@nclamvn/vibecode-cli 2.0.0 → 2.1.0

package/src/commands/build.js

@@ -20,14 +20,29 @@ import { getCurrentState, transitionTo } from '../core/state-machine.js';
 import { getSpecHash } from '../core/contract.js';
 import { STATES } from '../config/constants.js';
 import { getBuildReportTemplate } from '../config/templates.js';
-import { ensureDir, pathExists, appendToFile, readMarkdown } from '../utils/files.js';
+import { ensureDir, pathExists, appendToFile, readMarkdown, writeJson } from '../utils/files.js';
 import { printBox, printError, printSuccess, printWarning, printNextStep } from '../ui/output.js';
+import { showError, inlineError } from '../ui/error-translator.js';
+import { BackupManager } from '../core/backup.js';
 import {
   spawnClaudeCode,
   isClaudeCodeAvailable,
   buildPromptWithContext,
   getProviderInfo
 } from '../providers/index.js';
+// Phase D: Iterative Build
+import { runTests, formatTestResults } from '../core/test-runner.js';
+import { analyzeErrors, formatErrors, createErrorSummary } from '../core/error-analyzer.js';
+import { generateFixPrompt, areErrorsFixable, estimateFixComplexity } from '../core/fix-generator.js';
+import {
+  createIterationState,
+  recordIteration,
+  canContinue,
+  finalizeIterationState,
+  saveIterationState,
+  formatIterationSummary,
+  logIteration
+} from '../core/iteration.js';
 
 const execAsync = promisify(exec);
 
