@vibecheckai/cli 2.8.2 → 3.0.0

package/bin/runners/lib/doctor/service.js

@@ -0,0 +1,262 @@
+/**
+ * DoctorService — Enterprise-Grade Environment Diagnostics
+ * 
+ * Features:
+ * - Pluggable diagnostic modules
+ * - Parallel execution for independent checks
+ * - Dependency resolution between checks
+ * - Auto-fix capability
+ * - JSON/Markdown report generation
+ * - Health scoring with weighted categories
+ * - CI-friendly exit codes
+ */
+
+const path = require('path');
+const { SEVERITY, CATEGORY, CATEGORY_META } = require('./types');
+const { getAllDiagnostics } = require('./modules');
+const { createSummary, saveReports, generateJsonReport } = require('./reporter');
+const { autoFixAll, getFixCommands } = require('./autofix');
+const ui = require('./ui');
+
+class DoctorService {
+  constructor(projectPath, options = {}) {
+    this.projectPath = path.resolve(projectPath);
+    this.options = {
+      json: false,
+      markdown: false,
+      fix: false,
+      fixDryRun: false,
+      quiet: false,
+      verbose: false,
+      categories: null, // null = all categories
+      skipNetwork: false,
+      saveReport: true,
+      ...options,
+    };
+    
+    this.diagnostics = [];
+    this.results = [];
+    this.startTime = null;
+  }
+
+  async run() {
+    this.startTime = Date.now();
+    
+    // Load diagnostics
+    this.diagnostics = this.loadDiagnostics();
+    
+    // Filter by category if specified
+    if (this.options.categories) {
+      this.diagnostics = this.diagnostics.filter(d => 
+        this.options.categories.includes(d.category)
+      );
+    }
+    
+    // Skip network if requested
+    if (this.options.skipNetwork) {
+      this.diagnostics = this.diagnostics.filter(d => d.category !== CATEGORY.NETWORK);
+    }
+    
+    // Print header (unless quiet or json)
+    if (!this.options.quiet && !this.options.json) {
+      ui.printHeader();
+    }
+    
+    // Run diagnostics
+    await this.runDiagnostics();
+    
+    // Calculate summary
+    const durationMs = Date.now() - this.startTime;
+    const summary = createSummary(this.results);
+    
+    // Output results
+    if (this.options.json) {
+      // JSON output only
+      const report = generateJsonReport(this.results, this.projectPath, durationMs);
+      console.log(JSON.stringify(report, null, 2));
+    } else if (!this.options.quiet) {
+      // Print issues and summary
+      ui.printIssuesSummary(this.results);
+      ui.printFinalSummary(summary, durationMs);
+    }
+    
+    // Save reports
+    if (this.options.saveReport && !this.options.json) {
+      const outputDir = path.join(this.projectPath, '.vibecheck');
+      try {
+        const paths = saveReports(this.results, this.projectPath, durationMs, outputDir);
+        if (this.options.verbose) {
+          console.log(`${ui.c.dim}Reports saved to:${ui.c.reset}`);
+          console.log(`  ${ui.c.dim}${paths.lastJson}${ui.c.reset}`);
+          console.log(`  ${ui.c.dim}${paths.lastMd}${ui.c.reset}`);
+        }
+      } catch (err) {
+        if (this.options.verbose) {
+          console.log(`${ui.c.dim}Could not save reports: ${err.message}${ui.c.reset}`);
+        }
+      }
+    }
+    
+    // Auto-fix if requested
+    if (this.options.fix) {
+      const fixResults = await autoFixAll(this.results, this.projectPath, {
+        dryRun: this.options.fixDryRun,
+        severity: [SEVERITY.CRITICAL, SEVERITY.ERROR],
+      });
+      
+      if (!this.options.quiet && !this.options.json) {
+        ui.printAutoFixResults(fixResults);
+      }
+      
+      // Re-run affected checks after fixing
+      if (fixResults.succeeded > 0 && !this.options.fixDryRun) {
+        if (!this.options.quiet && !this.options.json) {
+          console.log(`${ui.c.cyan}Re-running diagnostics after fixes...${ui.c.reset}\n`);
+        }
+        return this.run();
+      }
+    }
+    
+    // Return exit code
+    if (summary.critical > 0) return 3;
+    if (summary.errors > 0) return 1;
+    if (summary.warnings > 0 && this.options.failOnWarn) return 2;
+    return 0;
+  }
+
+  loadDiagnostics() {
+    return getAllDiagnostics(this.projectPath);
+  }
+
+  async runDiagnostics() {
+    // Group by category for display
+    const byCategory = {};
+    for (const d of this.diagnostics) {
+      if (!byCategory[d.category]) byCategory[d.category] = [];
+      byCategory[d.category].push(d);
+    }
+    
+    // Sort categories
+    const sortedCategories = Object.keys(byCategory).sort((a, b) => {
+      const orderA = CATEGORY_META[a]?.order || 99;
+      const orderB = CATEGORY_META[b]?.order || 99;
+      return orderA - orderB;
+    });
+    
+    // Track completed diagnostic IDs for dependency resolution
+    const completed = new Set();
+    const resultMap = new Map();
+    
+    for (const category of sortedCategories) {
+      const categoryDiagnostics = byCategory[category];
+      
+      if (!this.options.quiet && !this.options.json) {
+        ui.printCategoryHeader(category);
+      }
+      
+      // Separate parallel and sequential diagnostics
+      const parallel = categoryDiagnostics.filter(d => d.parallel && !d.dependsOn?.length);
+      const sequential = categoryDiagnostics.filter(d => !d.parallel || d.dependsOn?.length);
+      
+      // Run parallel diagnostics
+      if (parallel.length > 0) {
+        const parallelPromises = parallel.map(d => this.runSingleDiagnostic(d));
+        const parallelResults = await Promise.all(parallelPromises);
+        
+        for (let i = 0; i < parallel.length; i++) {
+          const diagnostic = parallel[i];
+          const result = parallelResults[i];
+          
+          this.results.push(result);
+          completed.add(diagnostic.id);
+          resultMap.set(diagnostic.id, result);
+          
+          if (!this.options.quiet && !this.options.json) {
+            ui.printDiagnostic(result, { showFixes: this.options.verbose });
+          }
+        }
+      }
+      
+      // Run sequential diagnostics (respecting dependencies)
+      for (const diagnostic of sequential) {
+        // Check dependencies
+        if (diagnostic.dependsOn) {
+          const unmetDeps = diagnostic.dependsOn.filter(dep => !completed.has(dep));
+          if (unmetDeps.length > 0) {
+            // Skip if dependencies not met
+            const skipResult = {
+              ...diagnostic,
+              severity: SEVERITY.INFO,
+              message: `Skipped (depends on: ${unmetDeps.join(', ')})`,
+              durationMs: 0,
+            };
+            this.results.push(skipResult);
+            if (!this.options.quiet && !this.options.json) {
+              ui.printDiagnostic(skipResult);
+            }
+            continue;
+          }
+        }
+        
+        const result = await this.runSingleDiagnostic(diagnostic);
+        this.results.push(result);
+        completed.add(diagnostic.id);
+        resultMap.set(diagnostic.id, result);
+        
+        if (!this.options.quiet && !this.options.json) {
+          ui.printDiagnostic(result, { showFixes: this.options.verbose });
+        }
+      }
+      
+      if (!this.options.quiet && !this.options.json) {
+        console.log('');
+      }
+    }
+  }
+
+  async runSingleDiagnostic(diagnostic) {
+    const startTime = Date.now();
+    
+    try {
+      const checkResult = await diagnostic.check();
+      const durationMs = Date.now() - startTime;
+      
+      return {
+        id: diagnostic.id,
+        name: diagnostic.name,
+        category: diagnostic.category,
+        severity: checkResult.severity || SEVERITY.PASS,
+        message: checkResult.message || 'OK',
+        detail: checkResult.detail,
+        durationMs,
+        fixes: checkResult.fixes,
+        metadata: checkResult.metadata,
+      };
+    } catch (err) {
+      const durationMs = Date.now() - startTime;
+      
+      return {
+        id: diagnostic.id,
+        name: diagnostic.name,
+        category: diagnostic.category,
+        severity: SEVERITY.ERROR,
+        message: `Check failed: ${err.message}`,
+        durationMs,
+      };
+    }
+  }
+
+  getFixCommands() {
+    return getFixCommands(this.results);
+  }
+}
+
+async function diagnose(projectPath, options = {}) {
+  const service = new DoctorService(projectPath, options);
+  return service.run();
+}
+
+module.exports = {
+  DoctorService,
+  diagnose,
+};

