@vibecheckai/cli 3.6.1 → 3.8.0

package/bin/runners/runDoctor.js

@@ -6,6 +6,14 @@
  * ═══════════════════════════════════════════════════════════════════════════════
  * 
  * Comprehensive environment checks with auto-fix capability.
+ * 
+ * Features:
+ * - Full environment diagnostics (Node, npm, OS, build tools, etc.)
+ * - OS-specific quirk detection (Windows/macOS/Linux)
+ * - Known failure signature matching with exact remediation
+ * - "Fix Script" generation (copy-paste commands)
+ * - "Diagnosis Receipt" JSON export
+ * - Safe `--repair` mode for non-destructive fixes
  */
 
 const fs = require("fs");
@@ -309,6 +317,16 @@ async function runDoctor(args, context = {}) {
     printHelp(shouldShowBanner(opts));
     return EXIT.SUCCESS;
   }
+  
+  // Handle --list-actions (list available repair actions)
+  if (opts.listActions) {
+    return handleListActions(opts);
+  }
+  
+  // Handle --analyze (match error text against known signatures)
+  if (opts.analyze) {
+    return handleAnalyzeError(opts.analyze, opts);
+  }
 
   const projectPath = path.resolve(opts.path || process.cwd());
   
@@ -336,7 +354,7 @@ async function runDoctor(args, context = {}) {
     if (DoctorService.name === 'DoctorService') {
       const doctor = new DoctorService(projectPath, {
         json: opts.json,
-        fix: opts.fix,
+        fix: opts.fix && !opts.repair, // Don't use old fix if repair mode
         fixDryRun: opts.dryRun,
         quiet: opts.quiet || quiet,
         verbose: opts.verbose,
@@ -348,9 +366,35 @@ async function runDoctor(args, context = {}) {
       });
       
       const results = await doctor.run();
+      const endTime = new Date().toISOString();
+      
+      // Get diagnostic results for enhanced features
+      const diagnostics = doctor.results || results.checks || [];
+      
+      // Handle --repair mode (safe repairs only)
+      if (opts.repair) {
+        const repairResults = await handleRepairMode(diagnostics, projectPath, opts);
+        if (repairResults.needsRecheck) {
+          if (!quiet && !json) {
+            console.log(`\n  ${colors.accent}↻${c.reset} Re-running diagnostics after repairs...\n`);
+          }
+          return runDoctor(args.filter(a => a !== '--repair'), context);
+        }
+      }
+      
+      // Handle --fix-script (generate copy-paste fix commands)
+      if (opts.fixScript) {
+        handleFixScript(diagnostics, projectPath, opts);
+      }
+      
+      // Handle --receipt (generate diagnosis receipt JSON)
+      if (opts.receipt) {
+        handleReceipt(diagnostics, projectPath, { startTime, endTime, runId }, opts);
+      }
       
       // Apply CLI output conventions
       if (opts.json || json) {
+        // Enhanced JSON output with receipt format
         const output = createJsonOutput({
           runId,
           command: "doctor",
@@ -359,13 +403,21 @@ async function runDoctor(args, context = {}) {
           verdict: exitCodeToVerdict(results.exitCode || EXIT.SUCCESS),
           result: {
             health: results.health || "unknown",
-            checks: results.checks || [],
+            checks: diagnostics.map(d => ({
+              id: d.id,
+              name: d.name,
+              category: d.category,
+              severity: d.severity,
+              message: d.message,
+              detail: d.detail,
+              fixes: d.fixes,
+            })),
             fixes: results.fixes || [],
             summary: {
-              total: results.totalChecks || 0,
-              passed: results.passedChecks || 0,
-              warnings: results.warnings || 0,
-              errors: results.errors || 0,
+              total: results.totalChecks || diagnostics.length,
+              passed: results.passedChecks || diagnostics.filter(d => d.severity === 'pass').length,
+              warnings: results.warnings || diagnostics.filter(d => d.severity === 'warning').length,
+              errors: results.errors || diagnostics.filter(d => d.severity === 'error' || d.severity === 'critical').length,
             }
           },
           tier: "free",
@@ -381,8 +433,8 @@ async function runDoctor(args, context = {}) {
       }
       
       // Save artifacts
-      if (results.checks) {
-        saveArtifact(runId, "checks", results.checks);
+      if (diagnostics.length > 0) {
+        saveArtifact(runId, "checks", diagnostics);
       }
       if (results.fixes) {
         saveArtifact(runId, "fixes", results.fixes);
@@ -407,6 +459,161 @@ async function runDoctor(args, context = {}) {
   }
 }
 
+// ═══════════════════════════════════════════════════════════════════════════════
+// ENHANCED FEATURE HANDLERS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function handleListActions(opts) {
+  const safeRepair = require('./lib/doctor/safe-repair');
+  const actions = safeRepair.listSafeRepairActions();
+  
+  if (opts.json) {
+    console.log(JSON.stringify({ actions }, null, 2));
+  } else {
+    console.log(`\n  ${colors.accent}🔧${c.reset} ${c.bold}Available Safe Repair Actions${c.reset}\n`);
+    printDivider();
+    
+    for (const action of actions) {
+      console.log(`  ${colors.healthy}${action.id}${c.reset}`);
+      console.log(`    ${action.name}`);
+      console.log(`    ${c.dim}${action.description}${c.reset}`);
+      console.log();
+    }
+  }
+  
+  return EXIT.SUCCESS;
+}
+
+function handleAnalyzeError(errorText, opts) {
+  const failureSignatures = require('./lib/doctor/failure-signatures');
+  const matches = failureSignatures.matchFailureSignatures(errorText);
+  
+  if (opts.json) {
+    console.log(JSON.stringify({ 
+      analyzed: errorText.slice(0, 200),
+      matches: matches.map(m => ({
+        id: m.id,
+        name: m.name,
+        diagnosis: m.diagnosis,
+        remediation: m.remediation,
+        commands: m.commands,
+      })),
+      safeCommands: failureSignatures.getSafeCommands(matches),
+    }, null, 2));
+  } else {
+    if (matches.length === 0) {
+      console.log(`\n  ${colors.warning}⚠${c.reset} No known failure signatures matched.\n`);
+      console.log(`  ${c.dim}Try running: vibecheck doctor --verbose${c.reset}\n`);
+    } else {
+      console.log(`\n  ${colors.healthy}✓${c.reset} ${c.bold}Matched ${matches.length} known failure signature(s)${c.reset}\n`);
+      printDivider();
+      
+      for (const match of matches) {
+        console.log(failureSignatures.formatDiagnosis(match));
+        console.log();
+      }
+    }
+  }
+  
+  return EXIT.SUCCESS;
+}
+
+async function handleRepairMode(diagnostics, projectPath, opts) {
+  const safeRepair = require('./lib/doctor/safe-repair');
+  
+  const quiet = shouldSuppressOutput(opts);
+  const json = isJsonMode(opts);
+  
+  if (!quiet && !json) {
+    console.log(`\n  ${colors.accent}🔧${c.reset} ${c.bold}Safe Repair Mode${c.reset}`);
+    printDivider();
+  }
+  
+  const repairResults = await safeRepair.runSafeRepair(diagnostics, projectPath, {
+    dryRun: opts.dryRun,
+    verbose: opts.verbose,
+  });
+  
+  if (json) {
+    console.log(JSON.stringify({ repair: repairResults }, null, 2));
+  } else if (!quiet) {
+    const { summary, results } = repairResults;
+    
+    for (const result of results) {
+      const icon = result.status === 'success' ? `${colors.healthy}✓` : 
+                   result.status === 'failed' ? `${colors.error}✗` :
+                   `${colors.warning}○`;
+      console.log(`  ${icon}${c.reset} ${result.actionName}`);
+      console.log(`    ${c.dim}${result.message}${c.reset}`);
+    }
+    
+    console.log();
+    console.log(`  ${c.bold}Summary:${c.reset} ${summary.succeeded} succeeded, ${summary.failed} failed, ${summary.skipped} skipped`);
+  }
+  
+  return repairResults;
+}
+
+function handleFixScript(diagnostics, projectPath, opts) {
+  const fixScript = require('./lib/doctor/fix-script');
+  
+  const quiet = shouldSuppressOutput(opts);
+  const json = isJsonMode(opts);
+  
+  const format = opts.json ? 'json' : (opts.output?.endsWith('.md') ? 'markdown' : 'shell');
+  const result = fixScript.generateFixScript(diagnostics, {
+    projectPath,
+    format,
+    includeDangerous: false,
+    safeOnly: true,
+  });
+  
+  if (json || format === 'json') {
+    console.log(JSON.stringify(result, null, 2));
+  } else if (!quiet) {
+    // Save to file if output specified
+    if (opts.output) {
+      fs.writeFileSync(opts.output, result.script);
+      console.log(`\n  ${colors.healthy}✓${c.reset} Fix script saved to: ${opts.output}`);
+    } else {
+      console.log(`\n  ${colors.accent}📋${c.reset} ${c.bold}Fix Script${c.reset}`);
+      printDivider();
+      console.log(result.script);
+    }
+    
+    console.log(`\n  ${c.dim}Safe fixes: ${result.safeFixes}, Dangerous: ${result.dangerousFixes}, Manual: ${result.manualFixes}${c.reset}`);
+  }
+}
+
+function handleReceipt(diagnostics, projectPath, timing, opts) {
+  // Lazy load the module
+  const diagnosisReceipt = require('./lib/doctor/diagnosis-receipt');
+  
+  const quiet = shouldSuppressOutput(opts);
+  const json = isJsonMode(opts);
+  
+  const receipt = diagnosisReceipt.generateDiagnosisReceipt(diagnostics, {
+    projectPath,
+    startTime: timing.startTime,
+    endTime: timing.endTime,
+    runId: timing.runId,
+  });
+  
+  if (json) {
+    console.log(JSON.stringify(receipt, null, 2));
+  } else {
+    // Save to file
+    const outputPath = opts.output || path.join(projectPath, '.vibecheck', 'diagnosis-receipt.json');
+    diagnosisReceipt.saveReceipt(receipt, outputPath);
+    
+    if (!quiet) {
+      console.log(`\n  ${colors.healthy}✓${c.reset} Diagnosis receipt saved to: ${outputPath}`);
+      console.log(`  ${c.dim}Receipt ID: ${receipt.receiptId}${c.reset}`);
+      console.log(`  ${c.dim}Health: ${receipt.health.grade} (${receipt.health.score}/100) - ${receipt.health.verdict}${c.reset}`);
+    }
+  }
+}
+
 function parseArgs(args) {
   // Parse global flags first
   const { flags: globalFlags, cleanArgs } = parseGlobalFlags(args);
@@ -421,6 +628,12 @@ function parseArgs(args) {
     skipNetwork: false,
     saveReport: true,
     failOnWarn: false,
+    // New options for enhanced doctor
+    repair: false,         // Safe repair mode (--repair)
+    fixScript: false,      // Generate fix script (--fix-script)
+    receipt: false,        // Generate diagnosis receipt (--receipt)
+    analyze: null,         // Analyze error output (--analyze <text>)
+    listActions: false,    // List available repair actions (--list-actions)
   };
 
   // Parse command-specific args from cleanArgs
@@ -438,9 +651,24 @@ function parseArgs(args) {
       case '--fix':
         opts.fix = true;
         break;
+      case '--repair':
+        opts.repair = true;
+        break;
       case '--dry-run':
         opts.dryRun = true;
         break;
+      case '--fix-script':
+        opts.fixScript = true;
+        break;
+      case '--receipt':
+        opts.receipt = true;
+        break;
+      case '--analyze':
+        opts.analyze = cleanArgs[++i];
+        break;
+      case '--list-actions':
+        opts.listActions = true;
+        break;
       case '--category':
       case '-c':
         if (!opts.categories) opts.categories = [];
@@ -480,8 +708,9 @@ function printHelp(showBanner = true) {
   ${c.bold}Usage:${c.reset} vibecheck doctor (health, diag) [options] [path]
 
   ${c.bold}Environment Diagnostics${c.reset} — Comprehensive checks with auto-fix capability.
+  World-class diagnostic that gets you unblocked in minutes.
 
-  ${c.bold}Options:${c.reset}
+  ${c.bold}Core Options:${c.reset}
     ${colors.accent}--path, -p <path>${c.reset}     Project path ${c.dim}(default: current directory)${c.reset}
     ${colors.accent}--json${c.reset}                Output JSON report only
     ${colors.accent}--fix${c.reset}                 Auto-fix issues when possible
@@ -494,30 +723,51 @@ function printHelp(showBanner = true) {
     ${colors.accent}--fail-on-warn${c.reset}        Exit code 2 for warnings ${c.dim}(CI mode)${c.reset}
     ${colors.accent}--help, -h${c.reset}            Show this help
 
+  ${c.bold}Legendary Features:${c.reset}
+    ${colors.healthy}--repair${c.reset}              Safe repair mode ${c.dim}(clear cache, regen lock, etc.)${c.reset}
+    ${colors.healthy}--fix-script${c.reset}          Generate copy-paste fix commands
+    ${colors.healthy}--receipt${c.reset}             Generate diagnosis receipt JSON
+    ${colors.healthy}--analyze <error>${c.reset}     Match error against known failure signatures
+    ${colors.healthy}--list-actions${c.reset}        List all available safe repair actions
+
   ${c.bold}Categories:${c.reset}
-    ${colors.system}${ICONS.cpu}${c.reset} ${c.bold}system${c.reset}         ${c.dim}OS, memory, disk, CPU${c.reset}
-    ${colors.runtime}${ICONS.node}${c.reset} ${c.bold}runtime${c.reset}        ${c.dim}Node.js, npm, package managers${c.reset}
-    ${colors.project}${ICONS.package}${c.reset} ${c.bold}project${c.reset}        ${c.dim}package.json, dependencies, TypeScript${c.reset}
+    ${colors.system}${ICONS.cpu}${c.reset} ${c.bold}system${c.reset}         ${c.dim}OS, memory, disk, CPU, shell${c.reset}
+    ${colors.runtime}${ICONS.node}${c.reset} ${c.bold}runtime${c.reset}        ${c.dim}Node.js, npm, pnpm, yarn${c.reset}
+    ${colors.project}${ICONS.package}${c.reset} ${c.bold}project${c.reset}        ${c.dim}package.json, tsconfig, git state${c.reset}
     ${colors.accent}${ICONS.npm}${c.reset} ${c.bold}dependencies${c.reset}   ${c.dim}Outdated packages, vulnerabilities${c.reset}
     ${colors.security}${ICONS.shield}${c.reset} ${c.bold}security${c.reset}       ${c.dim}Secrets, gitignore, env files${c.reset}
-    ${colors.network}${ICONS.network}${c.reset} ${c.bold}network${c.reset}        ${c.dim}Internet, npm registry, API connectivity${c.reset}
+    ${colors.network}${ICONS.network}${c.reset} ${c.bold}network${c.reset}        ${c.dim}Internet, npm registry, API${c.reset}
     ${colors.vibecheck}${ICONS.sparkle}${c.reset} ${c.bold}vibecheck${c.reset}      ${c.dim}Config, truth pack, scan status${c.reset}
 
+  ${c.bold}OS-Specific Checks:${c.reset}
+    ${c.dim}Windows:${c.reset} Long paths, PowerShell policy, antivirus, symlinks
+    ${c.dim}macOS:${c.reset}   Xcode CLI tools, Homebrew, Rosetta 2, file limits
+    ${c.dim}Linux:${c.reset}   build-essential, inotify watches, distro detection
+
   ${c.bold}Exit Codes:${c.reset}
     ${colors.healthy}0${c.reset}  Healthy ${c.dim}(or warnings without --fail-on-warn)${c.reset}
-    ${colors.error}1${c.reset}  Errors found
-    ${colors.warning}2${c.reset}  Warnings found ${c.dim}(with --fail-on-warn)${c.reset}
+    ${colors.warning}1${c.reset}  Warnings found
+    ${colors.error}2${c.reset}  Errors found
     ${colors.critical}3${c.reset}  Critical issues found
 
   ${c.bold}Examples:${c.reset}
     ${c.dim}# Full diagnostic${c.reset}
     vibecheck doctor
 
-    ${c.dim}# JSON output for CI${c.reset}
-    vibecheck doctor --json
+    ${c.dim}# Safe repair mode (recommended first step)${c.reset}
+    vibecheck doctor --repair
+
+    ${c.dim}# Generate fix script for manual review${c.reset}
+    vibecheck doctor --fix-script -o fix.sh
+
+    ${c.dim}# Analyze a specific error message${c.reset}
+    vibecheck doctor --analyze "EACCES permission denied"
 
-    ${c.dim}# Auto-fix issues${c.reset}
-    vibecheck doctor --fix
+    ${c.dim}# Generate diagnosis receipt for support${c.reset}
+    vibecheck doctor --receipt --json > diagnosis.json
+
+    ${c.dim}# JSON output for CI${c.reset}
+    vibecheck doctor --json --fail-on-warn
 
     ${c.dim}# Security checks only${c.reset}
     vibecheck doctor -c security