// agent-server/index.ts
import express from 'express';
import { Anthropic } from '@anthropic-ai/sdk';
import { SQS } from 'aws-sdk';

const app = express();
const client = new Anthropic();
const sqs = new SQS();

// Task queue URLs — these are your SQS queue endpoints
// Each queue corresponds to a phase of the factory
const PLANNING_QUEUE = 'https://sqs.us-east-1.amazonaws.com/123456789/planning-tasks';
const BUILD_QUEUE = 'https://sqs.us-east-1.amazonaws.com/123456789/build-tasks';
const REVIEW_QUEUE = 'https://sqs.us-east-1.amazonaws.com/123456789/review-tasks';
const DEPLOY_QUEUE = 'https://sqs.us-east-1.amazonaws.com/123456789/deploy-tasks';

// Middleware to parse JSON bodies
app.use(express.json());

// Receive a feature request from a human or upstream system
app.post('/api/feature-request', async (req, res) => {
  const { description } = req.body;
  
  // Send to planning queue
  // The planning agent will pick this up and break it into tasks
  await sqs.sendMessage({
    QueueUrl: PLANNING_QUEUE,
    MessageBody: JSON.stringify({ 
      featureDescription: description,
      requestedAt: new Date().toISOString()
    })
  }).promise();
  
  res.json({ status: 'queued', message: 'Feature request accepted' });
});

app.listen(3000, () => console.log('Agent server running on :3000'));

// agents/planning-agent.ts
import { Anthropic } from '@anthropic-ai/sdk';
import { SQS } from 'aws-sdk';
import { Pool } from 'pg';
import { v4 as uuid } from 'uuid';

const client = new Anthropic();
const sqs = new SQS();
const db = new Pool(); // PostgreSQL connection

const PLANNING_QUEUE = process.env.PLANNING_QUEUE_URL;
const BUILD_QUEUE = process.env.BUILD_QUEUE_URL;

interface PlanResponse {
  featureId: string;
  tasks: Array<{
    id: string;
    title: string;
    description: string;
    dependencies: string[];  // List of other task IDs this depends on
    estimatedTokens: number;  // Rough estimate of tokens needed to build this
  }>;
}

async function planningAgent() {
  try {
    // Poll planning queue (20-second timeout per AWS best practices)
    // Returns up to 10 messages at once
    const messages = await sqs.receiveMessage({
      QueueUrl: PLANNING_QUEUE,
      MaxNumberOfMessages: 10,
      WaitTimeSeconds: 20
    }).promise();
    
    if (!messages.Messages || messages.Messages.length === 0) {
      console.log('[planning] No tasks found, waiting...');
      return;
    }
    
    for (const message of messages.Messages) {
      const featureRequest = JSON.parse(message.Body);
      const planTaskId = uuid();
      
      try {
        // Write to database that we're processing this
        await db.query(
          'INSERT INTO agent_tasks (id, status, task_type, input) VALUES ($1, $2, $3, $4)',
          [planTaskId, 'in_progress', 'plan', JSON.stringify(featureRequest)]
        );
        
        // Call Claude to plan (Sonnet: $3/$15 per 1M tokens)
        // This prompt is carefully engineered to elicit structured, dependency-aware output
        const response = await client.messages.create({
          model: 'claude-3-5-sonnet-20241022',
          max_tokens: 2000,
          system: `You are a software architect. Your job is to convert feature descriptions into implementation tasks.
          
          Requirements:
          - Identify all tasks needed to complete the feature
          - Include clear dependencies between tasks (which tasks must complete before others start)
          - Estimate token complexity for each task (small: <500, medium: 500-1000, large: >1000)
          - Respond ONLY with valid JSON (no markdown, no extra text)
          
          JSON format: {
            "tasks": [
              {
                "id": "task-1",
                "title": "Short title",
                "description": "1-2 sentence description of what to build",
                "dependencies": ["task-0"] or [],
                "estimatedTokens": 500
              }
            ]
          }`,
          messages: [
            {
              role: 'user',
              content: `Feature: ${featureRequest.featureDescription}`
            }
          ]
        });
        
        // Extract the plan from Claude's response
        const planText = response.content[0].type === 'text' ? response.content[0].text : '';
        const plan = JSON.parse(planText) as PlanResponse;
        
        // Write each task to the build queue
        for (const task of plan.tasks) {
          await sqs.sendMessage({
            QueueUrl: BUILD_QUEUE,
            MessageBody: JSON.stringify({
              planTaskId,
              taskId: task.id,
              title: task.title,
              description: task.description,
              dependencies: task.dependencies,
              estimatedTokens: task.estimatedTokens,
              createdAt: new Date().toISOString()
            })
          }).promise();
        }
        
        // Log success
        const inputTokens = response.usage.input_tokens;
        const outputTokens = response.usage.output_tokens;
        const totalTokens = inputTokens + outputTokens;
        const costUsd = (inputTokens * 0.003 + outputTokens * 0.015) / 1_000_000;
        
        await db.query(
          `INSERT INTO agent_metrics 
           (agent_name, task_id, success, latency_ms, tokens_used, cost_usd) 
           VALUES ($1, $2, $3, $4, $5, $6)`,
          ['planner', planTaskId, true, 0, totalTokens, costUsd]
        );
        
        await db.query(
          `UPDATE agent_tasks 
           SET status = $1, output = $2, updated_at = NOW() 
           WHERE id = $3`,
          ['completed', JSON.stringify(plan), planTaskId]
        );
        
        console.log(`[planning] ✅ Decomposed "${featureRequest.featureDescription}" into ${plan.tasks.length} tasks`);
        
      } catch (error) {
        console.error('[planning] ❌ Error processing task:', error);
        await db.query(
          `UPDATE agent_tasks 
           SET status = $1, error = $2, retry_count = retry_count + 1, updated_at = NOW() 
           WHERE id = $3`,
          ['failed', String(error), planTaskId]
        );
      }
      
      // Delete the message from the queue so it's not processed again
      await sqs.deleteMessage({
        QueueUrl: PLANNING_QUEUE,
        ReceiptHandle: message.ReceiptHandle
      }).promise();
    }
  } catch (error) {
    console.error('[planning] Fatal error:', error);
    // Don't exit — loop again in 5 seconds and try again
  }
}