package/bin/runners/lib/doctor/types.js

@@ -0,0 +1,113 @@
+/**
+ * Doctor Service Types
+ * 
+ * Enterprise-grade diagnostic types and constants
+ */
+
+const SEVERITY = {
+  CRITICAL: 'critical',  // Blocks all operations
+  ERROR: 'error',        // Must fix before using vibecheck
+  WARNING: 'warning',    // Recommended to fix
+  INFO: 'info',          // Informational
+  PASS: 'pass',          // Check passed
+};
+
+const SEVERITY_WEIGHT = {
+  [SEVERITY.CRITICAL]: 0,
+  [SEVERITY.ERROR]: 0.25,
+  [SEVERITY.WARNING]: 0.75,
+  [SEVERITY.INFO]: 1,
+  [SEVERITY.PASS]: 1,
+};
+
+const CATEGORY = {
+  SYSTEM: 'system',
+  RUNTIME: 'runtime',
+  PROJECT: 'project',
+  SECURITY: 'security',
+  NETWORK: 'network',
+  DEPENDENCIES: 'dependencies',
+  VIBECHECK: 'vibecheck',
+};
+
+const CATEGORY_META = {
+  [CATEGORY.SYSTEM]: { name: 'System', icon: '💻', order: 1 },
+  [CATEGORY.RUNTIME]: { name: 'Runtime', icon: '🟢', order: 2 },
+  [CATEGORY.PROJECT]: { name: 'Project', icon: '📁', order: 3 },
+  [CATEGORY.DEPENDENCIES]: { name: 'Dependencies', icon: '📦', order: 4 },
+  [CATEGORY.SECURITY]: { name: 'Security', icon: '🔐', order: 5 },
+  [CATEGORY.NETWORK]: { name: 'Network', icon: '🌐', order: 6 },
+  [CATEGORY.VIBECHECK]: { name: 'Vibecheck', icon: '⚡', order: 7 },
+};
+
+const FIX_TYPE = {
+  COMMAND: 'command',      // Run a shell command
+  FILE_CREATE: 'file_create',
+  FILE_EDIT: 'file_edit',
+  MANUAL: 'manual',        // User must do manually
+  LINK: 'link',            // External documentation
+};
+
+/**
+ * @typedef {Object} DiagnosticResult
+ * @property {string} id - Unique diagnostic ID
+ * @property {string} name - Human readable name
+ * @property {string} category - Category from CATEGORY enum
+ * @property {string} severity - Severity from SEVERITY enum
+ * @property {string} message - Short status message
+ * @property {string} [detail] - Additional detail
+ * @property {number} durationMs - Time taken in milliseconds
+ * @property {Fix[]} [fixes] - Available fixes
+ * @property {Object} [metadata] - Additional diagnostic data
+ */
+
+/**
+ * @typedef {Object} Fix
+ * @property {string} type - Fix type from FIX_TYPE enum
+ * @property {string} description - What the fix does
+ * @property {string} [command] - Command to run (for COMMAND type)
+ * @property {string} [path] - File path (for FILE_* types)
+ * @property {string} [content] - Content (for FILE_CREATE/EDIT)
+ * @property {string} [url] - URL (for LINK type)
+ * @property {boolean} [dangerous] - Requires confirmation
+ * @property {boolean} [autoFixable] - Can be auto-fixed
+ */
+
+/**
+ * @typedef {Object} DiagnosticModule
+ * @property {string} id - Module ID
+ * @property {string} name - Module name
+ * @property {string} category - Category
+ * @property {function} check - Async check function
+ * @property {boolean} [parallel] - Can run in parallel
+ * @property {string[]} [dependsOn] - IDs this module depends on
+ */
+
+/**
+ * @typedef {Object} DoctorReport
+ * @property {string} version - Report format version
+ * @property {string} timestamp - ISO timestamp
+ * @property {number} durationMs - Total duration
+ * @property {string} projectPath - Scanned project
+ * @property {DiagnosticResult[]} diagnostics - All results
+ * @property {Summary} summary - Summary stats
+ */
+
+/**
+ * @typedef {Object} Summary
+ * @property {number} total - Total checks
+ * @property {number} passed - Passed checks
+ * @property {number} warnings - Warning count
+ * @property {number} errors - Error count
+ * @property {number} critical - Critical count
+ * @property {number} healthScore - 0-100 score
+ * @property {string} verdict - HEALTHY | DEGRADED | UNHEALTHY | CRITICAL
+ */
+
+module.exports = {
+  SEVERITY,
+  SEVERITY_WEIGHT,
+  CATEGORY,
+  CATEGORY_META,
+  FIX_TYPE,
+};

