@nclamvn/vibecode-cli 1.2.0 → 1.5.0

package/src/core/test-runner.js

@@ -43,9 +43,10 @@ export async function runTests(projectPath) {
       results.tests.push(npmTest);
     }
 
-    // 3. Run npm run lint (if script exists)
+    // 3. Run npm run lint (if script exists) - soft fail (warnings only)
     if (pkg.scripts?.lint) {
       const npmLint = await runCommand('npm run lint', projectPath, 'npm lint');
+      npmLint.softFail = true; // Lint errors are warnings, don't block build
       results.tests.push(npmLint);
     }
 
@@ -70,11 +71,21 @@ export async function runTests(projectPath) {
   }
 
   // 7. Aggregate results
+  // Separate hard tests from soft-fail tests (like lint)
+  const hardTests = results.tests.filter(t => !t.softFail);
+  const softTests = results.tests.filter(t => t.softFail);
+
   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.summary.warnings = softTests.filter(t => !t.passed).length;
+
+  // Only hard tests determine pass/fail
+  results.passed = hardTests.length === 0 || hardTests.every(t => t.passed);
+
+  // Collect errors, but mark soft-fail errors as warnings
+  results.errors = results.tests.filter(t => !t.passed && !t.softFail).flatMap(t => t.errors || []);
+  results.warnings = softTests.filter(t => !t.passed).flatMap(t => t.errors || []);
   results.duration = Date.now() - startTime;
 
   return results;
