Claude AI Code Generation Integration Workflows for APAC Teams

1mkdir claude-integration && cd claude-integration
2npm init -y
3npm install @anthropic-ai/sdk dotenv express
4touch .env server.js claude-workflow.js

1ANTHROPIC_API_KEY=sk-ant-your-key-here
2PORT=3001
3GITHUB_WEBHOOK_SECRET=your-webhook-secret
4WORKFLOW_ENV=staging

1const Anthropic = require('@anthropic-ai/sdk');
2require('dotenv').config();
3
4const client = new Anthropic.default({
5  apiKey: process.env.ANTHROPIC_API_KEY,
6});
7
8const WORKFLOW_CONFIGS = {
9  codeReview: {
10    model: 'claude-sonnet-4-20250514',
11    maxTokens: 4096,
12    systemPrompt: `You are a senior code reviewer for a distributed APAC engineering team.
13    Review code for: correctness, security vulnerabilities, performance,
14    and adherence to team conventions. Flag any hardcoded strings that
15    should support i18n. Output structured JSON with severity levels.`,
16  },
17  codeGeneration: {
18    model: 'claude-sonnet-4-20250514',
19    maxTokens: 8192,
20    systemPrompt: `You are a code generation assistant integrated into a CI/CD pipeline.
21    Generate production-ready code with error handling, TypeScript types,
22    and inline comments. Follow the project's existing patterns.
23    Always include unit test stubs alongside generated code.`,
24  },
25  prSummary: {
26    model: 'claude-sonnet-4-20250514',
27    maxTokens: 2048,
28    systemPrompt: `Summarize pull request changes for a non-technical product manager.
29    Highlight: what changed, why it matters, and any risks.
30    Keep summaries under 200 words. Use bullet points.`,
31  },
32};
33
34async function executeWorkflow(workflowType, userMessage, context = {}) {
35  const config = WORKFLOW_CONFIGS[workflowType];
36  if (!config) throw new Error(`Unknown workflow: ${workflowType}`);
37
38  const contextPrefix = context.filePath
39    ? `File: ${context.filePath}\nBranch: ${context.branch || 'main'}\n\n`
40    : '';
41
42  const response = await client.messages.create({
43    model: config.model,
44    max_tokens: config.maxTokens,
45    system: config.systemPrompt,
46    messages: [
47      {
48        role: 'user',
49        content: contextPrefix + userMessage,
50      },
51    ],
52  });
53
54  return {
55    workflow: workflowType,
56    output: response.content[0].text,
57    usage: {
58      inputTokens: response.usage.input_tokens,
59      outputTokens: response.usage.output_tokens,
60    },
61    timestamp: new Date().toISOString(),
62  };
63}
64
65module.exports = { executeWorkflow, WORKFLOW_CONFIGS };

1const express = require('express');
2const crypto = require('crypto');
3const { executeWorkflow } = require('./claude-workflow');
4require('dotenv').config();
5
6const app = express();
7app.use(express.json());
8
9// Verify GitHub webhook signatures
10function verifyGitHubSignature(req, res, next) {
11  const signature = req.headers['x-hub-signature-256'];
12  if (!signature && process.env.WORKFLOW_ENV === 'staging') {
13    return next(); // skip in staging
14  }
15  const hmac = crypto.createHmac('sha256', process.env.GITHUB_WEBHOOK_SECRET);
16  const digest = 'sha256=' + hmac.update(JSON.stringify(req.body)).digest('hex');
17  if (crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(digest))) {
18    return next();
19  }
20  return res.status(401).json({ error: 'Invalid signature' });
21}
22
23// Generic workflow endpoint
24app.post('/api/workflow/:type', async (req, res) => {
25  try {
26    const { type } = req.params;
27    const { message, context } = req.body;
28    const result = await executeWorkflow(type, message, context);
29    res.json(result);
30  } catch (error) {
31    res.status(500).json({ error: error.message });
32  }
33});
34
35// GitHub PR webhook handler
36app.post('/api/github/pr', verifyGitHubSignature, async (req, res) => {
37  const { action, pull_request } = req.body;
38  if (action !== 'opened' && action !== 'synchronize') {
39    return res.json({ skipped: true });
40  }
41
42  const prContent = `PR Title: ${pull_request.title}
43  Description: ${pull_request.body || 'No description'}
44  Changed files: ${pull_request.changed_files}
45  Additions: ${pull_request.additions}, Deletions: ${pull_request.deletions}`;
46
47  const summary = await executeWorkflow('prSummary', prContent, {
48    branch: pull_request.head.ref,
49  });
50
51  // In production, post this back to GitHub as a PR comment
52  console.log('PR Summary generated:', summary.output);
53  res.json(summary);
54});
55
56app.listen(process.env.PORT, () => {
57  console.log(`Claude workflow server running on port ${process.env.PORT}`);
58});