package/bin/runners/lib/doctor/ui.js

@@ -0,0 +1,263 @@
+/**
+ * Doctor CLI UI Components
+ * 
+ * Beautiful terminal output for the Doctor service
+ */
+
+const { SEVERITY, CATEGORY_META } = require('./types');
+
+// ANSI color codes
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+  
+  black: '\x1b[30m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  bgCyan: '\x1b[46m',
+};
+
+const SEVERITY_CONFIG = {
+  [SEVERITY.PASS]: { icon: '✓', color: c.green, label: 'PASS' },
+  [SEVERITY.INFO]: { icon: 'ℹ', color: c.blue, label: 'INFO' },
+  [SEVERITY.WARNING]: { icon: '!', color: c.yellow, label: 'WARN' },
+  [SEVERITY.ERROR]: { icon: '✗', color: c.red, label: 'ERROR' },
+  [SEVERITY.CRITICAL]: { icon: '⛔', color: `${c.bgRed}${c.white}`, label: 'CRIT' },
+};
+
+const BOX_CHARS = {
+  topLeft: '╔',
+  topRight: '╗',
+  bottomLeft: '╚',
+  bottomRight: '╝',
+  horizontal: '═',
+  vertical: '║',
+  lightHorizontal: '─',
+};
+
+function box(width = 74) {
+  return {
+    top: `${c.cyan}${BOX_CHARS.topLeft}${BOX_CHARS.horizontal.repeat(width)}${BOX_CHARS.topRight}${c.reset}`,
+    bottom: `${c.cyan}${BOX_CHARS.bottomLeft}${BOX_CHARS.horizontal.repeat(width)}${BOX_CHARS.bottomRight}${c.reset}`,
+    line: (content, align = 'left') => {
+      const stripped = stripAnsi(content);
+      const padding = width - stripped.length;
+      const left = align === 'center' ? Math.floor(padding / 2) : 0;
+      const right = padding - left;
+      return `${c.cyan}${BOX_CHARS.vertical}${c.reset}${' '.repeat(left)}${content}${' '.repeat(right)}${c.cyan}${BOX_CHARS.vertical}${c.reset}`;
+    },
+    empty: `${c.cyan}${BOX_CHARS.vertical}${c.reset}${' '.repeat(width)}${c.cyan}${BOX_CHARS.vertical}${c.reset}`,
+  };
+}
+
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function printHeader() {
+  const b = box();
+  console.log('');
+  console.log(b.top);
+  console.log(b.empty);
+  console.log(b.line(`${c.bold}🩺 VIBECHECK DOCTOR${c.reset}`, 'center'));
+  console.log(b.line(`${c.dim}Enterprise Environment Diagnostics${c.reset}`, 'center'));
+  console.log(b.empty);
+  console.log(b.bottom);
+  console.log('');
+}
+
+function printCategoryHeader(category) {
+  const meta = CATEGORY_META[category] || { name: category, icon: '📋' };
+  console.log(`${c.cyan}${meta.icon} ${c.bold}${meta.name}${c.reset}`);
+  console.log(`${c.dim}${BOX_CHARS.lightHorizontal.repeat(50)}${c.reset}`);
+}
+
+function printDiagnostic(diagnostic, options = {}) {
+  const { showDetail = true, showFixes = true, indent = '   ' } = options;
+  const config = SEVERITY_CONFIG[diagnostic.severity] || SEVERITY_CONFIG[SEVERITY.INFO];
+  
+  // Main line
+  console.log(`${indent}${config.color}${config.icon}${c.reset} ${diagnostic.message}`);
+  
+  // Detail
+  if (showDetail && diagnostic.detail) {
+    console.log(`${indent}  ${c.dim}${diagnostic.detail}${c.reset}`);
+  }
+  
+  // First fix hint
+  if (showFixes && diagnostic.fixes && diagnostic.fixes.length > 0) {
+    const fix = diagnostic.fixes[0];
+    if (fix.command) {
+      console.log(`${indent}  ${c.cyan}→ ${fix.command}${c.reset}`);
+    } else if (fix.url) {
+      console.log(`${indent}  ${c.cyan}→ ${fix.url}${c.reset}`);
+    } else if (fix.description) {
+      console.log(`${indent}  ${c.cyan}→ ${fix.description}${c.reset}`);
+    }
+  }
+}
+
+function printProgress(name, total, current) {
+  const percent = Math.round((current / total) * 100);
+  const barWidth = 20;
+  const filled = Math.round((current / total) * barWidth);
+  const bar = '█'.repeat(filled) + '░'.repeat(barWidth - filled);
+  
+  process.stdout.write(`\r${c.dim}${name}${c.reset} [${c.cyan}${bar}${c.reset}] ${percent}%`);
+}
+
+function clearProgress() {
+  process.stdout.write('\r' + ' '.repeat(60) + '\r');
+}
+
+function printSpinner(message, frame = 0) {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  process.stdout.write(`\r${c.cyan}${frames[frame % frames.length]}${c.reset} ${message}`);
+  return (frame + 1) % frames.length;
+}
+
+function printIssuesSummary(diagnostics) {
+  const critical = diagnostics.filter(d => d.severity === SEVERITY.CRITICAL);
+  const errors = diagnostics.filter(d => d.severity === SEVERITY.ERROR);
+  const warnings = diagnostics.filter(d => d.severity === SEVERITY.WARNING);
+  
+  if (critical.length === 0 && errors.length === 0 && warnings.length === 0) {
+    return;
+  }
+  
+  const b = box();
+  console.log(b.top);
+  console.log(b.line(`${c.bold}ISSUES FOUND${c.reset}`));
+  console.log(b.bottom);
+  console.log('');
+  
+  if (critical.length > 0) {
+    console.log(`${c.bgRed}${c.white}${c.bold} CRITICAL (${critical.length}) ${c.reset} — Must fix immediately\n`);
+    for (const d of critical) {
+      console.log(`   ${c.red}●${c.reset} ${c.bold}${d.name}${c.reset}`);
+      console.log(`     ${c.dim}${d.message}${c.reset}`);
+      if (d.fixes?.[0]?.command) {
+        console.log(`     ${c.cyan}→ ${d.fixes[0].command}${c.reset}`);
+      }
+      console.log('');
+    }
+  }
+  
+  if (errors.length > 0) {
+    console.log(`${c.red}${c.bold}❌ ERRORS (${errors.length})${c.reset} — Must fix before using vibecheck\n`);
+    for (const d of errors) {
+      console.log(`   ${c.red}●${c.reset} ${c.bold}${d.name}${c.reset}`);
+      console.log(`     ${c.dim}${d.message}${c.reset}`);
+      if (d.fixes?.[0]?.command) {
+        console.log(`     ${c.cyan}→ ${d.fixes[0].command}${c.reset}`);
+      }
+      console.log('');
+    }
+  }
+  
+  if (warnings.length > 0) {
+    console.log(`${c.yellow}${c.bold}⚠️  WARNINGS (${warnings.length})${c.reset} — Recommended fixes\n`);
+    for (const d of warnings) {
+      console.log(`   ${c.yellow}●${c.reset} ${c.bold}${d.name}${c.reset}`);
+      console.log(`     ${c.dim}${d.message}${c.reset}`);
+      if (d.fixes?.[0]?.command) {
+        console.log(`     ${c.cyan}→ ${d.fixes[0].command}${c.reset}`);
+      }
+      console.log('');
+    }
+  }
+}
+
+function printFinalSummary(summary, durationMs) {
+  const b = box();
+  
+  const healthColor = summary.healthScore >= 80 ? c.green 
+    : summary.healthScore >= 60 ? c.yellow 
+    : c.red;
+  const healthIcon = summary.healthScore >= 80 ? '💚' 
+    : summary.healthScore >= 60 ? '💛' 
+    : '❤️';
+  
+  const verdictColor = {
+    HEALTHY: c.green,
+    DEGRADED: c.yellow,
+    UNHEALTHY: c.red,
+    CRITICAL: `${c.bgRed}${c.white}`,
+  }[summary.verdict] || c.white;
+  
+  console.log(b.top);
+  console.log(b.empty);
+  console.log(b.line(`${healthIcon} ${c.bold}Health Score: ${healthColor}${summary.healthScore}%${c.reset}`));
+  console.log(b.line(`   ${c.bold}Verdict: ${verdictColor}${summary.verdict}${c.reset}`));
+  console.log(b.empty);
+  console.log(b.line(`${c.green}✓ ${summary.passed} passed${c.reset}  ${c.blue}ℹ ${summary.info} info${c.reset}  ${c.yellow}! ${summary.warnings} warnings${c.reset}  ${c.red}✗ ${summary.errors} errors${c.reset}  ${summary.critical > 0 ? `${c.bgRed}${c.white}⛔ ${summary.critical}${c.reset}` : ''}`));
+  console.log(b.line(`${c.dim}Completed ${summary.total} checks in ${(durationMs / 1000).toFixed(1)}s${c.reset}`));
+  console.log(b.empty);
+  console.log(b.bottom);
+  console.log('');
+  
+  // Final message
+  if (summary.critical > 0) {
+    console.log(`${c.bgRed}${c.white}${c.bold} ⛔ CRITICAL ISSUES DETECTED ${c.reset}`);
+    console.log(`${c.red}Fix critical issues immediately before proceeding.${c.reset}\n`);
+  } else if (summary.errors > 0) {
+    console.log(`${c.red}${c.bold}⚠ Fix the errors above before running vibecheck.${c.reset}\n`);
+  } else if (summary.warnings > 0) {
+    console.log(`${c.yellow}Your environment is ready, but consider fixing the warnings.${c.reset}\n`);
+  } else {
+    console.log(`${c.green}${c.bold}✓ Your environment is perfectly configured!${c.reset}\n`);
+  }
+}
+
+function printAutoFixResults(results) {
+  console.log('');
+  console.log(`${c.cyan}${c.bold}🔧 Auto-Fix Results${c.reset}`);
+  console.log(`${c.dim}${BOX_CHARS.lightHorizontal.repeat(50)}${c.reset}`);
+  
+  console.log(`   Attempted: ${results.attempted}`);
+  console.log(`   ${c.green}Succeeded: ${results.succeeded}${c.reset}`);
+  console.log(`   ${c.red}Failed: ${results.failed}${c.reset}`);
+  console.log(`   ${c.dim}Skipped: ${results.skipped}${c.reset}`);
+  console.log('');
+  
+  for (const r of results.results) {
+    const icon = r.status === 'success' ? `${c.green}✓${c.reset}` 
+      : r.status === 'failed' ? `${c.red}✗${c.reset}`
+      : `${c.dim}○${c.reset}`;
+    console.log(`   ${icon} ${r.diagnosticName}: ${r.status}`);
+    if (r.error) {
+      console.log(`     ${c.dim}${r.error}${c.reset}`);
+    }
+  }
+  console.log('');
+}
+
+module.exports = {
+  c,
+  SEVERITY_CONFIG,
+  box,
+  stripAnsi,
+  printHeader,
+  printCategoryHeader,
+  printDiagnostic,
+  printProgress,
+  clearProgress,
+  printSpinner,
+  printIssuesSummary,
+  printFinalSummary,
+  printAutoFixResults,
+};