@nclamvn/vibecode-cli 1.1.0 → 1.2.0

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/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';

package/src/providers/claude-code.js

@@ -0,0 +1,159 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Claude Code Provider
+// "Claude/LLM là PIPELINE, là KIẾN TRÚC SƯ"
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import { spawn } from 'child_process';
+import path from 'path';
+import { pathExists, appendToFile } from '../utils/files.js';
+
+/**
+ * Claude Code optimal configuration
+ * Contract LOCKED = License to build (không cần hỏi thêm)
+ */
+export const CLAUDE_CODE_CONFIG = {
+  command: 'claude',
+  flags: [
+    '--dangerously-skip-permissions',  // Trust the AI - Contract đã locked
+  ],
+  timeout: 30 * 60 * 1000, // 30 minutes max
+};
+
+/**
+ * Check if Claude Code CLI is available
+ */
+export async function isClaudeCodeAvailable() {
+  return new Promise((resolve) => {
+    const proc = spawn('which', ['claude'], { shell: true });
+    proc.on('close', (code) => {
+      resolve(code === 0);
+    });
+    proc.on('error', () => {
+      resolve(false);
+    });
+  });
+}
+
+/**
+ * Spawn Claude Code with optimal settings
+ *
+ * @param {string} prompt - The coder pack / prompt to send
+ * @param {object} options - Configuration options
+ * @param {string} options.cwd - Working directory
+ * @param {string} options.logPath - Path to write build logs
+ * @param {function} options.onOutput - Callback for output
+ * @returns {Promise<{success: boolean, code: number}>}
+ */
+export async function spawnClaudeCode(prompt, options = {}) {
+  const { cwd, logPath, onOutput } = options;
+  const fs = await import('fs-extra');
+  const os = await import('os');
+
+  // Check if Claude Code is available
+  const available = await isClaudeCodeAvailable();
+  if (!available) {
+    throw new Error('Claude Code CLI not found. Install with: npm install -g @anthropic/claude-code');
+  }
+
+  // Write prompt to temp file to avoid shell escaping issues
+  const tempDir = os.default.tmpdir();
+  const promptFile = path.join(tempDir, `vibecode-prompt-${Date.now()}.md`);
+  await fs.default.writeFile(promptFile, prompt, 'utf-8');
+
+  return new Promise((resolve, reject) => {
+    // Use cat to pipe the prompt file content to claude
+    const command = `cat "${promptFile}" | claude ${CLAUDE_CODE_CONFIG.flags.join(' ')}`;
+
+    // Log the command being run
+    if (logPath) {
+      appendToFile(logPath, `\n[${new Date().toISOString()}] Running: claude with prompt from ${promptFile}\n`);
+    }
+
+    const proc = spawn(command, [], {
+      cwd: cwd || process.cwd(),
+      stdio: 'inherit', // Stream directly to terminal
+      shell: true,
+    });
+
+    let timeoutId = setTimeout(() => {
+      proc.kill();
+      // Cleanup temp file
+      fs.default.remove(promptFile).catch(() => {});
+      reject(new Error('Claude Code process timed out'));
+    }, CLAUDE_CODE_CONFIG.timeout);
+
+    proc.on('close', async (code) => {
+      clearTimeout(timeoutId);
+
+      // Cleanup temp file
+      await fs.default.remove(promptFile).catch(() => {});
+
+      const result = {
+        success: code === 0,
+        code: code || 0,
+        timestamp: new Date().toISOString()
+      };
+
+      if (logPath) {
+        const status = result.success ? 'SUCCESS' : 'FAILED';
+        appendToFile(logPath, `\n[${result.timestamp}] Claude Code ${status} (exit code: ${code})\n`);
+      }
+
+      resolve(result);
+    });
+
+    proc.on('error', async (error) => {
+      clearTimeout(timeoutId);
+      // Cleanup temp file
+      await fs.default.remove(promptFile).catch(() => {});
+
+      if (logPath) {
+        appendToFile(logPath, `\n[${new Date().toISOString()}] ERROR: ${error.message}\n`);
+      }
+      reject(error);
+    });
+  });
+}
+
+/**
+ * Build prompt with optional CLAUDE.md injection
+ *
+ * @param {string} coderPackContent - Content of coder_pack.md
+ * @param {string} projectRoot - Project root directory
+ * @returns {Promise<string>} - Final prompt
+ */
+export async function buildPromptWithContext(coderPackContent, projectRoot) {
+  let fullPrompt = coderPackContent;
+
+  // Check for CLAUDE.md in project root
+  const claudeMdPath = path.join(projectRoot, 'CLAUDE.md');
+  if (await pathExists(claudeMdPath)) {
+    const fs = await import('fs-extra');
+    const claudeMd = await fs.default.readFile(claudeMdPath, 'utf-8');
+
+    // Inject CLAUDE.md rules before coder pack
+    fullPrompt = `# PROJECT RULES (from CLAUDE.md)
+
+${claudeMd}
+
+---
+
+# BUILD INSTRUCTIONS
+
+${coderPackContent}`;
+  }
+
+  return fullPrompt;
+}
+
+/**
+ * Get provider info for status display
+ */
+export function getProviderInfo() {
+  return {
+    name: 'Claude Code',
+    command: CLAUDE_CODE_CONFIG.command,
+    mode: '--dangerously-skip-permissions',
+    description: 'AI coding with guardrails disabled (contract-approved)'
+  };
+}

package/src/providers/index.js

@@ -0,0 +1,45 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - AI Provider Manager
+// ═══════════════════════════════════════════════════════════════════════════════
+
+export {
+  spawnClaudeCode,
+  isClaudeCodeAvailable,
+  buildPromptWithContext,
+  getProviderInfo,
+  CLAUDE_CODE_CONFIG
+} from './claude-code.js';
+
+// Future providers:
+// export { callAnthropicAPI } from './anthropic-api.js';
+// export { spawnCursor } from './cursor.js';
+
+/**
+ * Available providers
+ */
+export const PROVIDERS = {
+  'claude-code': {
+    name: 'Claude Code',
+    description: 'Official Claude CLI for coding',
+    available: true
+  },
+  'anthropic-api': {
+    name: 'Anthropic API',
+    description: 'Direct API calls (coming soon)',
+    available: false
+  }
+};
+
+/**
+ * Get provider by name
+ */
+export function getProvider(name) {
+  return PROVIDERS[name] || null;
+}
+
+/**
+ * Get default provider
+ */
+export function getDefaultProvider() {
+  return 'claude-code';
+}