1node server.js &
2curl -X POST http://localhost:3001/api/workflow/codeReview \
3  -H "Content-Type: application/json" \
4  -d '{"message": "function getUser(id) { return fetch(`/api/users/${id}`).then(r => r.json()) }", "context": {"filePath": "src/api/users.js"}}'

1{
2  "name": "Claude PR Review Pipeline",
3  "nodes": [
4    {
5      "name": "GitHub Trigger",
6      "type": "n8n-nodes-base.githubTrigger",
7      "parameters": {
8        "owner": "your-org",
9        "repository": "your-repo",
10        "events": ["pull_request"]
11      }
12    },
13    {
14      "name": "Fetch PR Diff",
15      "type": "n8n-nodes-base.httpRequest",
16      "parameters": {
17        "method": "GET",
18        "url": "={{ $json.pull_request.diff_url }}",
19        "headers": {
20          "Authorization": "Bearer {{ $env.GITHUB_TOKEN }}"
21        }
22      }
23    },
24    {
25      "name": "Claude Code Review",
26      "type": "n8n-nodes-base.httpRequest",
27      "parameters": {
28        "method": "POST",
29        "url": "https://your-server.com/api/workflow/codeReview",
30        "body": {
31          "message": "={{ $json.data }}",
32          "context": {
33            "branch": "={{ $node['GitHub Trigger'].json.pull_request.head.ref }}"
34          }
35        }
36      }
37    },
38    {
39      "name": "Post Comment to GitHub",
40      "type": "n8n-nodes-base.github",
41      "parameters": {
42        "operation": "createComment",
43        "owner": "your-org",
44        "repository": "your-repo",
45        "issueNumber": "={{ $node['GitHub Trigger'].json.pull_request.number }}",
46        "body": "={{ $node['Claude Code Review'].json.output }}"
47      }
48    }
49  ]
50}

1#!/bin/bash
2# parallel-generate.sh — spawn isolated Claude Code generation tasks
3
4REPO_ROOT=$(git rev-parse --show-toplevel)
5BASE_BRANCH="main"
6
7# Create worktrees for parallel tasks
8git worktree add ../feature-auth feature/auth-refactor 2>/dev/null || \
9  git worktree add ../feature-auth -b feature/auth-refactor $BASE_BRANCH
10
11git worktree add ../feature-api feature/api-v2 2>/dev/null || \
12  git worktree add ../feature-api -b feature/api-v2 $BASE_BRANCH
13
14# Generate code in each worktree using Claude
15generate_in_worktree() {
16  local worktree_path=$1
17  local prompt_file=$2
18  local task_name=$3
19
20  echo "[$task_name] Starting code generation in $worktree_path"
21  cd "$worktree_path"
22
23  curl -s -X POST http://localhost:3001/api/workflow/codeGeneration \
24    -H "Content-Type: application/json" \
25    -d "{\"message\": \"$(cat $REPO_ROOT/prompts/$prompt_file)\", \"context\": {\"filePath\": \"$worktree_path\"}}" \
26    | jq -r '.output' > generated-code.ts
27
28  echo "[$task_name] Generation complete. Output: $worktree_path/generated-code.ts"
29}
30
31# Run in parallel
32generate_in_worktree "../feature-auth" "auth-refactor.md" "Auth" &
33generate_in_worktree "../feature-api" "api-v2.md" "API" &
34
35wait
36echo "All parallel generation tasks complete."

