@nclamvn/vibecode-cli 1.2.0 → 1.5.0

package/src/debug/fixer.js

@@ -0,0 +1,348 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE DEBUG - Fix Generator
+// Generates fix prompts and documents applied fixes
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * Fix Generator Class
+ * Creates targeted fix prompts and maintains fix documentation
+ */
+export class FixGenerator {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.debugDir = path.join(projectPath, '.vibecode', 'debug');
+  }
+
+  /**
+   * Generate a fix prompt for Claude Code
+   */
+  generateFixPrompt(evidence, hypothesis) {
+    const parts = [];
+
+    // Header with context
+    parts.push('# Debug Fix Request');
+    parts.push('');
+    parts.push('## Error Information');
+    parts.push(`- **Type**: ${evidence.type || 'Unknown'}`);
+    parts.push(`- **Category**: ${evidence.category}`);
+
+    if (evidence.message) {
+      parts.push(`- **Message**: ${evidence.message}`);
+    }
+
+    // Files involved
+    if (evidence.files.length > 0) {
+      parts.push('');
+      parts.push('## Affected Files');
+      for (const file of evidence.files.slice(0, 5)) {
+        parts.push(`- ${file}`);
+      }
+    }
+
+    // Line numbers
+    if (evidence.lines.length > 0) {
+      parts.push('');
+      parts.push('## Line Numbers');
+      parts.push(`Lines: ${evidence.lines.slice(0, 10).join(', ')}`);
+    }
+
+    // Stack trace (condensed)
+    if (evidence.stackTrace.length > 0) {
+      parts.push('');
+      parts.push('## Stack Trace (top 5 frames)');
+      parts.push('```');
+      for (const line of evidence.stackTrace.slice(0, 5)) {
+        parts.push(line);
+      }
+      parts.push('```');
+    }
+
+    // Hypothesis and fix
+    parts.push('');
+    parts.push('## Diagnosis');
+    parts.push(`**Root Cause**: ${hypothesis.rootCause}`);
+    parts.push('');
+    parts.push(`**Suggested Fix**: ${hypothesis.description}`);
+    parts.push(`**Confidence**: ${Math.round(hypothesis.confidence * 100)}%`);
+
+    // Category-specific instructions
+    parts.push('');
+    parts.push('## Fix Instructions');
+    parts.push(this.getCategoryInstructions(evidence.category, evidence));
+
+    // Verification requirement
+    parts.push('');
+    parts.push('## Verification');
+    parts.push('After fixing, ensure:');
+    parts.push('1. The original error no longer occurs');
+    parts.push('2. No new errors are introduced');
+    parts.push('3. Related tests pass (if applicable)');
+
+    return parts.join('\n');
+  }
+
+  /**
+   * Get category-specific fix instructions
+   */
+  getCategoryInstructions(category, evidence) {
+    const instructions = {
+      SYNTAX: `
+1. Navigate to the file(s) with syntax errors
+2. Check the indicated line numbers for:
+   - Missing or extra brackets, parentheses, braces
+   - Missing semicolons or commas
+   - Incorrect JSX syntax (unclosed tags, invalid expressions)
+3. Fix the syntax errors
+4. Run the linter/compiler to verify`,
+
+      TYPE: `
+1. Locate the code accessing ${evidence.message?.match(/property '(\w+)'/)?.[1] || 'the property'}
+2. Add null/undefined check before access:
+   - Use optional chaining: \`obj?.property\`
+   - Or guard clause: \`if (obj) { ... }\`
+3. Consider why the value might be undefined:
+   - Is data not loaded yet?
+   - Is there a race condition?
+   - Is the property name correct?`,
+
+      REFERENCE: `
+1. Find where the undefined variable is used
+2. Either:
+   - Import it from the correct module
+   - Define it before use
+   - Check for typos in the variable name
+3. If it's a function/class, ensure it's exported from the source`,
+
+      IMPORT: `
+1. Check if the module/package exists:
+   - For npm packages: \`npm install <package>\`
+   - For local files: verify the path is correct
+2. If the export doesn't exist:
+   - Check the source module for available exports
+   - Use default vs named import correctly
+3. Verify the file extension if needed`,
+
+      FILE: `
+1. Check if the referenced file/directory exists
+2. Either:
+   - Create the missing file/directory
+   - Fix the path in the code/config
+3. Verify permissions if needed`,
+
+      LINT: `
+1. Review the specific linting rule violation
+2. Either:
+   - Fix the code to comply with the rule
+   - Add eslint-disable comment if intentional (with explanation)
+3. Consider if the rule should be configured differently`,
+
+      TEST: `
+1. Review the failing test assertion
+2. Determine if:
+   - The test expectation is wrong (update test)
+   - The implementation is wrong (fix code)
+   - The test is testing the wrong thing
+3. Ensure the fix doesn't break other tests`,
+
+      NEXTJS: `
+1. Identify the Server/Client Component boundary issue
+2. Common fixes:
+   - Don't pass functions as props to Client Components
+   - Use "use client" directive where needed
+   - Move client-only code to useEffect
+   - Use serializable props (strings, numbers, objects)
+3. Check if component should be client or server`,
+
+      DATABASE: `
+1. For Prisma issues:
+   - Run: \`npx prisma generate\`
+   - Run: \`npx prisma db push\` or \`npx prisma migrate dev\`
+2. Check DATABASE_URL in .env
+3. Verify database connection and permissions
+4. Check schema matches database state`,
+
+      RUNTIME: `
+1. Add console.log statements to trace the issue
+2. Check the error stack trace for the source
+3. Look for:
+   - Async/await issues
+   - State management bugs
+   - Race conditions
+4. Use debugger breakpoints if available`
+    };
+
+    return instructions[category] || `
+1. Review the error message and stack trace
+2. Locate the source of the error
+3. Apply the suggested fix
+4. Test to verify the fix works`;
+  }
+
+  /**
+   * Document a fix in the debug log
+   */
+  async documentFix(fixInfo) {
+    await fs.ensureDir(this.debugDir);
+
+    const fixesFile = path.join(this.debugDir, 'fixes.md');
+    const timestamp = new Date().toISOString();
+
+    const entry = `
+## Fix Applied - ${timestamp}
+
+**Error Type**: ${fixInfo.errorType || 'Unknown'}
+**Category**: ${fixInfo.category}
+**Confidence**: ${Math.round((fixInfo.confidence || 0) * 100)}%
+
+### Root Cause
+${fixInfo.rootCause || 'Not determined'}
+
+### Fix Applied
+${fixInfo.description || 'Manual fix'}
+
+### Files Modified
+${(fixInfo.files || []).map(f => `- ${f}`).join('\n') || '- Unknown'}
+
+### Verification
+- Status: ${fixInfo.verified ? '✅ Verified' : '⏳ Pending verification'}
+${fixInfo.verificationOutput ? `- Output: ${fixInfo.verificationOutput}` : ''}
+
+---
+`;
+
+    // Append to fixes log
+    let content = '';
+    if (await fs.pathExists(fixesFile)) {
+      content = await fs.readFile(fixesFile, 'utf-8');
+    } else {
+      content = `# Vibecode Debug - Fix History
+
+This file tracks all fixes applied through the Vibecode debug system.
+
+---
+`;
+    }
+
+    await fs.writeFile(fixesFile, content + entry);
+    return fixesFile;
+  }
+
+  /**
+   * Update CLAUDE.md with prevention rules
+   */
+  async updateClaudeMd(fix) {
+    const claudeMdPath = path.join(this.projectPath, 'CLAUDE.md');
+    let content = '';
+
+    if (await fs.pathExists(claudeMdPath)) {
+      content = await fs.readFile(claudeMdPath, 'utf-8');
+    } else {
+      content = `# CLAUDE.md - Project Guidelines
+
+This file contains project-specific guidelines and lessons learned.
+
+`;
+    }
+
+    // Check if we already have a debugging section
+    const debugSection = '## Debugging History & Prevention';
+    if (!content.includes(debugSection)) {
+      content += `\n${debugSection}\n\n`;
+    }
+
+    // Generate prevention rule
+    const preventionRule = this.generatePreventionRule(fix);
+
+    // Add to the debugging section
+    const sectionIndex = content.indexOf(debugSection);
+    const insertPoint = content.indexOf('\n\n', sectionIndex + debugSection.length);
+
+    if (insertPoint !== -1) {
+      content = content.slice(0, insertPoint) +
+                '\n' + preventionRule +
+                content.slice(insertPoint);
+    } else {
+      content += preventionRule + '\n';
+    }
+
+    await fs.writeFile(claudeMdPath, content);
+    return claudeMdPath;
+  }
+
+  /**
+   * Generate a prevention rule from a fix
+   */
+  generatePreventionRule(fix) {
+    const rules = {
+      SYNTAX: `- ⚠️ Check syntax carefully: ${fix.message || 'brackets, semicolons, JSX tags'}`,
+      TYPE: `- ⚠️ Always use optional chaining (?.) when accessing: ${fix.files?.[0] || 'nested properties'}`,
+      REFERENCE: `- ⚠️ Ensure imports exist before using: ${fix.message?.match(/'(\w+)'/)?.[1] || 'variables'}`,
+      IMPORT: `- ⚠️ Verify module paths and exports: ${fix.files?.[0] || 'check imports'}`,
+      NEXTJS: `- ⚠️ Never pass functions to Client Components - use formatType strings instead`,
+      DATABASE: `- ⚠️ Run prisma generate after schema changes`,
+      TEST: `- ⚠️ Keep tests in sync with implementation`,
+      LINT: `- ⚠️ Follow linting rules: ${fix.message || 'check ESLint config'}`,
+      FILE: `- ⚠️ Verify file paths before referencing`,
+      RUNTIME: `- ⚠️ Handle edge cases: ${fix.rootCause || 'check for null/undefined'}`
+    };
+
+    const timestamp = new Date().toISOString().split('T')[0];
+    const rule = rules[fix.category] || `- ⚠️ Avoid: ${fix.rootCause || fix.description}`;
+
+    return `### [${timestamp}] ${fix.category} Fix
+${rule}
+`;
+  }
+
+  /**
+   * Generate a minimal fix prompt (for auto-fix mode)
+   */
+  generateMinimalPrompt(evidence, hypothesis) {
+    const parts = [
+      `Fix this ${evidence.category} error:`,
+      '',
+      `Error: ${evidence.message || evidence.description}`,
+      ''
+    ];
+
+    if (evidence.files.length > 0) {
+      parts.push(`File: ${evidence.files[0]}`);
+    }
+
+    if (evidence.lines.length > 0) {
+      parts.push(`Line: ${evidence.lines[0]}`);
+    }
+
+    parts.push('');
+    parts.push(`Fix: ${hypothesis.description}`);
+
+    return parts.join('\n');
+  }
+
+  /**
+   * Create a fix attempt record
+   */
+  createFixAttempt(evidence, hypothesis) {
+    return {
+      id: `fix-${Date.now()}`,
+      timestamp: new Date().toISOString(),
+      errorType: evidence.type,
+      category: evidence.category,
+      message: evidence.message,
+      files: evidence.files,
+      lines: evidence.lines,
+      rootCause: hypothesis.rootCause,
+      description: hypothesis.description,
+      confidence: hypothesis.confidence,
+      status: 'pending',
+      verified: false
+    };
+  }
+}
+
+export function createFixGenerator(projectPath) {
+  return new FixGenerator(projectPath);
+}