// Run continuously
setInterval(planningAgent, 5000);

// agents/builder-agent.ts
import { Anthropic } from '@anthropic-ai/sdk';
import { SQS } from 'aws-sdk';
import { Pool } from 'pg';
import { exec } from 'child_process';
import * as fs from 'fs';
import { v4 as uuid } from 'uuid';
import { promisify } from 'util';

const client = new Anthropic();
const sqs = new SQS();
const db = new Pool();
const execAsync = promisify(exec);

const BUILD_QUEUE = process.env.BUILD_QUEUE_URL;
const REVIEW_QUEUE = process.env.REVIEW_QUEUE_URL;

async function readExistingCode(): Promise<string> {
  // Read examples from the codebase so Claude can learn from existing patterns
  // This is called "in-context learning" — showing Claude examples helps it generate consistent code
  try {
    const files = fs.readdirSync('src').slice(0, 3); // First 3 files as examples
    let examples = '';
    for (const file of files) {
      if (file.endsWith('.ts') || file.endsWith('.tsx')) {
        const content = fs.readFileSync(`src/${file}`, 'utf-8').slice(0, 500);
        examples += `\n\n--- ${file} ---\n${content}`;
      }
    }
    return examples;
  } catch {
    return ''; // If we can't read examples, just continue
  }
}