1const { execSync } = require('child_process');
2const fs = require('fs');
3
4async function validateGeneratedCode(code, language = 'typescript') {
5  const tempFile = `/tmp/claude-gen-${Date.now()}.${language === 'typescript' ? 'ts' : 'js'}`;
6
7  fs.writeFileSync(tempFile, code);
8
9  const checks = {
10    syntaxValid: false,
11    lintClean: false,
12    noSecurityFlags: false,
13    hasErrorHandling: false,
14  };
15
16  // Syntax check
17  try {
18    execSync(`npx tsc --noEmit --strict ${tempFile} 2>&1`);
19    checks.syntaxValid = true;
20  } catch (e) {
21    checks.syntaxValid = false;
22    checks.syntaxErrors = e.stdout?.toString() || e.message;
23  }
24
25  // ESLint check
26  try {
27    execSync(`npx eslint ${tempFile} 2>&1`);
28    checks.lintClean = true;
29  } catch (e) {
30    checks.lintClean = false;
31  }
32
33  // Basic security scan
34  const securityPatterns = [
35    /eval\s*\(/,
36    /innerHTML\s*=/,
37    /document\.write/,
38    /\bexec\s*\(/,
39  ];
40  checks.noSecurityFlags = !securityPatterns.some((p) => p.test(code));
41
42  // Error handling presence
43  checks.hasErrorHandling =
44    code.includes('try') || code.includes('catch') || code.includes('.catch(');
45
46  // Clean up
47  fs.unlinkSync(tempFile);
48
49  const passed = Object.values(checks).filter(v => v === true).length;
50  const total = Object.keys(checks).filter(k => typeof checks[k] === 'boolean').length;
51
52  return {
53    score: `${passed}/${total}`,
54    passed: passed === total,
55    checks,
56  };
57}
58
59module.exports = { executeWorkflow, validateGeneratedCode, WORKFLOW_CONFIGS };

1curl -X POST http://localhost:3001/api/workflow/codeGeneration \
2  -H "Content-Type: application/json" \
3  -d '{"message": "Create a rate limiter middleware for Express.js that supports per-IP and per-API-key limits with Redis backend"}' \
4  | jq '.output' | xargs -I {} node -e "const {validateGeneratedCode} = require('./claude-workflow'); validateGeneratedCode('{}').then(console.log)"

1// Add to WORKFLOW_CONFIGS in claude-workflow.js
2const MODEL_SELECTION = {
3  // Sonnet for speed-sensitive workflows (code review, PR summaries)
4  fast: 'claude-sonnet-4-20250514',
5  // Opus for complex generation (architecture decisions, large refactors)
6  thorough: 'claude-opus-4-20250514',
7  // Haiku for high-volume, simple tasks (commit message generation, linting)
8  bulk: 'claude-3-5-haiku-20241022',
9};
10
11function selectModel(workflowType, codeComplexity) {
12  if (workflowType === 'prSummary') return MODEL_SELECTION.fast;
13  if (codeComplexity > 500) return MODEL_SELECTION.thorough; // lines of code
14  return MODEL_SELECTION.fast;
15}

1version: '3.8'
2services:
3  claude-workflow:
4    build: .
5    ports:
6      - '3001:3001'
7    environment:
8      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
9      - GITHUB_WEBHOOK_SECRET=${GITHUB_WEBHOOK_SECRET}
10      - WORKFLOW_ENV=production
11      - NODE_ENV=production
12    healthcheck:
13      test: ['CMD', 'curl', '-f', 'http://localhost:3001/health']
14      interval: 30s
15      timeout: 10s
16      retries: 3
17    restart: unless-stopped
18    deploy:
19      resources:
20        limits:
21          memory: 512M
22          cpus: '0.5'

1FROM node:18-alpine
2WORKDIR /app
3COPY package*.json ./
4RUN npm ci --production
5COPY . .
6EXPOSE 3001
7CMD ["node", "server.js"]

1docker-compose up -d
2docker-compose logs -f claude-workflow

1// usage-tracker.js
2const usageLog = [];
3
4function trackUsage(workflowResult, teamMember = 'unknown') {
5  const costPerInputToken = 0.003 / 1000; // Claude Sonnet pricing
6  const costPerOutputToken = 0.015 / 1000;
7
8  const entry = {
9    timestamp: workflowResult.timestamp,
10    workflow: workflowResult.workflow,
11    teamMember,
12    inputTokens: workflowResult.usage.inputTokens,
13    outputTokens: workflowResult.usage.outputTokens,
14    estimatedCost:
15      workflowResult.usage.inputTokens * costPerInputToken +
16      workflowResult.usage.outputTokens * costPerOutputToken,
17  };
18
19  usageLog.push(entry);
20
21  // Weekly summary
22  if (usageLog.length % 100 === 0) {
23    const totalCost = usageLog.reduce((sum, e) => sum + e.estimatedCost, 0);
24    console.log(`Usage checkpoint: ${usageLog.length} calls, $${totalCost.toFixed(2)} total`);
25  }
26
27  return entry;
28}
29
30module.exports = { trackUsage, usageLog };