@nclamvn/vibecode-cli 2.0.0 → 2.1.0

package/src/debug/evidence.js

@@ -0,0 +1,228 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE DEBUG - Evidence Collector
+// Gathers error information from multiple sources
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs-extra';
+import path from 'path';
+
+const execAsync = promisify(exec);
+
+/**
+ * Evidence Collector Class
+ * Gathers and parses error information from various sources
+ */
+export class EvidenceCollector {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+
+  /**
+   * Collect evidence from all available sources
+   */
+  async collect(input) {
+    const evidence = {
+      type: 'unknown',
+      category: 'RUNTIME',
+      description: input.description || '',
+      message: '',
+      stackTrace: [],
+      files: [],
+      lines: [],
+      logs: [],
+      hasImage: false,
+      imagePath: null,
+      timestamp: new Date().toISOString()
+    };
+
+    // From description
+    if (input.description) {
+      this.parseDescription(evidence, input.description);
+    }
+
+    // From log paste
+    if (input.log) {
+      this.parseLog(evidence, input.log);
+    }
+
+    // From image (note for future OCR)
+    if (input.image) {
+      await this.parseImage(evidence, input.image);
+    }
+
+    // Auto-scan mode
+    if (input.auto) {
+      await this.autoScan(evidence);
+    }
+
+    // Categorize error
+    evidence.category = this.categorizeError(evidence);
+
+    return evidence;
+  }
+
+  /**
+   * Parse error description text
+   */
+  parseDescription(evidence, description) {
+    const desc = description.toLowerCase();
+
+    // Detect error type from description
+    if (desc.includes('typeerror')) evidence.type = 'TypeError';
+    else if (desc.includes('syntaxerror')) evidence.type = 'SyntaxError';
+    else if (desc.includes('referenceerror')) evidence.type = 'ReferenceError';
+    else if (desc.includes('cannot find module')) evidence.type = 'ImportError';
+    else if (desc.includes('undefined')) evidence.type = 'UndefinedError';
+    else if (desc.includes('cannot read properties')) evidence.type = 'TypeError';
+
+    // Extract file references
+    const fileMatches = description.match(/[\w\/\-\.]+\.(js|ts|tsx|jsx|json|mjs|cjs)/gi);
+    if (fileMatches) {
+      evidence.files = [...new Set(fileMatches)];
+    }
+
+    // Extract line numbers
+    const lineMatches = description.match(/:(\d+)(?::\d+)?/g);
+    if (lineMatches) {
+      evidence.lines = lineMatches.map(m => parseInt(m.split(':')[1]));
+    }
+
+    // Extract error message
+    const errorMatch = description.match(/(Error|TypeError|SyntaxError|ReferenceError):\s*(.+?)(?:\n|$)/i);
+    if (errorMatch) {
+      evidence.type = errorMatch[1];
+      evidence.message = errorMatch[2].trim();
+    }
+  }
+
+  /**
+   * Parse error log text
+   */
+  parseLog(evidence, log) {
+    evidence.logs.push(log);
+
+    // Parse stack trace
+    const stackLines = log.split('\n').filter(line =>
+      line.trim().startsWith('at ') || line.includes('Error:')
+    );
+    evidence.stackTrace = stackLines.slice(0, 15);
+
+    // Extract error message
+    const errorMatch = log.match(/(Error|TypeError|SyntaxError|ReferenceError|RangeError):\s*(.+?)(?:\n|$)/i);
+    if (errorMatch) {
+      evidence.type = errorMatch[1];
+      evidence.message = errorMatch[2].trim();
+    }
+
+    // Extract files from stack trace
+    const fileMatches = log.match(/(?:at\s+)?(?:\w+\s+)?\(?([^\s()]+\.(js|ts|tsx|jsx)):(\d+)(?::\d+)?\)?/gi);
+    if (fileMatches) {
+      for (const match of fileMatches) {
+        const fileMatch = match.match(/([^\s()]+\.(js|ts|tsx|jsx)):(\d+)/i);
+        if (fileMatch) {
+          evidence.files.push(fileMatch[1]);
+          evidence.lines.push(parseInt(fileMatch[3]));
+        }
+      }
+      evidence.files = [...new Set(evidence.files)];
+    }
+  }
+
+  /**
+   * Parse image evidence (placeholder for OCR/Vision)
+   */
+  async parseImage(evidence, imagePath) {
+    if (await fs.pathExists(imagePath)) {
+      evidence.hasImage = true;
+      evidence.imagePath = imagePath;
+      // Future: OCR or Claude Vision API
+    }
+  }
+
+  /**
+   * Auto-scan project for errors
+   */
+  async autoScan(evidence) {
+    const checks = [
+      { name: 'npm test', cmd: 'npm test', softFail: true },
+      { name: 'npm build', cmd: 'npm run build', softFail: false },
+      { name: 'npm lint', cmd: 'npm run lint', softFail: true },
+      { name: 'tsc', cmd: 'npx tsc --noEmit', softFail: true }
+    ];
+
+    // Check if package.json exists
+    const pkgPath = path.join(this.projectPath, 'package.json');
+    if (!await fs.pathExists(pkgPath)) {
+      evidence.logs.push({ source: 'auto-scan', error: 'No package.json found' });
+      return;
+    }
+
+    const pkg = await fs.readJson(pkgPath);
+
+    for (const check of checks) {
+      // Skip if script doesn't exist
+      const scriptName = check.cmd.replace('npm run ', '').replace('npm ', '');
+      if (check.cmd.startsWith('npm') && scriptName !== 'test' && !pkg.scripts?.[scriptName]) {
+        continue;
+      }
+
+      try {
+        await execAsync(check.cmd, {
+          cwd: this.projectPath,
+          timeout: 60000,
+          maxBuffer: 10 * 1024 * 1024
+        });
+      } catch (error) {
+        const errorOutput = error.stderr || error.stdout || error.message;
+        evidence.logs.push({
+          source: check.name,
+          error: errorOutput.substring(0, 5000), // Limit size
+          exitCode: error.code
+        });
+
+        // Parse errors from output
+        this.parseLog(evidence, errorOutput);
+      }
+    }
+  }
+
+  /**
+   * Categorize error by type
+   */
+  categorizeError(evidence) {
+    const type = (evidence.type || '').toLowerCase();
+    const msg = (evidence.message || evidence.description || '').toLowerCase();
+
+    if (type.includes('syntax') || msg.includes('unexpected token')) return 'SYNTAX';
+    if (type.includes('type') || msg.includes('cannot read properties')) return 'TYPE';
+    if (type.includes('reference') || msg.includes('is not defined')) return 'REFERENCE';
+    if (msg.includes('cannot find module') || msg.includes('module not found')) return 'IMPORT';
+    if (msg.includes('enoent') || msg.includes('no such file')) return 'FILE';
+    if (msg.includes('eslint') || msg.includes('lint')) return 'LINT';
+    if (msg.includes('test') || msg.includes('expect') || msg.includes('assert')) return 'TEST';
+    if (msg.includes('client component') || msg.includes('server component')) return 'NEXTJS';
+    if (msg.includes('prisma') || msg.includes('database')) return 'DATABASE';
+
+    return 'RUNTIME';
+  }
+
+  /**
+   * Get evidence summary
+   */
+  getSummary(evidence) {
+    return {
+      type: evidence.type,
+      category: evidence.category,
+      message: evidence.message || evidence.description?.substring(0, 100),
+      fileCount: evidence.files.length,
+      hasStackTrace: evidence.stackTrace.length > 0,
+      logSources: evidence.logs.length
+    };
+  }
+}
+
+export function createEvidenceCollector(projectPath) {
+  return new EvidenceCollector(projectPath);
+}

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);
+}