codebakers 2.0.3 → 2.0.10

package/src/commands/build.ts

@@ -0,0 +1,989 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import Anthropic from '@anthropic-ai/sdk';
+import { execa } from 'execa';
+import { Config } from '../utils/config.js';
+import { EventEmitter } from 'events';
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
+interface AgentTask {
+  id: string;
+  name: string;
+  description: string;
+  folder: string;
+  dependencies: string[];
+  exports: string[];
+  status: 'waiting' | 'running' | 'done' | 'error' | 'healing' | 'asking';
+  progress: number;
+  currentAction: string;
+  branch: string;
+  files: string[];
+  error?: string;
+  healAttempts: number;
+}
+
+interface BuildWave {
+  wave: number;
+  agents: AgentTask[];
+  parallel: boolean;
+}
+
+interface BuildPlan {
+  projectName: string;
+  description: string;
+  sharedSetup: {
+    types: string[];
+    components: string[];
+    conventions: string;
+  };
+  waves: BuildWave[];
+}
+
+interface HealerSolution {
+  canFix: boolean;
+  solution: string;
+  type: 'retry' | 'modify-code' | 'wait' | 'skip-optional' | 'generate-missing';
+  newCode?: string;
+  waitTime?: number;
+  description: string;
+}
+
+interface UserQuestion {
+  question: string;
+  options: string[];
+  context?: string;
+}
+
+// Global flag to pause/resume display during questions
+let displayPaused = false;
+
+// ============================================================================
+// MAIN BUILD COMMAND
+// ============================================================================
+
+export async function buildCommand(prdPath?: string, options: { sequential?: boolean } = {}): Promise<void> {
+  const config = new Config();
+
+  if (!config.isConfigured()) {
+    p.log.error('Please run `codebakers setup` first.');
+    return;
+  }
+
+  const anthropicCreds = config.getCredentials('anthropic');
+  if (!anthropicCreds?.apiKey) {
+    p.log.error('Anthropic API key not configured.');
+    return;
+  }
+
+  // Get PRD file
+  let prdFile = prdPath;
+  if (!prdFile) {
+    const file = await p.text({
+      message: 'Path to PRD file:',
+      placeholder: './my-app-prd.md',
+      validate: (v) => !v ? 'PRD file required' : undefined,
+    });
+    if (p.isCancel(file)) return;
+    prdFile = file as string;
+  }
+
+  // Read PRD
+  if (!await fs.pathExists(prdFile)) {
+    p.log.error(`PRD file not found: ${prdFile}`);
+    return;
+  }
+
+  const prdContent = await fs.readFile(prdFile, 'utf-8');
+
+  console.log(chalk.cyan(`
+╔═══════════════════════════════════════════════════════════════╗
+║  🚀 CODEBAKERS PARALLEL BUILD                                 ║
+╚═══════════════════════════════════════════════════════════════╝
+`));
+
+  const anthropic = new Anthropic({ apiKey: anthropicCreds.apiKey });
+
+  // Step 1: Analyze PRD and create build plan
+  const spinner = p.spinner();
+  spinner.start('Analyzing PRD...');
+  
+  const buildPlan = await analyzePRD(anthropic, prdContent);
+  
+  spinner.stop('PRD analyzed');
+
+  // Show build plan
+  displayBuildPlan(buildPlan);
+
+  // Check if parallel makes sense
+  const totalAgents = buildPlan.waves.reduce((sum, w) => sum + w.agents.length, 0);
+  const useParallel = !options.sequential && totalAgents > 2;
+
+  if (!useParallel) {
+    console.log(chalk.dim('\nUsing sequential build (parallel not needed for small projects)\n'));
+  }
+
+  // Confirm
+  const proceed = await p.confirm({
+    message: `Start ${useParallel ? 'parallel' : 'sequential'} build?`,
+    initialValue: true,
+  });
+
+  if (!proceed || p.isCancel(proceed)) {
+    p.cancel('Build cancelled');
+    return;
+  }
+
+  // Step 2: Create project directory
+  const projectPath = path.join(process.cwd(), buildPlan.projectName);
+  
+  if (await fs.pathExists(projectPath)) {
+    const overwrite = await p.confirm({
+      message: `${buildPlan.projectName} already exists. Overwrite?`,
+      initialValue: false,
+    });
+    if (!overwrite || p.isCancel(overwrite)) return;
+    await fs.remove(projectPath);
+  }
+
+  await fs.ensureDir(projectPath);
+  process.chdir(projectPath);
+
+  // Step 3: Initialize git
+  spinner.start('Initializing project...');
+  await execa('git', ['init'], { cwd: projectPath });
+  spinner.stop('Project initialized');
+
+  // Step 4: Run setup phase (shared code)
+  await runSetupPhase(anthropic, buildPlan, projectPath);
+
+  // Step 5: Execute build waves
+  const startTime = Date.now();
+  
+  if (useParallel) {
+    await executeParallelBuild(anthropic, buildPlan, projectPath, config);
+  } else {
+    await executeSequentialBuild(anthropic, buildPlan, projectPath, config);
+  }
+
+  // Step 6: Integration phase
+  await runIntegrationPhase(anthropic, buildPlan, projectPath);
+
+  // Step 7: Final setup
+  spinner.start('Installing dependencies...');
+  await execa('npm', ['install'], { cwd: projectPath, reject: false });
+  spinner.stop('Dependencies installed');
+
+  // Done!
+  const elapsed = Math.round((Date.now() - startTime) / 1000);
+  const minutes = Math.floor(elapsed / 60);
+  const seconds = elapsed % 60;
+
+  console.log(chalk.green(`
+╔═══════════════════════════════════════════════════════════════╗
+║  ✅ BUILD COMPLETE                                            ║
+╠═══════════════════════════════════════════════════════════════╣
+║                                                               ║
+║  Project:  ${buildPlan.projectName.padEnd(46)}║
+║  Time:     ${(minutes + 'm ' + seconds + 's').padEnd(46)}║
+║  Features: ${(buildPlan.waves.reduce((s, w) => s + w.agents.length, 0) + ' built').padEnd(46)}║
+║                                                               ║
+║  Next steps:                                                  ║
+║    cd ${buildPlan.projectName.padEnd(52)}║
+║    npm run dev                                                ║
+║                                                               ║
+╚═══════════════════════════════════════════════════════════════╝
+`));
+}
+
+// ============================================================================
+// PRD ANALYZER
+// ============================================================================
+
+async function analyzePRD(anthropic: Anthropic, prdContent: string): Promise<BuildPlan> {
+  const response = await anthropic.messages.create({
+    model: 'claude-sonnet-4-20250514',
+    max_tokens: 4096,
+    messages: [{
+      role: 'user',
+      content: `Analyze this PRD and create a build plan with parallel-safe task assignment.
+
+PRD:
+${prdContent}
+
+Rules:
+1. Each feature gets its own folder (src/features/[name])
+2. Features with no dependencies can run in parallel
+3. Features that depend on others must wait
+4. Group into "waves" - each wave runs after previous completes
+5. Maximum 3 agents per wave
+
+Return JSON only:
+{
+  "projectName": "kebab-case-name",
+  "description": "one line description",
+  "sharedSetup": {
+    "types": ["User", "Invoice", etc - shared types needed],
+    "components": ["Button", "Card", etc - shared UI needed],
+    "conventions": "Next.js App Router, TypeScript, Tailwind, shadcn/ui"
+  },
+  "waves": [
+    {
+      "wave": 1,
+      "parallel": true,
+      "agents": [
+        {
+          "id": "auth",
+          "name": "Authentication",
+          "description": "Login, signup, session management",
+          "folder": "src/features/auth",
+          "dependencies": [],
+          "exports": ["AuthProvider", "useAuth", "LoginForm"]
+        }
+      ]
+    }
+  ]
+}
+
+Think about:
+- What MUST come first (auth, database setup)?
+- What can run at the same time (independent features)?
+- What needs data from other features (dashboards, reports)?`
+    }],
+  });
+
+  const text = response.content[0].type === 'text' ? response.content[0].text : '';
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  
+  if (!jsonMatch) {
+    throw new Error('Failed to parse PRD analysis');
+  }
+
+  const plan = JSON.parse(jsonMatch[0]) as BuildPlan;
+
+  // Initialize agent task fields
+  for (const wave of plan.waves) {
+    for (const agent of wave.agents) {
+      (agent as AgentTask).status = 'waiting';
+      (agent as AgentTask).progress = 0;
+      (agent as AgentTask).currentAction = '';
+      (agent as AgentTask).branch = `codebakers/${agent.id}`;
+      (agent as AgentTask).files = [];
+      (agent as AgentTask).healAttempts = 0;
+    }
+  }
+
+  return plan;
+}
+
+// ============================================================================
+// DISPLAY
+// ============================================================================
+
+function displayBuildPlan(plan: BuildPlan): void {
+  console.log(chalk.bold(`\n📋 Build Plan: ${plan.projectName}\n`));
+  console.log(chalk.dim(`   ${plan.description}\n`));
+
+  for (const wave of plan.waves) {
+    const parallel = wave.parallel && wave.agents.length > 1;
+    const mode = parallel ? chalk.green('parallel') : chalk.yellow('sequential');
+    
+    console.log(chalk.bold(`   Wave ${wave.wave} (${mode}):`));
+    
+    for (const agent of wave.agents) {
+      const deps = agent.dependencies.length > 0 
+        ? chalk.dim(` ← needs: ${agent.dependencies.join(', ')}`)
+        : '';
+      console.log(`     • ${agent.name} ${deps}`);
+    }
+    console.log('');
+  }
+
+  const totalAgents = plan.waves.reduce((sum, w) => sum + w.agents.length, 0);
+  const parallelWaves = plan.waves.filter(w => w.parallel && w.agents.length > 1).length;
+  
+  console.log(chalk.dim(`   Total: ${totalAgents} features, ${plan.waves.length} waves, ${parallelWaves} parallel\n`));
+}
+
+// ============================================================================
+// SETUP PHASE
+// ============================================================================
+
+async function runSetupPhase(
+  anthropic: Anthropic, 
+  plan: BuildPlan, 
+  projectPath: string
+): Promise<void> {
+  const spinner = p.spinner();
+  spinner.start('Setting up project structure...');
+
+  // Create base structure
+  await fs.ensureDir(path.join(projectPath, 'src/app'));
+  await fs.ensureDir(path.join(projectPath, 'src/components/ui'));
+  await fs.ensureDir(path.join(projectPath, 'src/lib'));
+  await fs.ensureDir(path.join(projectPath, 'src/types'));
+  await fs.ensureDir(path.join(projectPath, 'src/features'));
+  await fs.ensureDir(path.join(projectPath, '.codebakers'));
+
+  // Generate shared setup code
+  const setupResponse = await anthropic.messages.create({
+    model: 'claude-sonnet-4-20250514',
+    max_tokens: 8192,
+    messages: [{
+      role: 'user',
+      content: `Generate the shared setup files for this project.
+
+Project: ${plan.projectName}
+Description: ${plan.description}
+Conventions: ${plan.sharedSetup.conventions}
+Shared Types: ${plan.sharedSetup.types.join(', ')}
+Shared Components: ${plan.sharedSetup.components.join(', ')}
+
+Generate these files:
+
+1. package.json (Next.js 14, TypeScript, Tailwind, shadcn/ui)
+2. tsconfig.json
+3. tailwind.config.ts
+4. src/lib/utils.ts (cn helper)
+5. src/types/index.ts (shared types)
+6. src/app/layout.tsx (basic layout)
+7. src/app/page.tsx (simple home page placeholder)
+8. .env.example
+9. CLAUDE.md (CodeBakers patterns)
+
+Output format:
+<<<FILE: path/to/file>>>
+content
+<<<END_FILE>>>
+
+Use TypeScript. Include all necessary imports.`
+    }],
+  });
+
+  const setupText = setupResponse.content[0].type === 'text' ? setupResponse.content[0].text : '';
+  await writeFilesFromResponse(setupText, projectPath);
+
+  // Initial git commit
+  await execa('git', ['add', '.'], { cwd: projectPath });
+  await execa('git', ['commit', '-m', 'Initial setup'], { cwd: projectPath });
+
+  spinner.stop('Project structure ready');
+}
+
+// ============================================================================
+// PARALLEL BUILD EXECUTION
+// ============================================================================
+
+async function executeParallelBuild(
+  anthropic: Anthropic,
+  plan: BuildPlan,
+  projectPath: string,
+  config: Config
+): Promise<void> {
+  for (const wave of plan.waves) {
+    console.log(chalk.bold(`\n🏗️  Wave ${wave.wave} of ${plan.waves.length}`));
+    
+    if (wave.parallel && wave.agents.length > 1) {
+      console.log(chalk.dim(`   Running ${wave.agents.length} agents in parallel\n`));
+      await executeWaveParallel(anthropic, wave.agents as AgentTask[], projectPath, plan);
+    } else {
+      console.log(chalk.dim(`   Running sequentially\n`));
+      for (const agent of wave.agents) {
+        await executeAgent(anthropic, agent as AgentTask, projectPath, plan);
+      }
+    }
+
+    // Merge all branches from this wave
+    await mergeWaveBranches(wave.agents as AgentTask[], projectPath);
+  }
+}
+
+async function executeWaveParallel(
+  anthropic: Anthropic,
+  agents: AgentTask[],
+  projectPath: string,
+  plan: BuildPlan
+): Promise<void> {
+  // Create progress display
+  const display = new ProgressDisplay(agents);
+  display.start();
+
+  // Run agents in parallel
+  const promises = agents.map(agent => 
+    executeAgentWithProgress(anthropic, agent, projectPath, plan, display)
+  );
+
+  await Promise.all(promises);
+  
+  display.stop();
+}
+
+async function executeAgentWithProgress(
+  anthropic: Anthropic,
+  agent: AgentTask,
+  projectPath: string,
+  plan: BuildPlan,
+  display: ProgressDisplay
+): Promise<void> {
+  agent.status = 'running';
+  display.update();
+
+  try {
+    await executeAgent(anthropic, agent, projectPath, plan, (progress, action) => {
+      agent.progress = progress;
+      agent.currentAction = action;
+      display.update();
+    });
+    
+    agent.status = 'done';
+    agent.progress = 100;
+    display.update();
+  } catch (error) {
+    agent.status = 'error';
+    agent.error = error instanceof Error ? error.message : 'Unknown error';
+    display.update();
+  }
+}
+
+// ============================================================================
+// SEQUENTIAL BUILD EXECUTION
+// ============================================================================
+
+async function executeSequentialBuild(
+  anthropic: Anthropic,
+  plan: BuildPlan,
+  projectPath: string,
+  config: Config
+): Promise<void> {
+  for (const wave of plan.waves) {
+    for (const agent of wave.agents) {
+      const spinner = p.spinner();
+      spinner.start(`Building ${agent.name}...`);
+      
+      try {
+        await executeAgent(anthropic, agent as AgentTask, projectPath, plan, (progress, action) => {
+          spinner.message = `${agent.name}: ${action} (${progress}%)`;
+        });
+        spinner.stop(`✓ ${agent.name} complete`);
+      } catch (error) {
+        spinner.stop(`✗ ${agent.name} failed`);
+        throw error;
+      }
+
+      // Merge branch
+      await mergeWaveBranches([agent as AgentTask], projectPath);
+    }
+  }
+}
+
+// ============================================================================
+// AGENT EXECUTION WITH SELF-HEALING
+// ============================================================================
+
+async function executeAgent(
+  anthropic: Anthropic,
+  agent: AgentTask,
+  projectPath: string,
+  plan: BuildPlan,
+  onProgress?: (progress: number, action: string) => void
+): Promise<void> {
+  const maxAttempts = 3;
+  
+  // Create branch for this agent
+  await execa('git', ['checkout', '-b', agent.branch], { cwd: projectPath });
+
+  while (agent.healAttempts < maxAttempts) {
+    try {
+      await runAgentTask(anthropic, agent, projectPath, plan, onProgress);
+      
+      // Commit changes
+      await execa('git', ['add', '.'], { cwd: projectPath });
+      await execa('git', ['commit', '-m', `feat: ${agent.name}`], { cwd: projectPath, reject: false });
+      
+      // Switch back to main
+      await execa('git', ['checkout', 'main'], { cwd: projectPath });
+      
+      return; // Success!
+      
+    } catch (error) {
+      agent.healAttempts++;
+      const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+      
+      if (agent.healAttempts >= maxAttempts) {
+        // Switch back to main before throwing
+        await execa('git', ['checkout', 'main'], { cwd: projectPath, reject: false });
+        throw new Error(`Agent ${agent.name} failed after ${maxAttempts} attempts: ${errorMsg}`);
+      }
+
+      // Try to heal
+      agent.status = 'healing';
+      if (onProgress) onProgress(agent.progress, 'Self-healing...');
+      
+      const solution = await healerAgent(anthropic, agent, errorMsg, projectPath, plan);
+      
+      if (solution.canFix) {
+        if (onProgress) onProgress(agent.progress, `Healing: ${solution.description}`);
+        
+        if (solution.type === 'wait' && solution.waitTime) {
+          await sleep(solution.waitTime);
+        } else if (solution.type === 'modify-code' && solution.newCode) {
+          // Apply the fix
+          await writeFilesFromResponse(solution.newCode, projectPath);
+        }
+        
+        agent.status = 'running';
+        // Loop continues with fix applied
+      } else {
+        // Healer can't fix, switch back and throw
+        await execa('git', ['checkout', 'main'], { cwd: projectPath, reject: false });
+        throw new Error(`Agent ${agent.name} failed and could not self-heal: ${errorMsg}`);
+      }
+    }
+  }
+}
+
+async function runAgentTask(
+  anthropic: Anthropic,
+  agent: AgentTask,
+  projectPath: string,
+  plan: BuildPlan,
+  onProgress?: (progress: number, action: string) => void
+): Promise<void> {
+  if (onProgress) onProgress(10, 'Analyzing requirements...');
+
+  // Create feature folder
+  const featurePath = path.join(projectPath, agent.folder);
+  await fs.ensureDir(featurePath);
+
+  if (onProgress) onProgress(20, 'Generating code...');
+
+  // Conversation loop to handle questions
+  const messages: Array<{ role: 'user' | 'assistant'; content: string }> = [];
+  let userAnswers: Record<string, string> = {};
+  let iteration = 0;
+  const maxIterations = 5; // Prevent infinite loops
+
+  // Initial prompt
+  messages.push({
+    role: 'user',
+    content: `You are Agent "${agent.id}" building the "${agent.name}" feature.
+
+Feature: ${agent.name}
+Description: ${agent.description}
+Your folder: ${agent.folder}
+Exports needed: ${agent.exports.join(', ')}
+
+Project context:
+- Project: ${plan.projectName}
+- Conventions: ${plan.sharedSetup.conventions}
+- Shared types available: ${plan.sharedSetup.types.join(', ')}
+
+Rules:
+1. ONLY create files in your folder: ${agent.folder}/
+2. Export everything from ${agent.folder}/index.ts
+3. Import shared types from @/types
+4. Import shared components from @/components/ui
+5. Use TypeScript, proper error handling, loading states
+6. Every form needs Zod validation
+7. Every async operation needs try/catch
+8. Every list needs empty state
+
+IMPORTANT: If you need to make a significant decision (auth provider, database choice, 
+styling approach, etc.) and it's not specified, ASK THE USER first:
+
+<<<ASK_USER>>>
+question: Your question here?
+options: Option 1, Option 2, Option 3
+context: Brief context for why you're asking
+<<<END_ASK>>>
+
+Only ask for IMPORTANT decisions, not minor implementation details.
+
+Generate ALL files needed for this feature.
+
+Output format:
+<<<FILE: ${agent.folder}/path/to/file.ts>>>
+content
+<<<END_FILE>>>
+
+Start with the index.ts that exports everything.`
+  });
+
+  while (iteration < maxIterations) {
+    iteration++;
+
+    const response = await anthropic.messages.create({
+      model: 'claude-sonnet-4-20250514',
+      max_tokens: 8192,
+      messages,
+    });
+
+    const text = response.content[0].type === 'text' ? response.content[0].text : '';
+    messages.push({ role: 'assistant', content: text });
+
+    // Check if agent is asking a question
+    const questionMatch = text.match(/<<<ASK_USER>>>([\s\S]*?)<<<END_ASK>>>/);
+    
+    if (questionMatch) {
+      // Parse the question
+      const questionBlock = questionMatch[1];
+      const questionLine = questionBlock.match(/question:\s*(.+)/);
+      const optionsLine = questionBlock.match(/options:\s*(.+)/);
+      const contextLine = questionBlock.match(/context:\s*(.+)/);
+
+      if (questionLine && optionsLine) {
+        const question = questionLine[1].trim();
+        const options = optionsLine[1].split(',').map(o => o.trim());
+        const context = contextLine ? contextLine[1].trim() : '';
+
+        // Ask the user
+        const answer = await askUserQuestion(agent, {
+          question,
+          options,
+          context,
+        }, onProgress);
+
+        if (answer) {
+          userAnswers[question] = answer;
+          
+          // Send answer back to agent
+          messages.push({
+            role: 'user',
+            content: `User answered: "${answer}"
+
+Now continue building the feature with this choice. Generate the code files.`
+          });
+
+          if (onProgress) onProgress(30 + (iteration * 10), 'Continuing with your choice...');
+          continue; // Loop to get the code
+        }
+      }
+    }
+
+    // No question found, check for files
+    if (onProgress) onProgress(60, 'Writing files...');
+
+    const files = await writeFilesFromResponse(text, projectPath);
+    agent.files = files;
+
+    if (onProgress) onProgress(80, 'Validating...');
+
+    // Basic validation - check if files were created
+    if (files.length === 0) {
+      throw new Error('No files generated');
+    }
+
+    // Check for index.ts
+    const hasIndex = files.some(f => f.endsWith('index.ts'));
+    if (!hasIndex) {
+      throw new Error('Missing index.ts export file');
+    }
+
+    if (onProgress) onProgress(100, 'Complete');
+    return; // Success!
+  }
+
+  throw new Error('Agent exceeded maximum iterations');
+}
+
+// ============================================================================
+// ASK USER QUESTION
+// ============================================================================
+
+async function askUserQuestion(
+  agent: AgentTask,
+  question: UserQuestion,
+  onProgress?: (progress: number, action: string) => void
+): Promise<string | null> {
+  // Pause display and update status
+  displayPaused = true;
+  const previousStatus = agent.status;
+  agent.status = 'asking';
+  
+  if (onProgress) onProgress(agent.progress, 'Waiting for your input...');
+
+  // Clear some space
+  console.log('\n');
+
+  // Show the question
+  console.log(chalk.cyan(`  ┌─────────────────────────────────────────────────────────────`));
+  console.log(chalk.cyan(`  │ 🤖 ${agent.name} needs your input`));
+  console.log(chalk.cyan(`  └─────────────────────────────────────────────────────────────`));
+  
+  if (question.context) {
+    console.log(chalk.dim(`  ${question.context}\n`));
+  }
+
+  const answer = await p.select({
+    message: question.question,
+    options: question.options.map(o => ({ value: o, label: o })),
+  });
+
+  if (p.isCancel(answer)) {
+    // User cancelled - use first option as default
+    console.log(chalk.yellow(`  Using default: ${question.options[0]}`));
+    agent.status = previousStatus;
+    displayPaused = false;
+    return question.options[0];
+  }
+
+  console.log(chalk.green(`  ✓ Got it: ${answer}\n`));
+
+  // Resume
+  agent.status = previousStatus;
+  displayPaused = false;
+
+  return answer as string;
+}
+
+// ============================================================================
+// HEALER AGENT
+// ============================================================================
+
+async function healerAgent(
+  anthropic: Anthropic,
+  agent: AgentTask,
+  error: string,
+  projectPath: string,
+  plan: BuildPlan
+): Promise<HealerSolution> {
+  const response = await anthropic.messages.create({
+    model: 'claude-sonnet-4-20250514',
+    max_tokens: 4096,
+    messages: [{
+      role: 'user',
+      content: `You are the Healer Agent. An agent failed and you need to diagnose and fix it.
+
+Failed Agent: ${agent.name} (${agent.id})
+Folder: ${agent.folder}
+Error: ${error}
+Attempt: ${agent.healAttempts + 1} of 3
+
+Files created so far: ${agent.files.join(', ') || 'none'}
+
+Project context:
+- Other features: ${plan.waves.flatMap(w => w.agents.map(a => a.id)).join(', ')}
+- Shared types: ${plan.sharedSetup.types.join(', ')}
+
+Diagnose the error and provide a solution.
+
+Return JSON only:
+{
+  "canFix": true,
+  "solution": "explanation of what went wrong",
+  "type": "retry" | "modify-code" | "wait" | "skip-optional" | "generate-missing",
+  "description": "short description for UI",
+  "waitTime": 5000,  // if type is "wait", milliseconds
+  "newCode": "<<<FILE: path>>>\\ncontent\\n<<<END_FILE>>>"  // if type is "modify-code" or "generate-missing"
+}
+
+Common fixes:
+- Missing import → generate the missing file
+- Type error → fix the types
+- Module not found → check path or generate stub
+- Syntax error → fix the syntax
+- Timeout → retry with simpler approach`
+    }],
+  });
+
+  const text = response.content[0].type === 'text' ? response.content[0].text : '';
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+
+  if (!jsonMatch) {
+    return {
+      canFix: false,
+      solution: 'Could not parse healer response',
+      type: 'retry',
+      description: 'Unknown error',
+    };
+  }
+
+  return JSON.parse(jsonMatch[0]);
+}
+
+// ============================================================================
+// INTEGRATION PHASE
+// ============================================================================
+
+async function runIntegrationPhase(
+  anthropic: Anthropic,
+  plan: BuildPlan,
+  projectPath: string
+): Promise<void> {
+  const spinner = p.spinner();
+  spinner.start('Running integration...');
+
+  // Get all feature exports
+  const features = plan.waves.flatMap(w => w.agents);
+  
+  const response = await anthropic.messages.create({
+    model: 'claude-sonnet-4-20250514',
+    max_tokens: 8192,
+    messages: [{
+      role: 'user',
+      content: `You are the Integration Agent. Wire together all the features.
+
+Features built:
+${features.map(f => `- ${f.name}: ${f.folder} exports [${f.exports.join(', ')}]`).join('\n')}
+
+Generate:
+1. src/app/layout.tsx - Wire up providers (AuthProvider, etc.)
+2. src/app/page.tsx - Main dashboard/home linking to features
+3. src/app/[feature]/page.tsx - Route for each feature
+4. src/components/Navigation.tsx - Nav linking all features
+5. src/types/index.ts - Re-export all feature types
+
+Output format:
+<<<FILE: path>>>
+content
+<<<END_FILE>>>
+
+Make sure all features are accessible and properly connected.`
+    }],
+  });
+
+  const text = response.content[0].type === 'text' ? response.content[0].text : '';
+  await writeFilesFromResponse(text, projectPath);
+
+  // Final commit
+  await execa('git', ['add', '.'], { cwd: projectPath });
+  await execa('git', ['commit', '-m', 'Integration: wire up all features'], { cwd: projectPath, reject: false });
+
+  spinner.stop('Integration complete');
+}
+
+// ============================================================================
+// GIT HELPERS
+// ============================================================================
+
+async function mergeWaveBranches(agents: AgentTask[], projectPath: string): Promise<void> {
+  for (const agent of agents) {
+    if (agent.status === 'done') {
+      try {
+        await execa('git', ['merge', agent.branch, '--no-edit'], { cwd: projectPath });
+        await execa('git', ['branch', '-d', agent.branch], { cwd: projectPath, reject: false });
+      } catch (error) {
+        // Merge conflict - shouldn't happen with isolated folders
+        console.log(chalk.yellow(`  Warning: Merge issue with ${agent.name}, continuing...`));
+        await execa('git', ['merge', '--abort'], { cwd: projectPath, reject: false });
+      }
+    }
+  }
+}
+
+// ============================================================================
+// PROGRESS DISPLAY
+// ============================================================================
+
+class ProgressDisplay {
+  private agents: AgentTask[];
+  private interval: ReturnType<typeof setInterval> | null = null;
+  private lastLineCount: number = 0;
+
+  constructor(agents: AgentTask[]) {
+    this.agents = agents;
+  }
+
+  start(): void {
+    this.render();
+    this.interval = setInterval(() => {
+      if (!displayPaused) {
+        this.render();
+      }
+    }, 500);
+  }
+
+  stop(): void {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    if (!displayPaused) {
+      this.render();
+    }
+    console.log('');
+  }
+
+  update(): void {
+    // Will be rendered on next interval
+  }
+
+  pause(): void {
+    displayPaused = true;
+  }
+
+  resume(): void {
+    displayPaused = false;
+    // Re-render after question is answered
+    console.log(''); // Add spacing
+    this.render();
+  }
+
+  private render(): void {
+    if (displayPaused) return;
+
+    // Move cursor up and clear previous render
+    if (this.lastLineCount > 0) {
+      process.stdout.write(`\x1b[${this.lastLineCount}A\x1b[0J`);
+    }
+
+    for (const agent of this.agents) {
+      const icon = this.getStatusIcon(agent.status);
+      const bar = this.getProgressBar(agent.progress);
+      const action = agent.currentAction ? chalk.dim(` ${agent.currentAction}`) : '';
+      
+      console.log(`  ${icon} ${agent.name.padEnd(15)} ${bar} ${agent.progress.toString().padStart(3)}%${action}`);
+    }
+    console.log('');
+    
+    this.lastLineCount = this.agents.length + 1;
+  }
+
+  private getStatusIcon(status: AgentTask['status']): string {
+    switch (status) {
+      case 'waiting': return chalk.gray('○');
+      case 'running': return chalk.blue('●');
+      case 'healing': return chalk.yellow('⚕');
+      case 'asking': return chalk.magenta('?');
+      case 'done': return chalk.green('✓');
+      case 'error': return chalk.red('✗');
+      default: return '?';
+    }
+  }
+
+  private getProgressBar(progress: number): string {
+    const width = 20;
+    const filled = Math.round((progress / 100) * width);
+    const empty = width - filled;
+    return chalk.green('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+  }
+}
+
+// ============================================================================
+// FILE HELPERS
+// ============================================================================
+
+async function writeFilesFromResponse(text: string, projectPath: string): Promise<string[]> {
+  const fileRegex = /<<<FILE:\s*(.+?)>>>([\s\S]*?)<<<END_FILE>>>/g;
+  const files: string[] = [];
+  let match;
+
+  while ((match = fileRegex.exec(text)) !== null) {
+    const filePath = path.join(projectPath, match[1].trim());
+    const content = match[2].trim();
+
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content);
+    files.push(match[1].trim());
+  }
+
+  return files;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}