@nclamvn/vibecode-cli 1.1.0 → 1.3.0

package/src/core/fix-generator.js

@@ -0,0 +1,195 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Fix Generator
+// Generate fix prompts for iterative builds
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import { formatErrors, createErrorSummary } from './error-analyzer.js';
+
+/**
+ * Generate a fix prompt based on errors from previous iteration
+ * @param {AnalyzedError[]} errors - Analyzed errors from test runner
+ * @param {string} originalPack - Original coder pack content
+ * @param {number} iteration - Current iteration number
+ * @returns {string} - Fix prompt for Claude Code
+ */
+export function generateFixPrompt(errors, originalPack, iteration = 1) {
+  const summary = createErrorSummary(errors);
+
+  const sections = [
+    '# 🔧 FIX REQUIRED - Iteration ' + iteration,
+    '',
+    `The previous build had **${errors.length} error(s)**. Please fix them.`,
+    '',
+    '---',
+    '',
+    '## 📋 Error Summary',
+    '',
+    `- **Total Errors:** ${summary.total}`,
+    `- **Critical:** ${summary.byPriority.critical}`,
+    `- **High:** ${summary.byPriority.high}`,
+    `- **Medium:** ${summary.byPriority.medium}`,
+    `- **Low:** ${summary.byPriority.low}`,
+    '',
+    `**Affected Files:** ${summary.files.length > 0 ? summary.files.join(', ') : 'Unknown'}`,
+    '',
+    '---',
+    '',
+    '## 🚨 Errors to Fix',
+    '',
+  ];
+
+  // Add detailed errors grouped by priority
+  const byPriority = groupByPriority(errors);
+
+  for (const [priority, priorityErrors] of Object.entries(byPriority)) {
+    if (priorityErrors.length === 0) continue;
+
+    const emoji = priority === 'critical' ? '🔴' :
+                  priority === 'high' ? '🟠' :
+                  priority === 'medium' ? '🟡' : '🟢';
+
+    sections.push(`### ${emoji} ${priority.toUpperCase()} Priority`);
+    sections.push('');
+
+    for (const error of priorityErrors) {
+      const location = error.file
+        ? `\`${error.file}${error.line ? ':' + error.line : ''}\``
+        : 'Unknown location';
+
+      sections.push(`**${error.type}** at ${location}`);
+      sections.push(`- Message: ${error.message}`);
+      sections.push(`- Suggestion: ${error.suggestion}`);
+      if (error.raw && error.raw !== error.message) {
+        sections.push(`- Raw output: \`${truncate(error.raw, 200)}\``);
+      }
+      sections.push('');
+    }
+  }
+
+  sections.push('---');
+  sections.push('');
+  sections.push('## 📝 Original Task Reference');
+  sections.push('');
+  sections.push('<details>');
+  sections.push('<summary>Click to expand original task</summary>');
+  sections.push('');
+  sections.push(originalPack);
+  sections.push('');
+  sections.push('</details>');
+  sections.push('');
+  sections.push('---');
+  sections.push('');
+  sections.push('## ⚡ Fix Instructions');
+  sections.push('');
+  sections.push('1. **Fix ONLY the errors listed above** - Do not refactor or change working code');
+  sections.push('2. **Start with CRITICAL errors** - They likely cause cascading failures');
+  sections.push('3. **Run tests after each fix** - Verify the error is resolved');
+  sections.push('4. **Keep changes minimal** - Focus on the specific issue');
+  sections.push('');
+  sections.push('When all errors are fixed, the build will be validated again.');
+  sections.push('');
+
+  return sections.join('\n');
+}
+
+/**
+ * Generate a minimal fix prompt for single error
+ */
+export function generateSingleFixPrompt(error) {
+  const location = error.file
+    ? `${error.file}${error.line ? ':' + error.line : ''}`
+    : 'unknown location';
+
+  return `# Fix Required
+
+**Error Type:** ${error.type}
+**Location:** ${location}
+**Message:** ${error.message}
+
+**Suggestion:** ${error.suggestion}
+
+Please fix this specific error. Keep the change minimal and focused.`;
+}
+
+/**
+ * Generate iteration context for logging
+ */
+export function generateIterationContext(iteration, errors, duration) {
+  return {
+    iteration,
+    timestamp: new Date().toISOString(),
+    errorCount: errors.length,
+    errorTypes: [...new Set(errors.map(e => e.type))],
+    affectedFiles: [...new Set(errors.filter(e => e.file).map(e => e.file))],
+    duration
+  };
+}
+
+/**
+ * Group errors by priority
+ */
+function groupByPriority(errors) {
+  const grouped = {
+    critical: [],
+    high: [],
+    medium: [],
+    low: []
+  };
+
+  for (const error of errors) {
+    const priority = error.priority || 'medium';
+    if (grouped[priority]) {
+      grouped[priority].push(error);
+    } else {
+      grouped.medium.push(error);
+    }
+  }
+
+  return grouped;
+}
+
+/**
+ * Truncate string with ellipsis
+ */
+function truncate(str, maxLen) {
+  if (!str) return '';
+  if (str.length <= maxLen) return str;
+  return str.substring(0, maxLen - 3) + '...';
+}
+
+/**
+ * Check if errors are fixable (not system/config errors)
+ */
+export function areErrorsFixable(errors) {
+  // If all errors are unknown type with no file info, might be config issue
+  const unknownWithoutFile = errors.filter(e => e.type === 'unknown' && !e.file);
+
+  if (unknownWithoutFile.length === errors.length) {
+    return {
+      fixable: false,
+      reason: 'All errors are unstructured with no file information. This may indicate a configuration or environment issue.'
+    };
+  }
+
+  return { fixable: true };
+}
+
+/**
+ * Estimate fix complexity
+ */
+export function estimateFixComplexity(errors) {
+  let score = 0;
+
+  for (const error of errors) {
+    switch (error.priority) {
+      case 'critical': score += 3; break;
+      case 'high': score += 2; break;
+      case 'medium': score += 1; break;
+      case 'low': score += 0.5; break;
+    }
+  }
+
+  if (score <= 3) return 'simple';
+  if (score <= 8) return 'moderate';
+  return 'complex';
+}