async function builderAgent() {
  try {
    const messages = await sqs.receiveMessage({
      QueueUrl: BUILD_QUEUE,
      MaxNumberOfMessages: 1  // Process one task at a time (safer)
    }).promise();
    
    if (!messages.Messages) return;
    
    for (const message of messages.Messages) {
      const task = JSON.parse(message.Body);
      const buildTaskId = uuid();
      const branchName = `task-${task.taskId}`;
      
      try {
        await db.query(
          'INSERT INTO agent_tasks (id, status, task_type, input) VALUES ($1, $2, $3, $4)',
          [buildTaskId, 'in_progress', 'build', JSON.stringify(task)]
        );
        
        // Get examples from existing code
        const codeExamples = await readExistingCode();
        
        // Call Claude to generate code, tests, and docs
        // This prompt is extremely detailed to guide Claude toward production-quality output
        const response = await client.messages.create({
          model: 'claude-3-5-sonnet-20241022',
          max_tokens: 4000,
          system: `You are a senior developer. Generate production-quality code.
          
          Requirements:
          - Write tests FIRST, then implementation
          - Follow existing code patterns (examples provided)
          - Include error handling and edge cases
          - Add JSDoc comments for exported functions
          - Respond ONLY with valid JSON
          
          JSON format: {
            "test": "jest test code",
            "code": "implementation code",
            "documentation": "README or docstring updates"
          }`,
          messages: [
            {
              role: 'user',
              content: `Task: ${task.title}
              
Description: ${task.description}

Existing code patterns in this codebase:
${codeExamples}

Estimated token budget: ${task.estimatedTokens} tokens
Generate code under 500 lines total.`
            }
          ]
        });
        
        const generated = JSON.parse(
          response.content[0].type === 'text' ? response.content[0].text : ''
        );
        
        // Create feature branch
        await execAsync('git checkout main');
        await execAsync('git pull origin main');
        await execAsync(`git checkout -b ${branchName}`);
        
        // Write generated code to files
        // Determine file extension from project type
        const ext = fs.existsSync('tsconfig.json') ? 'ts' : 'js';
        
        fs.writeFileSync(`src/task-${task.taskId}.${ext}`, generated.code);
        fs.writeFileSync(`src/task-${task.taskId}.test.${ext}`, generated.test);
        
        if (generated.documentation) {
          fs.appendFileSync('README.md', `\n\n### ${task.title}\n${generated.documentation}`);
        }
        
        // Commit and push
        await execAsync('git add .');
        await execAsync(`git commit -m "feat: ${task.title} (automated)"`);
        await execAsync(`git push origin ${branchName}`);
        
        // Send to review queue
        await sqs.sendMessage({
          QueueUrl: REVIEW_QUEUE,
          MessageBody: JSON.stringify({
            buildTaskId,
            taskId: task.taskId,
            branchName,
            title: task.title,
            generatedAt: new Date().toISOString()
          })
        }).promise();
        
        // Log success
        const totalTokens = response.usage.input_tokens + response.usage.output_tokens;
        const costUsd = (response.usage.input_tokens * 0.003 + response.usage.output_tokens * 0.015) / 1_000_000;
        
        await db.query(
          `UPDATE agent_tasks 
           SET status = $1, output = $2, updated_at = NOW() 
           WHERE id = $3`,
          ['completed', JSON.stringify({ branchName, tasksGenerated: 1 }), buildTaskId]
        );
        
        await db.query(
          `INSERT INTO agent_metrics 
           (agent_name, task_id, success, tokens_used, cost_usd) 
           VALUES ($1, $2, $3, $4, $5)`,
          ['builder', buildTaskId, true, totalTokens, costUsd]
        );
        
        console.log(`[builder] ✅ Generated code for "${task.title}" on branch ${branchName}`);
        
      } catch (error) {
        console.error('[builder] ❌ Error:', error);
        await db.query(
          `UPDATE agent_tasks 
           SET status = $1, error = $2, retry_count = retry_count + 1 
           WHERE id = $3`,
          ['failed', String(error), buildTaskId]
        );
      }
      
      await sqs.deleteMessage({
        QueueUrl: BUILD_QUEUE,
        ReceiptHandle: message.ReceiptHandle
      }).promise();
    }
  } catch (error) {
    console.error('[builder] Fatal error:', error);
  }
}

setInterval(builderAgent, 10000);  // Poll every 10 seconds

import { renderHook, act } from '@testing-library/react';
import { useTheme, ThemeProvider } from './task-theme-context';

describe('ThemeContext', () => {
  it('should provide dark mode toggle', () => {
    const { result } = renderHook(() => useTheme(), {
      wrapper: ThemeProvider
    });
    
    expect(result.current.isDark).toBe(false);
    
    act(() => {
      result.current.toggleTheme();
    });
    
    expect(result.current.isDark).toBe(true);
  });
  
  it('should persist theme to localStorage', () => {
    localStorage.setItem('theme', 'dark');
    const { result } = renderHook(() => useTheme(), {
      wrapper: ThemeProvider
    });
    expect(result.current.isDark).toBe(true);
  });
});

import React, { createContext, useState, useContext, useEffect } from 'react';

export interface ThemeContextType {
  isDark: boolean;
  toggleTheme: () => void;
}

const ThemeContext = createContext<ThemeContextType | undefined>(undefined);

export const ThemeProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
  const [isDark, setIsDark] = useState(() => {
    const saved = localStorage.getItem('theme');
    return saved === 'dark';
  });
  
  useEffect(() => {
    localStorage.setItem('theme', isDark ? 'dark' : 'light');
  }, [isDark]);
  
  const toggleTheme = () => setIsDark(!isDark);
  
  return (
    <ThemeContext.Provider value={{ isDark, toggleTheme }}>
      {children}
    </ThemeContext.Provider>
  );
};