@@ -46,7 +61,10 @@ export async function buildCommand(options = {}) {
     const specHash = await getSpecHash();
 
     // Handle different build modes
-    if (options.auto) {
+    if (options.iterate) {
+      // Phase D: Iterative Build
+      await handleIterativeBuild(currentState, projectName, sessionId, sessionPath, specHash, options);
+    } else if (options.auto) {
       await handleAutoBuild(currentState, projectName, sessionId, sessionPath, specHash, options);
     } else if (options.start) {
       await handleBuildStart(currentState, projectName, sessionId, sessionPath, specHash);
@@ -59,7 +77,7 @@ export async function buildCommand(options = {}) {
     }
 
   } catch (error) {
-    printError(error.message);
+    showError(error, { verbose: options.verbose });
     process.exit(1);
   }
 }
@@ -69,6 +87,10 @@ export async function buildCommand(options = {}) {
  * "Contract LOCKED = License to build"
  */
 async function handleAutoBuild(currentState, projectName, sessionId, sessionPath, specHash, options) {
+  // Create backup before build
+  const backup = new BackupManager();
+  await backup.createBackup('build-auto');
+
   // Check state - must be PLAN_CREATED or BUILD_IN_PROGRESS or REVIEW_FAILED
   const validStates = [STATES.PLAN_CREATED, STATES.BUILD_IN_PROGRESS, STATES.REVIEW_FAILED];
   if (!validStates.includes(currentState)) {
@@ -211,9 +233,328 @@ ${evidence.screenshots > 0 ? `  ✅ ${evidence.screenshots} screenshots` : '
 
   } catch (error) {
     await appendToFile(logPath, `\nERROR: ${error.message}\n`);
-    printError(`Auto build failed: ${error.message}`);
+    showError(error);
+    process.exit(1);
+  }
+}
+
+/**
+ * Handle --iterate mode: Build-Test-Fix loop
+ * "Build until tests pass or max iterations reached"
+ */
+async function handleIterativeBuild(currentState, projectName, sessionId, sessionPath, specHash, options) {
+  const maxIterations = options.max || 3;
+  const strictMode = options.strict || false;
+
+  // Create backup before iterative build
+  const backup = new BackupManager();
+  await backup.createBackup('build-iterate');
+
+  // Check state - must be PLAN_CREATED or BUILD_IN_PROGRESS or REVIEW_FAILED
+  const validStates = [STATES.PLAN_CREATED, STATES.BUILD_IN_PROGRESS, STATES.REVIEW_FAILED];
+  if (!validStates.includes(currentState)) {
+    printError(`Cannot iterate in state: ${currentState}`);
+    console.log('Run `vibecode plan` first to create execution plan.');
+    process.exit(1);
+  }
+
+  // Check if Claude Code is available
+  const available = await isClaudeCodeAvailable();
+  if (!available) {
+    printError('Claude Code CLI not found.');
+    console.log(chalk.gray('Install with: npm install -g @anthropic-ai/claude-code'));
     process.exit(1);
   }
+
+  // Check coder_pack.md exists
+  if (!await sessionFileExists('coder_pack.md')) {
+    printError('coder_pack.md not found. Run `vibecode plan` first.');
+    process.exit(1);
+  }
+
+  // Setup directories
+  const evidencePath = path.join(sessionPath, 'evidence');
+  await ensureDir(evidencePath);
+  await ensureDir(path.join(evidencePath, 'screenshots'));
+  const iterationDir = path.join(sessionPath, 'iterations');
+  await ensureDir(iterationDir);
+  const logPath = path.join(evidencePath, 'build.log');
+
+  // Initialize iteration state
+  let iterationState = createIterationState(sessionId, maxIterations);
+
+  // Save initial state
+  const stateData = await loadState();
+  const startTime = new Date().toISOString();
+  stateData.build_started = startTime;
+  stateData.build_provider = 'claude-code';
+  stateData.build_mode = 'iterate';
+  stateData.max_iterations = maxIterations;
+  await saveState(stateData);
+
+  // Transition to BUILD_IN_PROGRESS if not already
+  if (currentState !== STATES.BUILD_IN_PROGRESS) {
+    await transitionTo(STATES.BUILD_IN_PROGRESS, 'iterative_build_started');
+  }
+
+  // Load coder pack
+  const originalCoderPack = await readSessionFile('coder_pack.md');
+
+  // Log start
+  await appendToFile(logPath, `\n${'='.repeat(60)}\n`);
+  await appendToFile(logPath, `ITERATIVE BUILD STARTED: ${startTime}\n`);
+  await appendToFile(logPath, `Max Iterations: ${maxIterations}\n`);
+  await appendToFile(logPath, `Strict Mode: ${strictMode}\n`);
+  await appendToFile(logPath, `${'='.repeat(60)}\n\n`);
+
+  // Show starting message
+  const providerInfo = getProviderInfo();
+
+  const content = `🔄 ITERATIVE BUILD
+
+Project: ${projectName}
+Session: ${sessionId}
+Spec Hash: ${specHash}
+
+Provider: ${providerInfo.name}
+Max Iterations: ${maxIterations}
+Strict Mode: ${strictMode ? 'Yes' : 'No'}
+
+Starting build-test-fix loop...`;
+
+  console.log();
+  printBox(content, { borderColor: 'magenta' });
+  console.log();
+
+  // Build-Test-Fix Loop
+  let currentPrompt = await buildPromptWithContext(originalCoderPack, process.cwd());
+  let loopResult = { success: false, reason: '' };
+
+  while (true) {
+    const iteration = iterationState.currentIteration + 1;
+    const iterationStart = Date.now();
+
+    console.log(chalk.cyan(`\n${'─'.repeat(60)}`));
+    console.log(chalk.cyan(`│ ITERATION ${iteration}/${maxIterations}`));
+    console.log(chalk.cyan(`${'─'.repeat(60)}\n`));
+
+    await logIteration(logPath, iteration, 'Starting iteration');
+
+    // Step 1: Run Claude Code
+    console.log(chalk.yellow('▶ Running Claude Code...'));
+    console.log();
+
+    try {
+      const buildResult = await spawnClaudeCode(currentPrompt, {
+        cwd: process.cwd(),
+        logPath: logPath
+      });
+
+      console.log();
+      await logIteration(logPath, iteration, `Claude Code exited with code: ${buildResult.code}`);
+
+      // Capture evidence for this iteration
+      await captureGitDiff(evidencePath);
+      const iterEvidencePath = path.join(iterationDir, `iteration-${iteration}-diff.txt`);
+      try {
+        const { stdout } = await execAsync('git diff HEAD', { maxBuffer: 10 * 1024 * 1024 });
+        if (stdout.trim()) {
+          const fs = await import('fs-extra');
+          await fs.default.writeFile(iterEvidencePath, stdout, 'utf-8');
+        }
+      } catch (e) { /* ignore */ }
+
+      // Step 2: Run Tests
+      console.log(chalk.yellow('▶ Running tests...'));
+      const spinner = ora('Testing...').start();
+
+      const testResult = await runTests(process.cwd());
+      const iterationDuration = Date.now() - iterationStart;
+
+      if (testResult.passed) {
+        spinner.succeed('All tests passed!');
+
+        // Record successful iteration
+        iterationState = recordIteration(iterationState, {
+          passed: true,
+          errorCount: 0,
+          errorTypes: [],
+          affectedFiles: [],
+          duration: iterationDuration,
+          action: 'build'
+        });
+
+        // Finalize as success
+        iterationState = finalizeIterationState(iterationState, 'success');
+        await saveIterationState(sessionPath, iterationState);
+
+        loopResult = { success: true, reason: 'All tests passed' };
+        break;
+
+      } else {
+        spinner.fail(`Tests failed: ${testResult.summary.failed}/${testResult.summary.total}`);
+
+        // Step 3: Analyze Errors
+        const analyzedErrors = analyzeErrors(testResult);
+        const summary = createErrorSummary(analyzedErrors);
+
+        console.log();
+        console.log(formatErrors(analyzedErrors));
+
+        await logIteration(logPath, iteration, `Found ${analyzedErrors.length} errors`);
+
+        // Save error analysis for this iteration
+        await writeJson(path.join(iterationDir, `iteration-${iteration}-errors.json`), {
+          iteration,
+          timestamp: new Date().toISOString(),
+          summary,
+          errors: analyzedErrors
+        });
+
+        // Record failed iteration
+        iterationState = recordIteration(iterationState, {
+          passed: false,
+          errorCount: analyzedErrors.length,
+          errorTypes: [...new Set(analyzedErrors.map(e => e.type))],
+          affectedFiles: [...new Set(analyzedErrors.filter(e => e.file).map(e => e.file))],
+          duration: iterationDuration,
+          action: 'build'
+        });
+
+        // Check if errors are fixable
+        const fixableCheck = areErrorsFixable(analyzedErrors);
+        if (!fixableCheck.fixable) {
+          console.log(chalk.red(`\n⚠️  ${fixableCheck.reason}`));
+          await logIteration(logPath, iteration, `Errors not fixable: ${fixableCheck.reason}`);
+
+          iterationState = finalizeIterationState(iterationState, 'unfixable');
+          await saveIterationState(sessionPath, iterationState);
+
+          loopResult = { success: false, reason: fixableCheck.reason };
+          break;
+        }
+
+        // Check if we can continue
+        const continueCheck = canContinue(iterationState);
+        if (!continueCheck.canContinue) {
+          console.log(chalk.yellow(`\n⚠️  ${continueCheck.reason}`));
+          await logIteration(logPath, iteration, continueCheck.reason);
+
+          iterationState = finalizeIterationState(iterationState, 'max_reached');
+          await saveIterationState(sessionPath, iterationState);
+
+          loopResult = { success: false, reason: continueCheck.reason };
+          break;
+        }
+
+        // Step 4: Generate Fix Prompt
+        const complexity = estimateFixComplexity(analyzedErrors);
+        console.log(chalk.gray(`\nFix complexity: ${complexity}`));
+        console.log(chalk.yellow(`\n▶ Generating fix prompt for iteration ${iteration + 1}...`));
+
+        currentPrompt = generateFixPrompt(analyzedErrors, originalCoderPack, iteration + 1);
+
+        // Save fix prompt for evidence
+        await writeSessionFile(`iterations/fix-prompt-${iteration + 1}.md`, currentPrompt);
+
+        await logIteration(logPath, iteration, 'Generated fix prompt for next iteration');
+      }
+
+    } catch (error) {
+      console.log('\n' + inlineError(error));
+      await logIteration(logPath, iteration, `Error: ${error.message}`);
+
+      iterationState = finalizeIterationState(iterationState, 'error');
+      await saveIterationState(sessionPath, iterationState);
+
+      loopResult = { success: false, reason: error.message };
+      break;
+    }
+  }
+
+  // Final Summary
+  const endTime = new Date().toISOString();
+  await appendToFile(logPath, `\n${'='.repeat(60)}\n`);
+  await appendToFile(logPath, `ITERATIVE BUILD COMPLETED: ${endTime}\n`);
+  await appendToFile(logPath, `Result: ${loopResult.success ? 'SUCCESS' : 'FAILED'}\n`);
+  await appendToFile(logPath, `Iterations: ${iterationState.currentIteration}\n`);
+  await appendToFile(logPath, `${'='.repeat(60)}\n`);
+
+  // Save final iteration state
+  await saveIterationState(sessionPath, iterationState);
+
+  // Check evidence
+  const evidence = await checkEvidence(evidencePath);
+
+  // Generate build report
+  const reportContent = getBuildReportTemplate(
+    projectName,
+    sessionId,
+    specHash,
+    startTime,
+    endTime,
+    evidence
+  );
+  await writeSessionFile('build_report.md', reportContent);
+
+  // Update state - RELOAD to get current state (after BUILD_IN_PROGRESS transition)
+  const finalStateData = await loadState();
+  finalStateData.build_completed = endTime;
+  finalStateData.iterations = iterationState.currentIteration;
+  finalStateData.iteration_result = loopResult.success ? 'success' : 'failed';
+  await saveState(finalStateData);
+
+  console.log();
+  console.log(chalk.cyan('─'.repeat(60)));
+  console.log();
+
+  if (loopResult.success) {
+    await transitionTo(STATES.BUILD_DONE, 'iterative_build_success');
+
+    const duration = Math.round((new Date(endTime) - new Date(startTime)) / 1000 / 60);
+
+    const successContent = `✅ ITERATIVE BUILD SUCCESS
+
+Project: ${projectName}
+Iterations: ${iterationState.currentIteration}/${maxIterations}
+Duration: ${duration} minutes
+Result: All tests passed!
+
+Evidence:
+${evidence.hasDiff ? '  ✅ changes.diff' : '  ⬜ changes.diff'}
+${evidence.hasLog ? '  ✅ build.log' : '  ⬜ build.log'}
+  ✅ ${iterationState.currentIteration} iteration records`;
+
+    printBox(successContent, { borderColor: 'green' });
+    printNextStep('Run `vibecode review` to validate your build');
+
+  } else {
+    // Still transition to BUILD_DONE but with failure note
+    await transitionTo(STATES.BUILD_DONE, 'iterative_build_completed_with_errors');
+
+    const failContent = `⚠️  ITERATIVE BUILD INCOMPLETE
+
+Project: ${projectName}
+Iterations: ${iterationState.currentIteration}/${maxIterations}
+Result: ${loopResult.reason}
+
+Evidence saved in:
+  ${iterationDir}/
+
+Check iteration logs for details.`;
+
+    printBox(failContent, { borderColor: 'yellow' });
+
+    if (strictMode) {
+      printError('Strict mode: Build failed with errors');
+      process.exit(1);
+    } else {
+      console.log(chalk.gray('\nYou can:'));
+      console.log(chalk.gray('  • Run `vibecode build --iterate` to try again'));
+      console.log(chalk.gray('  • Run `vibecode review` to review current state'));
+      console.log(chalk.gray('  • Fix errors manually and run `vibecode build --complete`'));
+    }
+  }
 }
 
 async function handleBuildStart(currentState, projectName, sessionId, sessionPath, specHash) {