package/src/debug/index.js

@@ -0,0 +1,349 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE DEBUG - Main Debug Engine
+// Orchestrates the 9-step intelligent debugging workflow
+// ═══════════════════════════════════════════════════════════════════════════════
+//
+// The 9-Step Debug Protocol:
+// 1. EVIDENCE    - Gather error information
+// 2. REPRODUCE   - Confirm the error exists
+// 3. ANALYZE     - Identify root cause
+// 4. HYPOTHESIZE - Generate fix hypotheses
+// 5. TEST        - Test hypothesis validity
+// 6. FIX         - Apply the fix via Claude Code
+// 7. VERIFY      - Confirm the fix works
+// 8. DOCUMENT    - Log the fix for future reference
+// 9. PREVENT     - Add prevention rules to CLAUDE.md
+//
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+import { EvidenceCollector } from './evidence.js';
+import { RootCauseAnalyzer } from './analyzer.js';
+import { FixGenerator } from './fixer.js';
+import { FixVerifier } from './verifier.js';
+import { spawnClaudeCode, isClaudeCodeAvailable } from '../providers/index.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * Debug Engine Class
+ * Main orchestrator for the debugging workflow
+ */
+export class DebugEngine {
+  constructor(projectPath, options = {}) {
+    this.projectPath = projectPath;
+    this.options = {
+      autoFix: options.autoFix || false,
+      maxAttempts: options.maxAttempts || 3,
+      verbose: options.verbose || false,
+      interactive: options.interactive !== false,
+      ...options
+    };
+
+    // Initialize components
+    this.evidence = new EvidenceCollector(projectPath);
+    this.analyzer = new RootCauseAnalyzer();
+    this.fixer = new FixGenerator(projectPath);
+    this.verifier = new FixVerifier(projectPath);
+
+    // Debug session state
+    this.session = {
+      id: `debug-${Date.now()}`,
+      startTime: new Date().toISOString(),
+      steps: [],
+      attempts: 0,
+      resolved: false
+    };
+  }
+
+  /**
+   * Run the full debug workflow
+   */
+  async debug(input) {
+    console.log(chalk.cyan.bold('\n🔍 VIBECODE DEBUG - Intelligent Bug Fixing\n'));
+
+    try {
+      // Step 1: EVIDENCE - Gather error information
+      this.logStep(1, 'EVIDENCE', 'Gathering error information...');
+      const evidence = await this.evidence.collect(input);
+      this.session.steps.push({ step: 'EVIDENCE', data: evidence });
+      this.logEvidence(evidence);
+
+      // Step 2: REPRODUCE - Confirm error exists (if auto mode)
+      if (input.auto) {
+        this.logStep(2, 'REPRODUCE', 'Confirming error exists...');
+        const reproduced = await this.reproduce(evidence);
+        this.session.steps.push({ step: 'REPRODUCE', data: reproduced });
+
+        if (!reproduced.errorFound) {
+          console.log(chalk.green('  ✓ No errors found during reproduction check'));
+          return this.createResult('no_error', 'No errors found to fix');
+        }
+      }
+
+      // Step 3: ANALYZE - Identify root cause
+      this.logStep(3, 'ANALYZE', 'Analyzing root cause...');
+      const analysis = await this.analyzer.analyze(evidence);
+      this.session.steps.push({ step: 'ANALYZE', data: analysis });
+      this.logAnalysis(analysis);
+
+      // Step 4: HYPOTHESIZE - Generate fix hypotheses
+      this.logStep(4, 'HYPOTHESIZE', 'Generating fix hypotheses...');
+      const hypotheses = this.analyzer.buildHypotheses(analysis);
+      this.session.steps.push({ step: 'HYPOTHESIZE', data: hypotheses });
+      this.logHypotheses(hypotheses);
+
+      if (hypotheses.length === 0) {
+        console.log(chalk.yellow('  ⚠ No fix hypotheses generated'));
+        return this.createResult('no_hypothesis', 'Could not generate fix hypotheses');
+      }
+
+      // Step 5-7: TEST, FIX, VERIFY - Attempt fixes
+      let fixResult = null;
+      for (let attempt = 0; attempt < this.options.maxAttempts && !this.session.resolved; attempt++) {
+        this.session.attempts = attempt + 1;
+
+        const hypothesis = hypotheses[attempt % hypotheses.length];
+        console.log(chalk.cyan(`\n  Attempt ${attempt + 1}/${this.options.maxAttempts}:`));
+
+        // Step 5: TEST - Generate fix prompt
+        this.logStep(5, 'TEST', 'Preparing fix...');
+        const fixPrompt = this.fixer.generateFixPrompt(evidence, hypothesis);
+        const fixAttempt = this.fixer.createFixAttempt(evidence, hypothesis);
+
+        // Step 6: FIX - Apply fix via Claude Code
+        this.logStep(6, 'FIX', 'Applying fix via Claude Code...');
+        fixResult = await this.applyFix(fixPrompt);
+        fixAttempt.status = fixResult.success ? 'applied' : 'failed';
+
+        if (!fixResult.success) {
+          console.log(chalk.yellow(`  ⚠ Fix application failed: ${fixResult.error}`));
+          continue;
+        }
+
+        // Step 7: VERIFY - Confirm fix works
+        this.logStep(7, 'VERIFY', 'Verifying fix...');
+        const verification = await this.verifier.verify(evidence, fixAttempt);
+        this.session.steps.push({ step: 'VERIFY', data: verification });
+
+        if (verification.passed) {
+          console.log(chalk.green('  ✓ Fix verified successfully!'));
+          this.session.resolved = true;
+          fixAttempt.verified = true;
+
+          // Step 8: DOCUMENT - Log the fix
+          this.logStep(8, 'DOCUMENT', 'Documenting fix...');
+          await this.fixer.documentFix(fixAttempt);
+
+          // Step 9: PREVENT - Add prevention rules
+          this.logStep(9, 'PREVENT', 'Adding prevention rules...');
+          await this.fixer.updateClaudeMd(fixAttempt);
+
+          console.log(chalk.green.bold('\n✅ Bug fixed and documented!\n'));
+        } else {
+          console.log(chalk.yellow('  ⚠ Verification failed, trying next approach...'));
+        }
+      }
+
+      return this.createResult(
+        this.session.resolved ? 'resolved' : 'unresolved',
+        this.session.resolved ? 'Bug fixed successfully' : 'Could not resolve after max attempts',
+        fixResult
+      );
+
+    } catch (error) {
+      console.log(chalk.red(`\n❌ Debug error: ${error.message}\n`));
+      return this.createResult('error', error.message);
+    }
+  }
+
+  /**
+   * Quick debug mode - minimal interaction
+   */
+  async quickDebug(description) {
+    return this.debug({
+      description,
+      auto: false
+    });
+  }
+
+  /**
+   * Auto scan and fix mode
+   */
+  async autoDebug() {
+    console.log(chalk.cyan('🔄 Auto-scanning project for errors...\n'));
+
+    return this.debug({
+      auto: true
+    });
+  }
+
+  /**
+   * Reproduce the error to confirm it exists
+   */
+  async reproduce(evidence) {
+    const result = {
+      errorFound: false,
+      output: ''
+    };
+
+    // Try to reproduce based on category
+    try {
+      const checks = {
+        SYNTAX: 'npx tsc --noEmit',
+        TYPE: 'npx tsc --noEmit',
+        IMPORT: 'npx tsc --noEmit',
+        BUILD: 'npm run build',
+        LINT: 'npm run lint',
+        TEST: 'npm test'
+      };
+
+      const command = checks[evidence.category] || 'npm run build';
+
+      await execAsync(command, {
+        cwd: this.projectPath,
+        timeout: 60000
+      });
+
+      result.output = 'Command succeeded';
+    } catch (error) {
+      result.errorFound = true;
+      result.output = error.stderr || error.stdout || error.message;
+    }
+
+    return result;
+  }
+
+  /**
+   * Apply a fix using Claude Code
+   */
+  async applyFix(prompt) {
+    const result = {
+      success: false,
+      output: '',
+      error: null
+    };
+
+    try {
+      // 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-ai/claude-code');
+      }
+
+      // Save prompt to debug folder for reference
+      const promptFile = path.join(this.projectPath, '.vibecode', 'debug', 'current-fix.md');
+      await fs.ensureDir(path.dirname(promptFile));
+      await fs.writeFile(promptFile, prompt);
+
+      if (this.options.verbose) {
+        console.log(chalk.gray(`  Running Claude Code with fix prompt...`));
+      }
+
+      // Use spawnClaudeCode which handles temp file properly
+      const spawnResult = await spawnClaudeCode(prompt, {
+        cwd: this.projectPath
+      });
+
+      result.success = spawnResult.success;
+      result.output = `Exit code: ${spawnResult.code}`;
+
+    } catch (error) {
+      result.error = error.message;
+      result.output = '';
+    }
+
+    return result;
+  }
+
+  /**
+   * Log a debug step
+   */
+  logStep(number, name, message) {
+    const stepLabel = chalk.cyan(`[${number}/9 ${name}]`);
+    console.log(`${stepLabel} ${message}`);
+  }
+
+  /**
+   * Log evidence summary
+   */
+  logEvidence(evidence) {
+    console.log(chalk.gray(`  Type: ${evidence.type || 'Unknown'}`));
+    console.log(chalk.gray(`  Category: ${evidence.category}`));
+    if (evidence.message) {
+      console.log(chalk.gray(`  Message: ${evidence.message.substring(0, 100)}${evidence.message.length > 100 ? '...' : ''}`));
+    }
+    if (evidence.files.length > 0) {
+      console.log(chalk.gray(`  Files: ${evidence.files.slice(0, 3).join(', ')}${evidence.files.length > 3 ? '...' : ''}`));
+    }
+  }
+
+  /**
+   * Log analysis results
+   */
+  logAnalysis(analysis) {
+    console.log(chalk.gray(`  Root cause: ${analysis.rootCause || 'Unknown'}`));
+    console.log(chalk.gray(`  Confidence: ${Math.round(analysis.confidence * 100)}%`));
+    if (analysis.patterns.length > 0) {
+      console.log(chalk.gray(`  Patterns: ${analysis.patterns.join(', ')}`));
+    }
+  }
+
+  /**
+   * Log hypotheses
+   */
+  logHypotheses(hypotheses) {
+    console.log(chalk.gray(`  Generated ${hypotheses.length} hypothesis(es):`));
+    for (const h of hypotheses.slice(0, 3)) {
+      console.log(chalk.gray(`  - ${h.description.substring(0, 60)}... (${Math.round(h.confidence * 100)}%)`));
+    }
+  }
+
+  /**
+   * Create result object
+   */
+  createResult(status, message, fixResult = null) {
+    return {
+      status,
+      message,
+      session: {
+        id: this.session.id,
+        attempts: this.session.attempts,
+        resolved: this.session.resolved,
+        steps: this.session.steps.length
+      },
+      fixResult
+    };
+  }
+
+  /**
+   * Get debug session summary
+   */
+  getSessionSummary() {
+    return {
+      id: this.session.id,
+      startTime: this.session.startTime,
+      attempts: this.session.attempts,
+      resolved: this.session.resolved,
+      stepsCompleted: this.session.steps.map(s => s.step)
+    };
+  }
+}
+
+/**
+ * Create a new debug engine instance
+ */
+export function createDebugEngine(projectPath, options = {}) {
+  return new DebugEngine(projectPath, options);
+}
+
+// Re-export components
+export { EvidenceCollector } from './evidence.js';
+export { RootCauseAnalyzer } from './analyzer.js';
+export { FixGenerator } from './fixer.js';
+export { FixVerifier } from './verifier.js';