export const useTheme = (): ThemeContextType => {
  const context = useContext(ThemeContext);
  if (!context) {
    throw new Error('useTheme must be used within ThemeProvider');
  }
  return context;
};

// agents/reviewer-agent.ts
import { Anthropic } from '@anthropic-ai/sdk';
import { SQS } from 'aws-sdk';
import { Pool } from 'pg';
import { exec } from 'child_process';
import * as fs from 'fs';
import { v4 as uuid } from 'uuid';
import { promisify } from 'util';

const client = new Anthropic();
const sqs = new SQS();
const db = new Pool();
const execAsync = promisify(exec);

const REVIEW_QUEUE = process.env.REVIEW_QUEUE_URL;
const DEPLOY_QUEUE = process.env.DEPLOY_QUEUE_URL;
const BUILD_QUEUE = process.env.BUILD_QUEUE_URL;

async function runAutomatedChecks(branchName: string): Promise<{
  lintIssues: string[];
  testsPassed: boolean;
  coverage: number;
  securityWarnings: string[];
}> {
  const issues = {
    lintIssues: [] as string[],
    testsPassed: true,
    coverage: 0,
    securityWarnings: [] as string[]
  };
  
  try {
    // Run ESLint
    const { stderr: lintOutput } = await execAsync('npm run lint 2>&1 || true');
    if (lintOutput.includes('error')) {
      issues.lintIssues = lintOutput.split('\n').filter(l => l.includes('error')).slice(0, 5);
    }
    
    // Run tests
    const { exitCode } = await execAsync('npm run test 2>&1 || true');
    issues.testsPassed = exitCode === 0;
    
    // Get coverage
    const coverage = await execAsync('npm run coverage 2>&1 || true');
    const match = coverage.match(/(\d+)%/);
    issues.coverage = match ? parseInt(match[1]) : 0;
    
    // Security scan (OWASP, snyk, etc.)
    const security = await execAsync('npm audit 2>&1 || true');
    if (security.includes('vulnerabilities')) {
      issues.securityWarnings = security.split('\n').filter(l => l.includes('high')).slice(0, 3);
    }
  } catch (error) {
    console.error('[reviewer] Error running checks:', error);
  }
  
  return issues;
}