@@ -230,12 +241,17 @@ export function formatTestResults(results) {
   const lines = [];
 
   lines.push(`Tests: ${results.summary.passed}/${results.summary.total} passed`);
+  if (results.summary.warnings > 0) {
+    lines.push(`Warnings: ${results.summary.warnings} (lint)`);
+  }
   lines.push(`Duration: ${(results.duration / 1000).toFixed(1)}s`);
 
-  if (!results.passed) {
+  // Show hard failures
+  const hardFailures = results.tests.filter(t => !t.passed && !t.softFail);
+  if (hardFailures.length > 0) {
     lines.push('');
     lines.push('Failed tests:');
-    for (const test of results.tests.filter(t => !t.passed)) {
+    for (const test of hardFailures) {
       lines.push(`  ❌ ${test.name}`);
       for (const error of test.errors || []) {
         const loc = error.file ? `${error.file}:${error.line || '?'}` : '';
@@ -244,5 +260,22 @@ export function formatTestResults(results) {
     }
   }
 
+  // Show soft failures (warnings)
+  const softFailures = results.tests.filter(t => !t.passed && t.softFail);
+  if (softFailures.length > 0) {
+    lines.push('');
+    lines.push('Warnings (non-blocking):');
+    for (const test of softFailures) {
+      lines.push(`  ⚠️  ${test.name}`);
+      for (const error of (test.errors || []).slice(0, 3)) {
+        const loc = error.file ? `${error.file}:${error.line || '?'}` : '';
+        lines.push(`     ${loc} ${error.message?.substring(0, 80) || ''}`);
+      }
+      if ((test.errors?.length || 0) > 3) {
+        lines.push(`     ... and ${test.errors.length - 3} more`);
+      }
+    }
+  }
+
   return lines.join('\n');
 }

package/src/debug/analyzer.js

@@ -0,0 +1,329 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE DEBUG - Root Cause Analyzer
+// Analyzes evidence to determine root cause and generate hypotheses
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Root Cause Analyzer Class
+ * Uses pattern matching and heuristics to identify bug sources
+ */
+export class RootCauseAnalyzer {
+  constructor() {
+    this.patterns = this.initPatterns();
+  }
+
+  /**
+   * Analyze evidence to find root cause
+   */
+  async analyze(evidence) {
+    const analysis = {
+      category: evidence.category,
+      rootCause: null,
+      suggestedFix: null,
+      relatedFiles: evidence.files || [],
+      confidence: 0,
+      patterns: []
+    };
+
+    // Match against known patterns
+    for (const pattern of this.patterns) {
+      if (this.matchesPattern(evidence, pattern)) {
+        analysis.patterns.push(pattern.name);
+
+        if (pattern.confidence > analysis.confidence) {
+          analysis.rootCause = pattern.rootCause;
+          analysis.suggestedFix = pattern.fix;
+          analysis.confidence = pattern.confidence;
+        }
+      }
+    }
+
+    // If no pattern matched, use generic analysis
+    if (!analysis.rootCause) {
+      analysis.rootCause = this.inferRootCause(evidence);
+      analysis.confidence = 0.3;
+    }
+
+    return analysis;
+  }
+
+  /**
+   * Build hypotheses from analysis
+   */
+  buildHypotheses(analysis) {
+    const hypotheses = [];
+
+    // Primary hypothesis from analysis
+    if (analysis.suggestedFix) {
+      hypotheses.push({
+        description: analysis.suggestedFix,
+        confidence: analysis.confidence,
+        category: analysis.category,
+        rootCause: analysis.rootCause
+      });
+    }
+
+    // Add category-specific hypotheses
+    const categoryFixes = this.getCategoryFixes(analysis.category);
+    for (const fix of categoryFixes) {
+      if (!hypotheses.find(h => h.description === fix.description)) {
+        hypotheses.push({
+          ...fix,
+          category: analysis.category
+        });
+      }
+    }
+
+    // Sort by confidence
+    return hypotheses.sort((a, b) => b.confidence - a.confidence);
+  }
+
+  /**
+   * Initialize pattern database
+   */
+  initPatterns() {
+    return [
+      // Next.js specific
+      {
+        name: 'nextjs-server-client-boundary',
+        match: (e) => {
+          const msg = (e.message || e.description || '').toLowerCase();
+          return msg.includes('functions cannot be passed directly to client components') ||
+                 msg.includes('client component') && msg.includes('server');
+        },
+        rootCause: 'Server/Client Component boundary violation in Next.js',
+        fix: 'Convert function props to serializable format (e.g., use formatType string instead of formatValue function). Or mark the function with "use server".',
+        confidence: 0.95
+      },
+      {
+        name: 'nextjs-hydration',
+        match: (e) => {
+          const msg = (e.message || e.description || '').toLowerCase();
+          return msg.includes('hydration') || msg.includes('text content does not match');
+        },
+        rootCause: 'Hydration mismatch between server and client render',
+        fix: 'Ensure server and client render identical content. Use useEffect for client-only code.',
+        confidence: 0.85
+      },
+
+      // Type errors
+      {
+        name: 'undefined-property-access',
+        match: (e) => {
+          const msg = (e.message || '').toLowerCase();
+          return msg.includes('cannot read properties of undefined') ||
+                 msg.includes('cannot read property') && msg.includes('undefined');
+        },
+        rootCause: 'Accessing property on undefined object',
+        fix: 'Add null check or optional chaining (?.) before property access',
+        confidence: 0.85
+      },
+      {
+        name: 'null-property-access',
+        match: (e) => {
+          const msg = (e.message || '').toLowerCase();
+          return msg.includes('cannot read properties of null');
+        },
+        rootCause: 'Accessing property on null value',
+        fix: 'Add null check before property access. Check if data is loaded before accessing.',
+        confidence: 0.85
+      },
+
+      // Import errors
+      {
+        name: 'module-not-found',
+        match: (e) => {
+          const msg = (e.message || e.description || '').toLowerCase();
+          return msg.includes('cannot find module') || msg.includes('module not found');
+        },
+        rootCause: 'Missing import or incorrect module path',
+        fix: 'Install missing package with npm install, or fix import path',
+        confidence: 0.9
+      },
+      {
+        name: 'export-not-found',
+        match: (e) => {
+          const msg = (e.message || '').toLowerCase();
+          return msg.includes('does not provide an export named') ||
+                 msg.includes('is not exported from');
+        },
+        rootCause: 'Importing non-existent export',
+        fix: 'Check export name in source module. Use correct named or default import.',
+        confidence: 0.9
+      },
+
+      // Syntax errors
+      {
+        name: 'unexpected-token',
+        match: (e) => {
+          const msg = (e.message || '').toLowerCase();
+          return msg.includes('unexpected token') || e.type === 'SyntaxError';
+        },
+        rootCause: 'Syntax error in JavaScript/TypeScript code',
+        fix: 'Fix syntax error at indicated line. Check for missing brackets, semicolons, or incorrect syntax.',
+        confidence: 0.9
+      },
+      {
+        name: 'jsx-syntax',
+        match: (e) => {
+          const msg = (e.message || '').toLowerCase();
+          return msg.includes('jsx') && (msg.includes('unexpected') || msg.includes('syntax'));
+        },
+        rootCause: 'JSX syntax error',
+        fix: 'Check JSX syntax. Ensure proper closing tags and valid JSX expressions.',
+        confidence: 0.85
+      },
+
+      // Reference errors
+      {
+        name: 'undefined-variable',
+        match: (e) => {
+          const msg = (e.message || '').toLowerCase();
+          return msg.includes('is not defined') || e.type === 'ReferenceError';
+        },
+        rootCause: 'Using undefined variable',
+        fix: 'Define the variable before use, or import it from the correct module',
+        confidence: 0.85
+      },
+
+      // Database errors
+      {
+        name: 'prisma-client',
+        match: (e) => {
+          const msg = (e.message || '').toLowerCase();
+          return msg.includes('prisma') || msg.includes('@prisma/client');
+        },
+        rootCause: 'Prisma database client error',
+        fix: 'Run npx prisma generate and npx prisma db push. Check DATABASE_URL.',
+        confidence: 0.8
+      },
+
+      // Auth errors
+      {
+        name: 'nextauth-error',
+        match: (e) => {
+          const msg = (e.message || '').toLowerCase();
+          return msg.includes('next-auth') || msg.includes('nextauth');
+        },
+        rootCause: 'NextAuth configuration error',
+        fix: 'Check NEXTAUTH_URL and NEXTAUTH_SECRET in .env. Verify auth provider config.',
+        confidence: 0.8
+      },
+
+      // ESLint/Lint errors
+      {
+        name: 'eslint-error',
+        match: (e) => e.category === 'LINT' || (e.message || '').toLowerCase().includes('eslint'),
+        rootCause: 'ESLint code style violation',
+        fix: 'Fix the linting error or add eslint-disable comment if intentional',
+        confidence: 0.75
+      },
+
+      // Test failures
+      {
+        name: 'test-assertion',
+        match: (e) => {
+          const msg = (e.message || '').toLowerCase();
+          return msg.includes('expect') || msg.includes('assertion') || e.category === 'TEST';
+        },
+        rootCause: 'Test assertion failure',
+        fix: 'Review test expectations and implementation. Update test or fix code.',
+        confidence: 0.7
+      }
+    ];
+  }
+
+  /**
+   * Check if evidence matches a pattern
+   */
+  matchesPattern(evidence, pattern) {
+    try {
+      return pattern.match(evidence);
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Infer root cause when no pattern matches
+   */
+  inferRootCause(evidence) {
+    const parts = [];
+
+    if (evidence.type && evidence.type !== 'unknown') {
+      parts.push(evidence.type);
+    }
+
+    if (evidence.files.length > 0) {
+      parts.push(`in ${evidence.files[0]}`);
+    }
+
+    if (evidence.lines.length > 0) {
+      parts.push(`at line ${evidence.lines[0]}`);
+    }
+
+    if (parts.length === 0) {
+      return 'Unknown error - manual investigation needed';
+    }
+
+    return parts.join(' ');
+  }
+
+  /**
+   * Get category-specific fixes
+   */
+  getCategoryFixes(category) {
+    const fixes = {
+      SYNTAX: [
+        { description: 'Check for missing brackets, parentheses, or semicolons', confidence: 0.6 },
+        { description: 'Verify JSX syntax and proper tag closing', confidence: 0.5 }
+      ],
+      TYPE: [
+        { description: 'Add null/undefined check before property access', confidence: 0.6 },
+        { description: 'Use optional chaining (?.) for nested access', confidence: 0.6 },
+        { description: 'Verify variable types match expected types', confidence: 0.5 }
+      ],
+      REFERENCE: [
+        { description: 'Import or define the missing variable', confidence: 0.6 },
+        { description: 'Check for typos in variable names', confidence: 0.5 }
+      ],
+      IMPORT: [
+        { description: 'Install missing package: npm install <package>', confidence: 0.7 },
+        { description: 'Fix import path to correct location', confidence: 0.6 },
+        { description: 'Check if export exists in source module', confidence: 0.5 }
+      ],
+      FILE: [
+        { description: 'Create missing file or directory', confidence: 0.6 },
+        { description: 'Fix file path in configuration', confidence: 0.5 }
+      ],
+      LINT: [
+        { description: 'Fix code style violation', confidence: 0.6 },
+        { description: 'Add eslint-disable comment if intentional', confidence: 0.4 }
+      ],
+      TEST: [
+        { description: 'Update test expectations to match implementation', confidence: 0.5 },
+        { description: 'Fix implementation to pass test', confidence: 0.5 }
+      ],
+      NEXTJS: [
+        { description: 'Check Server/Client Component boundaries', confidence: 0.7 },
+        { description: 'Move client-only code to useEffect', confidence: 0.6 }
+      ],
+      DATABASE: [
+        { description: 'Run prisma generate and db push', confidence: 0.7 },
+        { description: 'Check DATABASE_URL environment variable', confidence: 0.6 }
+      ],
+      RUNTIME: [
+        { description: 'Debug runtime error with console.log', confidence: 0.3 },
+        { description: 'Check error stack trace for source', confidence: 0.4 }
+      ]
+    };
+
+    return fixes[category] || [
+      { description: 'Investigate error message and stack trace', confidence: 0.2 }
+    ];
+  }
+}
+
+export function createRootCauseAnalyzer() {
+  return new RootCauseAnalyzer();
+}

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