package/src/core/iteration.js

@@ -0,0 +1,226 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Iteration Tracker
+// Manage and track build-test-fix iterations
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import path from 'path';
+import { ensureDir, writeJson, readJson, pathExists, appendToFile } from '../utils/files.js';
+
+/**
+ * @typedef {Object} IterationRecord
+ * @property {number} iteration - Iteration number
+ * @property {string} timestamp - ISO timestamp
+ * @property {boolean} passed - Whether tests passed
+ * @property {number} errorCount - Number of errors
+ * @property {string[]} errorTypes - Types of errors found
+ * @property {string[]} affectedFiles - Files with errors
+ * @property {number} duration - Duration in ms
+ * @property {string} action - What action was taken (build/fix)
+ */
+
+/**
+ * @typedef {Object} IterationState
+ * @property {string} sessionId - Session identifier
+ * @property {string} startTime - When iteration started
+ * @property {number} currentIteration - Current iteration number
+ * @property {number} maxIterations - Max allowed iterations
+ * @property {IterationRecord[]} history - History of iterations
+ * @property {boolean} completed - Whether iteration loop completed
+ * @property {string} result - Final result (success/max_reached/error)
+ */
+
+/**
+ * Create new iteration state
+ * @param {string} sessionId - Session identifier
+ * @param {number} maxIterations - Maximum iterations allowed
+ * @returns {IterationState}
+ */
+export function createIterationState(sessionId, maxIterations = 3) {
+  return {
+    sessionId,
+    startTime: new Date().toISOString(),
+    currentIteration: 0,
+    maxIterations,
+    history: [],
+    completed: false,
+    result: null
+  };
+}
+
+/**
+ * Record an iteration result
+ * @param {IterationState} state - Current iteration state
+ * @param {Object} result - Iteration result
+ * @returns {IterationState} - Updated state
+ */
+export function recordIteration(state, result) {
+  const record = {
+    iteration: state.currentIteration + 1,
+    timestamp: new Date().toISOString(),
+    passed: result.passed,
+    errorCount: result.errorCount || 0,
+    errorTypes: result.errorTypes || [],
+    affectedFiles: result.affectedFiles || [],
+    duration: result.duration || 0,
+    action: result.action || 'build'
+  };
+
+  return {
+    ...state,
+    currentIteration: state.currentIteration + 1,
+    history: [...state.history, record]
+  };
+}
+
+/**
+ * Check if can continue iterating
+ * @param {IterationState} state - Current state
+ * @returns {{canContinue: boolean, reason: string}}
+ */
+export function canContinue(state) {
+  if (state.completed) {
+    return { canContinue: false, reason: 'Iteration already completed' };
+  }
+
+  if (state.currentIteration >= state.maxIterations) {
+    return { canContinue: false, reason: `Max iterations (${state.maxIterations}) reached` };
+  }
+
+  // Check if last iteration passed
+  const lastRecord = state.history[state.history.length - 1];
+  if (lastRecord && lastRecord.passed) {
+    return { canContinue: false, reason: 'Tests passed - no more iterations needed' };
+  }
+
+  // Check for stuck loop (same errors repeated 3 times)
+  if (state.history.length >= 3) {
+    const last3 = state.history.slice(-3);
+    const errorCounts = last3.map(r => r.errorCount);
+    if (errorCounts.every(c => c === errorCounts[0]) && errorCounts[0] > 0) {
+      return { canContinue: false, reason: 'Stuck in loop - same error count for 3 iterations' };
+    }
+  }
+
+  return { canContinue: true, reason: '' };
+}
+
+/**
+ * Finalize iteration state
+ * @param {IterationState} state - Current state
+ * @param {string} result - Result type (success/max_reached/error/stuck)
+ * @returns {IterationState}
+ */
+export function finalizeIterationState(state, result) {
+  return {
+    ...state,
+    completed: true,
+    result,
+    endTime: new Date().toISOString(),
+    totalDuration: state.history.reduce((sum, r) => sum + r.duration, 0)
+  };
+}
+
+/**
+ * Save iteration state to session directory
+ * @param {string} sessionDir - Session directory path
+ * @param {IterationState} state - Iteration state
+ */
+export async function saveIterationState(sessionDir, state) {
+  const iterationDir = path.join(sessionDir, 'iterations');
+  await ensureDir(iterationDir);
+
+  const stateFile = path.join(iterationDir, 'state.json');
+  await writeJson(stateFile, state, { spaces: 2 });
+
+  // Also write individual iteration files for evidence
+  for (const record of state.history) {
+    const recordFile = path.join(iterationDir, `iteration-${record.iteration}.json`);
+    if (!await pathExists(recordFile)) {
+      await writeJson(recordFile, record, { spaces: 2 });
+    }
+  }
+}
+
+/**
+ * Load iteration state from session directory
+ * @param {string} sessionDir - Session directory path
+ * @returns {Promise<IterationState|null>}
+ */
+export async function loadIterationState(sessionDir) {
+  const stateFile = path.join(sessionDir, 'iterations', 'state.json');
+  if (await pathExists(stateFile)) {
+    return await readJson(stateFile);
+  }
+  return null;
+}
+
+/**
+ * Format iteration summary for display
+ * @param {IterationState} state - Iteration state
+ * @returns {string}
+ */
+export function formatIterationSummary(state) {
+  const lines = [];
+
+  lines.push(`Iteration Summary (${state.sessionId})`);
+  lines.push('═'.repeat(50));
+  lines.push(`Total Iterations: ${state.currentIteration}/${state.maxIterations}`);
+  lines.push(`Result: ${state.result || 'In Progress'}`);
+  lines.push('');
+
+  if (state.history.length > 0) {
+    lines.push('History:');
+    for (const record of state.history) {
+      const status = record.passed ? '✅' : '❌';
+      const errors = record.errorCount > 0 ? ` (${record.errorCount} errors)` : '';
+      lines.push(`  ${record.iteration}. ${status} ${record.action}${errors} - ${formatDuration(record.duration)}`);
+    }
+  }
+
+  if (state.totalDuration) {
+    lines.push('');
+    lines.push(`Total Duration: ${formatDuration(state.totalDuration)}`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Format duration in human readable format
+ */
+function formatDuration(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  return `${Math.floor(ms / 60000)}m ${Math.round((ms % 60000) / 1000)}s`;
+}
+
+/**
+ * Write iteration log entry
+ */
+export async function logIteration(logPath, iteration, message) {
+  const timestamp = new Date().toISOString();
+  const entry = `[${timestamp}] [Iteration ${iteration}] ${message}\n`;
+  await appendToFile(logPath, entry);
+}
+
+/**
+ * Get progress percentage
+ */
+export function getProgressPercent(state) {
+  if (state.completed && state.result === 'success') {
+    return 100;
+  }
+  return Math.round((state.currentIteration / state.maxIterations) * 100);
+}
+
+/**
+ * Check if errors are improving (decreasing)
+ */
+export function isImproving(state) {
+  if (state.history.length < 2) return true;
+
+  const last = state.history[state.history.length - 1];
+  const prev = state.history[state.history.length - 2];
+
+  return last.errorCount < prev.errorCount;
+}

package/src/core/session.js

@@ -114,9 +114,25 @@ export async function createBlueprint(projectName, sessionId) {
 }
 
 /**
- * Create contract file
+ * Create contract file from intake and blueprint
  */
 export async function createContract(projectName, sessionId) {
-  const template = getContractTemplate(projectName, sessionId);
+  // Read intake and blueprint to extract real content
+  let intakeContent = '';
+  let blueprintContent = '';
+
+  try {
+    intakeContent = await readSessionFile('intake.md');
+  } catch (e) {
+    // Intake not found, use empty
+  }
+
+  try {
+    blueprintContent = await readSessionFile('blueprint.md');
+  } catch (e) {
+    // Blueprint not found, use empty
+  }
+
+  const template = getContractTemplate(projectName, sessionId, intakeContent, blueprintContent);
   await writeSessionFile('contract.md', template);
 }

package/src/core/test-runner.js

@@ -0,0 +1,248 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Test Runner
+// Automated test execution for iterative builds
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+import { pathExists, readJson } from '../utils/files.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * Run all available tests for a project
+ * @param {string} projectPath - Path to the project
+ * @returns {Promise<TestResults>}
+ */
+export async function runTests(projectPath) {
+  const results = {
+    passed: true,
+    tests: [],
+    errors: [],
+    summary: {
+      total: 0,
+      passed: 0,
+      failed: 0
+    },
+    duration: 0
+  };
+
+  const startTime = Date.now();
+
+  // 1. Check if package.json exists
+  const packageJsonPath = path.join(projectPath, 'package.json');
+  const hasPackageJson = await pathExists(packageJsonPath);
+
+  if (hasPackageJson) {
+    const pkg = await readJson(packageJsonPath);
+
+    // 2. Run npm test (if script exists)
+    if (pkg.scripts?.test && !pkg.scripts.test.includes('no test specified')) {
+      const npmTest = await runCommand('npm test', projectPath, 'npm test');
+      results.tests.push(npmTest);
+    }
+
+    // 3. Run npm run lint (if script exists)
+    if (pkg.scripts?.lint) {
+      const npmLint = await runCommand('npm run lint', projectPath, 'npm lint');
+      results.tests.push(npmLint);
+    }
+
+    // 4. Run npm run build (if script exists) - check for build errors
+    if (pkg.scripts?.build) {
+      const npmBuild = await runCommand('npm run build', projectPath, 'npm build');
+      results.tests.push(npmBuild);
+    }
+
+    // 5. Run TypeScript check if tsconfig exists
+    const tsconfigPath = path.join(projectPath, 'tsconfig.json');
+    if (await pathExists(tsconfigPath)) {
+      const tscCheck = await runCommand('npx tsc --noEmit', projectPath, 'typescript');
+      results.tests.push(tscCheck);
+    }
+  }
+
+  // 6. Check for syntax errors in JS files
+  const syntaxCheck = await checkJsSyntax(projectPath);
+  if (syntaxCheck.ran) {
+    results.tests.push(syntaxCheck);
+  }
+
+  // 7. Aggregate results
+  results.summary.total = results.tests.length;
+  results.summary.passed = results.tests.filter(t => t.passed).length;
+  results.summary.failed = results.tests.filter(t => !t.passed).length;
+  results.passed = results.tests.length === 0 || results.tests.every(t => t.passed);
+  results.errors = results.tests.filter(t => !t.passed).flatMap(t => t.errors || []);
+  results.duration = Date.now() - startTime;
+
+  return results;
+}
+
+/**
+ * Run a single command and capture results
+ */
+async function runCommand(command, cwd, name) {
+  const result = {
+    name,
+    command,
+    passed: false,
+    ran: true,
+    output: '',
+    errors: [],
+    duration: 0
+  };
+
+  const startTime = Date.now();
+
+  try {
+    const { stdout, stderr } = await execAsync(command, {
+      cwd,
+      timeout: 120000, // 2 minute timeout
+      maxBuffer: 10 * 1024 * 1024
+    });
+
+    result.passed = true;
+    result.output = stdout + stderr;
+    result.duration = Date.now() - startTime;
+
+  } catch (error) {
+    result.passed = false;
+    result.output = error.stdout || '';
+    result.error = error.stderr || error.message;
+    result.exitCode = error.code;
+    result.duration = Date.now() - startTime;
+
+    // Parse errors from output
+    result.errors = parseErrors(error.stderr || error.stdout || error.message, name);
+  }
+
+  return result;
+}
+
+/**
+ * Check JavaScript syntax errors
+ */
+async function checkJsSyntax(projectPath) {
+  const result = {
+    name: 'syntax-check',
+    passed: true,
+    ran: false,
+    errors: []
+  };
+
+  try {
+    // Find JS/TS files (limited to src/ to avoid node_modules)
+    const { stdout } = await execAsync(
+      'find src -name "*.js" -o -name "*.ts" -o -name "*.jsx" -o -name "*.tsx" 2>/dev/null | head -20',
+      { cwd: projectPath }
+    );
+
+    const files = stdout.trim().split('\n').filter(f => f);
+    if (files.length === 0) return result;
+
+    result.ran = true;
+
+    // Check each file for syntax errors using node --check
+    for (const file of files) {
+      if (file.endsWith('.ts') || file.endsWith('.tsx')) continue; // Skip TS files
+
+      try {
+        await execAsync(`node --check "${file}"`, { cwd: projectPath });
+      } catch (error) {
+        result.passed = false;
+        result.errors.push({
+          file,
+          message: error.message,
+          type: 'syntax'
+        });
+      }
+    }
+  } catch (error) {
+    // find command failed, skip syntax check
+  }
+
+  return result;
+}
+
+/**
+ * Parse error messages into structured format
+ */
+function parseErrors(errorOutput, source) {
+  const errors = [];
+  const lines = errorOutput.split('\n');
+
+  for (const line of lines) {
+    // Match common error patterns
+    // Pattern: file.js:10:5: error message
+    const fileLineMatch = line.match(/([^\s:]+):(\d+):(\d+)?:?\s*(.+)/);
+    if (fileLineMatch) {
+      errors.push({
+        source,
+        file: fileLineMatch[1],
+        line: parseInt(fileLineMatch[2]),
+        column: fileLineMatch[3] ? parseInt(fileLineMatch[3]) : null,
+        message: fileLineMatch[4].trim(),
+        raw: line
+      });
+      continue;
+    }
+
+    // Pattern: Error: message
+    const errorMatch = line.match(/^(Error|TypeError|SyntaxError|ReferenceError):\s*(.+)/);
+    if (errorMatch) {
+      errors.push({
+        source,
+        type: errorMatch[1],
+        message: errorMatch[2].trim(),
+        raw: line
+      });
+      continue;
+    }
+
+    // Pattern: ✖ or ✗ or FAIL
+    if (line.includes('✖') || line.includes('✗') || line.includes('FAIL')) {
+      errors.push({
+        source,
+        message: line.trim(),
+        raw: line
+      });
+    }
+  }
+
+  // If no structured errors found, add the whole output
+  if (errors.length === 0 && errorOutput.trim()) {
+    errors.push({
+      source,
+      message: errorOutput.substring(0, 500),
+      raw: errorOutput
+    });
+  }
+
+  return errors;
+}
+
+/**
+ * Format test results for display
+ */
+export function formatTestResults(results) {
+  const lines = [];
+
+  lines.push(`Tests: ${results.summary.passed}/${results.summary.total} passed`);
+  lines.push(`Duration: ${(results.duration / 1000).toFixed(1)}s`);
+
+  if (!results.passed) {
+    lines.push('');
+    lines.push('Failed tests:');
+    for (const test of results.tests.filter(t => !t.passed)) {
+      lines.push(`  ❌ ${test.name}`);
+      for (const error of test.errors || []) {
+        const loc = error.file ? `${error.file}:${error.line || '?'}` : '';
+        lines.push(`     ${loc} ${error.message?.substring(0, 80) || ''}`);
+      }
+    }
+  }
+
+  return lines.join('\n');
+}

package/src/index.js

@@ -16,4 +16,11 @@ export { buildCommand } from './commands/build.js';
 export { reviewCommand } from './commands/review.js';
 export { snapshotCommand } from './commands/snapshot.js';
 
+// Phase C Commands
+export { configCommand } from './commands/config.js';
+
+// Constants
 export { VERSION, SPEC_HASH, STATES } from './config/constants.js';
+
+// Providers
+export { PROVIDERS, getProvider, getDefaultProvider } from './providers/index.js';