async function reviewerAgent() {
  try {
    const messages = await sqs.receiveMessage({
      QueueUrl: REVIEW_QUEUE,
      MaxNumberOfMessages: 3
    }).promise();
    
    if (!messages.Messages) return;
    
    for (const message of messages.Messages) {
      const reviewRequest = JSON.parse(message.Body);
      const reviewTaskId = uuid();
      const { branchName, taskId, title } = reviewRequest;
      
      try {
        await db.query(
          'INSERT INTO agent_tasks (id, status, task_type, input) VALUES ($1, $2, $3, $4)',
          [reviewTaskId, 'in_progress', 'review', JSON.stringify(reviewRequest)]
        );
        
        // Fetch the branch
        await execAsync(`git fetch origin ${branchName}`);
        await execAsync(`git checkout ${branchName}`);
        
        // Read the generated code
        const generatedFiles = fs.readdirSync('src')
          .filter(f => f.includes(taskId))
          .map(f => ({
            name: f,
            content: fs.readFileSync(`src/${f}`, 'utf-8')
          }));
        
        // Run automated checks
        const checks = await runAutomatedChecks(branchName);
        
        // Prepare code for LLM review (summarize if large)
        let codeSummary = '';
        for (const file of generatedFiles) {
          const lines = file.content.split('\n').length;
          codeSummary += `\n\n--- ${file.name} (${lines} lines) ---\n`;
          codeSummary += file.content.slice(0, 1500); // First 1500 chars
        }
        
        // Call Claude for comprehensive review
        const response = await client.messages.create({
          model: 'claude-3-5-sonnet-20241022',
          max_tokens: 2000,
          system: `You are a code reviewer. Review the generated code for:
          
          1. Security issues (hardcoded secrets, injection attacks, authentication gaps)
          2. Performance problems (N+1 queries, memory leaks, inefficient algorithms)
          3. Logic correctness (does the code do what the tests expect?)
          4. Code quality (readability, maintainability, consistency with existing patterns)
          
          Respond ONLY with valid JSON:
          {
            "approved": boolean,
            "confidence": 0-100,
            "issues": ["issue 1", "issue 2"],
            "suggestions": ["suggestion 1"],
            "summary": "brief summary of review"
          }`,
          messages: [
            {
              role: 'user',
              content: `Task: ${title}
              
Generated code to review:
${codeSummary}

Automated checks results:
- Lint issues: ${checks.lintIssues.length > 0 ? checks.lintIssues.join('; ') : 'none'}
- Tests passed: ${checks.testsPassed}
- Coverage: ${checks.coverage}%
- Security warnings: ${checks.securityWarnings.length > 0 ? checks.securityWarnings.join('; ') : 'none'}`
            }
          ]
        });
        
        const review = JSON.parse(
          response.content[0].type === 'text' ? response.content[0].text : ''
        );
        
        const approved = review.approved && review.confidence > 80 && checks.testsPassed;
        
        if (approved) {
          // Send to deploy queue
          console.log(`[reviewer] ✅ APPROVED: "${title}" (confidence: ${review.confidence}%)`);
          
          await sqs.sendMessage({
            QueueUrl: DEPLOY_QUEUE,
            MessageBody: JSON.stringify({
              reviewTaskId,
              taskId,
              branchName,
              title,
              reviewResult: review
            })
          }).promise();
          
          await db.query(
            `UPDATE agent_tasks 
             SET status = $1, output = $2 
             WHERE id = $3`,
            ['completed', JSON.stringify(review), reviewTaskId]
          );
          
        } else {
          // Send feedback back to builder
          console.log(`[reviewer] ❌ REJECTED: "${title}"`);
          console.log(`  Issues: ${review.issues.join(', ')}`);
          
          // Create a revision task for the builder
          await sqs.sendMessage({
            QueueUrl: BUILD_QUEUE,
            MessageBody: JSON.stringify({
              taskId,
              title: `Revise: ${title}`,
              description: `Reviewer feedback: ${review.issues.join('; ')}`,
              revisionFeedback: review.issues,
              previousBranch: branchName
            })
          }).promise();
          
          await db.query(
            `UPDATE agent_tasks 
             SET status = $1, output = $2, error = $3
             WHERE id = $4`,
            ['failed', JSON.stringify(review), review.issues.join('; '), reviewTaskId]
          );
        }
        
        // Log metrics
        const totalTokens = response.usage.input_tokens + response.usage.output_tokens;
        const costUsd = (response.usage.input_tokens * 0.003 + response.usage.output_tokens * 0.015) / 1_000_000;
        
        await db.query(
          `INSERT INTO agent_metrics 
           (agent_name, task_id, success, tokens_used, cost_usd) 
           VALUES ($1, $2, $3, $4, $5)`,
          ['reviewer', reviewTaskId, approved, totalTokens, costUsd]
        );
        
      } catch (error) {
        console.error('[reviewer] ❌ Error:', error);
        await db.query(
          `UPDATE agent_tasks 
           SET status = $1, error = $2, retry_count = retry_count + 1 
           WHERE id = $3`,
          ['failed', String(error), reviewTaskId]
        );
      }
      
      await sqs.deleteMessage({
        QueueUrl: REVIEW_QUEUE,
        ReceiptHandle: message.ReceiptHandle
      }).promise();
    }
  } catch (error) {
    console.error('[reviewer] Fatal error:', error);
  }
}

setInterval(reviewerAgent, 15000);  // Poll every 15 seconds

// agents/integrator-agent.ts
import { Anthropic } from '@anthropic-ai/sdk';
import { SQS } from 'aws-sdk';
import { Pool } from 'pg';
import { exec } from 'child_process';
import { v4 as uuid } from 'uuid';
import { promisify } from 'util';

const client = new Anthropic();
const sqs = new SQS();
const db = new Pool();
const execAsync = promisify(exec);

const DEPLOY_QUEUE = process.env.DEPLOY_QUEUE_URL;
const MONITORING_WEBHOOK = process.env.SLACK_WEBHOOK_URL;

async function sleep(ms: number) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function notifySlack(message: string) {
  try {
    await execAsync(
      `curl -X POST ${MONITORING_WEBHOOK} -d '{"text":"[Integrator] ${message}"}'`
    );
  } catch (error) {
    console.error('Slack notification failed (non-fatal)');
  }
}

async function integratorAgent() {
  try {
    const messages = await sqs.receiveMessage({
      QueueUrl: DEPLOY_QUEUE,
      MaxNumberOfMessages: 1  // One deployment at a time
    }).promise();
    
    if (!messages.Messages) return;
    
    for (const message of messages.Messages) {
      const deployRequest = JSON.parse(message.Body);
      const deployTaskId = uuid();
      const { branchName, taskId, title, reviewResult } = deployRequest;
      
      let deploymentStatus = 'in_progress';
      let errorMessage = '';
      
      try {
        await db.query(
          'INSERT INTO agent_tasks (id, status, task_type, input) VALUES ($1, $2, $3, $4)',
          [deployTaskId, 'in_progress', 'deploy', JSON.stringify(deployRequest)]
        );
        
        // Step 1: Fetch branch and merge to main
        console.log(`[integrator] 🔄 Starting deployment of "${title}"`);
        await notifySlack(`🚀 Starting deployment of "${title}" from ${branchName}`);
        
        await execAsync('git fetch origin');
        await execAsync('git checkout main');
        await execAsync('git pull origin main');
        
        // Step 2: Merge branch
        try {
          await execAsync(`git merge origin/${branchName} --no-ff -m "Merge ${branchName}"`);
        } catch (error) {
          throw new Error(`Merge conflict on ${branchName}: ${error}`);
        }
        
        // Step 3: Run full test suite (final safety gate)
        console.log('[integrator] 🧪 Running full test suite...');
        try {
          await execAsync('npm run test:ci');  // CI-mode tests (no watch)
        } catch (error) {
          throw new Error(`Tests failed after merge: ${error}`);
        }
        
        // Step 4: Build Docker image
        const commitHash = (await execAsync('git rev-parse --short HEAD')).stdout.trim();
        const imageTag = `${process.env.REGISTRY}/${process.env.IMAGE_NAME}:${commitHash}`;
        
        console.log(`[integrator] 🐳 Building Docker image: ${imageTag}`);
        await execAsync(`docker build -t ${imageTag} .`);
        await execAsync(`docker push ${imageTag}`);
        
        // Step 5: Deploy to staging
        console.log('[integrator] 📦 Deploying to staging...');
        const stagingYaml = `
apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-staging
spec:
  replicas: 1
  template:
    spec:
      containers:
      - name: app
        image: ${imageTag}
`;
        await execAsync(`echo '${stagingYaml}' | kubectl apply -f - --namespace=staging`);
        await execAsync('kubectl rollout status deployment/app-staging -n staging --timeout=5m');
        
        // Step 6: Wait for staging to be healthy
        await sleep(3000);
        
        // Step 7: Run smoke tests
        console.log('[integrator] 🔥 Running smoke tests on staging...');
        try {
          await execAsync('npm run test:e2e:staging --bail');
        } catch (error) {
          throw new Error(`Smoke tests failed on staging: ${error}`);
        }
        
        // Step 8: Deploy to production (canary: 5% traffic)
        console.log('[integrator] 🌍 Deploying to production (canary 5%)...');
        const productionYaml = `
apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-production
spec:
  replicas: 20
  template:
    spec:
      containers:
      - name: app
        image: ${imageTag}
---
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: app-canary
spec:
  hosts:
  - app.example.com
  http:
  - match:
    - uri:
        prefix: /
    route:
    - destination:
        host: app-production
      weight: 5  # 5% traffic to new version
    - destination:
        host: app-production-stable
      weight: 95  # 95% traffic to stable version
`;
        await execAsync(`echo '${productionYaml}' | kubectl apply -f - --namespace=production`);
        
        // Step 9: Monitor for 15 minutes
        console.log('[integrator] 📊 Monitoring canary deployment (15 min)...');
        const startTime = Date.now();
        const monitorDuration = 15 * 60 * 1000;  // 15 minutes
        let errorRateExceeded = false;
        
        while (Date.now() - startTime < monitorDuration) {
          // Get error rate from monitoring system
          const errorRate = await execAsync(
            `curl -s 'https://monitoring.example.com/api/error-rate?service=app&window=1m' | jq .error_rate`
          );
          
          const rate = parseFloat(errorRate.stdout);
          console.log(`[integrator] Error rate: ${rate.toFixed(2)}%`);
          
          if (rate > 1.0) {  // Error rate threshold
            console.error(`[integrator] ❌ Error rate ${rate}% exceeds threshold 1%!`);
            errorRateExceeded = true;
            break;
          }
          
          await sleep(60000);  // Check every 60 seconds
        }
        
        if (errorRateExceeded) {
          throw new Error(`Production error rate exceeded threshold (${rate}%)`);
        }
        
        // Step 10: Rollout to 100%
        console.log('[integrator] ✅ Canary stable, rolling out to 100%');
        const fullRolloutYaml = `
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: app-canary
spec:
  hosts:
  - app.example.com
  http:
  - match:
    - uri:
        prefix: /
    route:
    - destination:
        host: app-production
      weight: 100
`;
        await execAsync(`echo '${fullRolloutYaml}' | kubectl apply -f - --namespace=production`);
        
        // Step 11: Clean up feature branch
        await execAsync(`git push origin --delete ${branchName}`);
        
        // Step 12: Push main
        await execAsync('git push origin main');
        
        deploymentStatus = 'completed';
        console.log(`[integrator] ✅ Successfully deployed "${title}"`);
        await notifySlack(`✅ Successfully deployed "${title}" to production. Commit: ${commitHash}`);
        
      } catch (error) {
        deploymentStatus = 'failed';
        errorMessage = String(error);
        
        console.error(`[integrator] ❌ Deployment failed: ${error}`);
        await notifySlack(`❌ Deployment of "${title}" FAILED: ${error}`);
        
        // Rollback: revert the merge
        try {
          console.log('[integrator] 🔄 Attempting rollback...');
          await execAsync('git revert HEAD --no-edit');
          await execAsync('git push origin main');
          await execAsync('kubectl rollout undo deployment/app-production -n production');
          await notifySlack('✅ Rollback completed');
        } catch (rollbackError) {
          await notifySlack(`❌ ROLLBACK FAILED: ${rollbackError}`);
        }
      }
      
      // Log result
      await db.query(
        `UPDATE agent_tasks 
         SET status = $1, output = $2, error = $3, updated_at = NOW()
         WHERE id = $4`,
        [deploymentStatus, JSON.stringify({ title, deployed: deploymentStatus === 'completed' }), errorMessage, deployTaskId]
      );
      
      await db.query(
        `INSERT INTO agent_metrics (agent_name, task_id, success) 
         VALUES ($1, $2, $3)`,
        ['integrator', deployTaskId, deploymentStatus === 'completed']
      );
      
      await sqs.deleteMessage({
        QueueUrl: DEPLOY_QUEUE,
        ReceiptHandle: message.ReceiptHandle
      }).promise();
    }
  } catch (error) {
    console.error('[integrator] Fatal error:', error);
  }
}

// Run integrator every 30 seconds (check for new deployments)
setInterval(integratorAgent, 30000);

// agents/monitoring-agent.ts
import { Pool } from 'pg';
import axios from 'axios';
import * as fs from 'fs';

const db = new Pool();
const SLACK_WEBHOOK = process.env.SLACK_WEBHOOK_URL;
const PAGERDUTY_KEY = process.env.PAGERDUTY_KEY;

interface FactoryMetrics {
  tasksCompleted24h: number;
  autonomousRate: number;  // percent
  deploymentSuccessRate: number;
  avgCostPerFeature: number;
  agentHealth: Record<string, { status: string; lastSeen: Date; errorRate: number }>;
}

async function collectMetrics(): Promise<FactoryMetrics> {
  // Query last 24 hours of task data
  const tasks = await db.query(
    `SELECT agent_name, status, COUNT(*) as count 
     FROM agent_tasks 
     WHERE created_at > NOW() - INTERVAL '24 hours'
     GROUP BY agent_name, status`
  );
  
  const completed = tasks.rows.filter(r => r.status === 'completed').reduce((sum, r) => sum + r.count, 0);
  const total = tasks.rows.reduce((sum, r) => sum + r.count, 0);
  
  // Get cost data
  const costs = await db.query(
    `SELECT SUM(cost_usd) as total_cost, COUNT(*) as task_count 
     FROM agent_metrics 
     WHERE created_at > NOW() - INTERVAL '24 hours'`
  );
  
  const costData = costs.rows[0];
  const totalCost = costData?.total_cost || 0;
  const costPerFeature = costData?.task_count ? totalCost / costData.task_count : 0;
  
  // Get agent health
  const agentHealth: Record<string, any> = {};
  for (const agent of ['planning', 'builder', 'reviewer', 'integrator']) {
    const lastTask = await db.query(
      `SELECT updated_at, success FROM agent_tasks 
       WHERE task_type = $1 
       ORDER BY updated_at DESC 
       LIMIT 1`,
      [agent]
    );
    
    const lastSeen = lastTask.rows[0]?.updated_at || null;
    const recentTasks = await db.query(
      `SELECT success, COUNT(*) as count 
       FROM agent_tasks 
       WHERE task_type = $1 AND updated_at > NOW() - INTERVAL '1 hour'
       GROUP BY success`,
      [agent]
    );
    
    const successful = recentTasks.rows.find(r => r.success === true)?.count || 0;
    const failed = recentTasks.rows.find(r => r.success === false)?.count || 0;
    const errorRate = (successful + failed) > 0 ? (failed / (successful + failed)) * 100 : 0;
    
    agentHealth[agent] = {
      status: lastSeen && new Date().getTime() - new Date(lastSeen).getTime() < 300000 ? 'healthy' : 'stalled',
      lastSeen,
      errorRate
    };
  }
  
  return {
    tasksCompleted24h: completed,
    autonomousRate: (completed / total) * 100,
    deploymentSuccessRate: agentHealth['integrator'].errorRate === 0 ? 100 : 0,
    avgCostPerFeature: costPerFeature,
    agentHealth
  };
}

async function checkAlerts(metrics: FactoryMetrics) {
  const alerts = [];
  
  // Check if planning agent is stalled
  if (metrics.agentHealth.planning.status === 'stalled') {
    alerts.push({
      severity: 'warning',
      message: '⚠️ Planning agent has not processed a task in 5 minutes'
    });
  }
  
  // Check if builder quality degraded
  if (metrics.agentHealth.builder.errorRate > 40) {
    alerts.push({
      severity: 'critical',
      message: `❌ Builder error rate high: ${metrics.agentHealth.builder.errorRate.toFixed(1)}%`
    });
  }
  
  // Check if deployment success rate is poor
  if (metrics.deploymentSuccessRate < 90) {
    alerts.push({
      severity: 'critical',
      message: `❌ Deployment success rate: ${metrics.deploymentSuccessRate.toFixed(1)}% (target: 95%)`
    });
  }
  
  return alerts;
}

async function publishMetrics(metrics: FactoryMetrics) {
  // Send to DataDog
  try {
    await axios.post('https://api.datadoghq.com/api/v1/series', {
      series: [
        {
          metric: 'factory.tasks.completed',
          points: [[Date.now() / 1000, metrics.tasksCompleted24h]],
          tags: ['env:production']
        },
        {
          metric: 'factory.pr.autonomous_rate',
          points: [[Date.now() / 1000, metrics.autonomousRate]],
          tags: ['env:production']
        },
        {
          metric: 'factory.cost.per_feature',
          points: [[Date.now() / 1000, metrics.avgCostPerFeature]],
          tags: ['env:production']
        }
      ]
    }, {
      headers: { 'DD-API-KEY': process.env.DATADOG_API_KEY }
    });
  } catch (error) {
    console.error('DataDog publish failed:', error);
  }
}

async function notifySlack(message: string, severity: 'info' | 'warning' | 'critical') {
  const colors = {
    info: '#36a64f',
    warning: '#ff9900',
    critical: '#ff0000'
  };
  
  try {
    await axios.post(SLACK_WEBHOOK, {
      attachments: [{
        color: colors[severity],
        title: `[${severity.toUpperCase()}] Autonomous Factory`,
        text: message,
        ts: Math.floor(Date.now() / 1000)
      }]
    });
  } catch (error) {
    console.error('Slack notification failed:', error);
  }
}

async function monitoringAgent() {
  try {
    const metrics = await collectMetrics();
    
    // Log metrics to console
    console.log('[monitoring] 📊 Factory Metrics:');
    console.log(`  Tasks completed (24h): ${metrics.tasksCompleted24h}`);
    console.log(`  Autonomous rate: ${metrics.autonomousRate.toFixed(1)}%`);
    console.log(`  Deployment success: ${metrics.deploymentSuccessRate.toFixed(1)}%`);
    console.log(`  Cost/feature: $${metrics.avgCostPerFeature.toFixed(2)}`);
    console.log(`  Agent health:`, metrics.agentHealth);
    
    // Publish to monitoring system
    await publishMetrics(metrics);
    
    // Check for alerts
    const alerts = await checkAlerts(metrics);
    
    for (const alert of alerts) {
      console.warn(`[monitoring] ${alert.message}`);
      await notifySlack(alert.message, alert.severity as any);
    }
    
  } catch (error) {
    console.error('[monitoring] Fatal error:', error);
  }
}

// Run monitoring every 60 seconds
setInterval(monitoringAgent, 60000);