vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/doctor/modules/vibecheck.js

@@ -0,0 +1,394 @@
+/**
+ * Vibecheck Diagnostics Module
+ * 
+ * Checks vibecheck-specific configuration, truth packs, and scan readiness
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { SEVERITY, CATEGORY, FIX_TYPE } = require('../types');
+
+const MODULE_ID = 'vibecheck';
+
+const CONFIG_FILES = [
+  '.vibecheckrc',
+  '.vibecheck.json',
+  'vibecheck.config.js',
+  'vibecheck.config.mjs',
+];
+
+function createDiagnostics(projectPath) {
+  return [
+    {
+      id: `${MODULE_ID}.config`,
+      name: 'Configuration File',
+      category: CATEGORY.VIBECHECK,
+      parallel: true,
+      check: async () => {
+        for (const configFile of CONFIG_FILES) {
+          const configPath = path.join(projectPath, configFile);
+          if (fs.existsSync(configPath)) {
+            try {
+              if (configFile.endsWith('.json') || configFile === '.vibecheckrc') {
+                JSON.parse(fs.readFileSync(configPath, 'utf8'));
+              }
+              return {
+                severity: SEVERITY.PASS,
+                message: configFile,
+                metadata: { configFile },
+              };
+            } catch (err) {
+              return {
+                severity: SEVERITY.WARNING,
+                message: `Invalid ${configFile}`,
+                detail: err.message,
+                fixes: [{
+                  type: FIX_TYPE.MANUAL,
+                  description: 'Fix configuration file syntax',
+                  autoFixable: false,
+                }],
+              };
+            }
+          }
+        }
+        
+        return {
+          severity: SEVERITY.INFO,
+          message: 'Using defaults',
+          detail: 'Run `vibecheck init` to create a config file',
+          fixes: [{
+            type: FIX_TYPE.COMMAND,
+            description: 'Initialize vibecheck configuration',
+            command: 'vibecheck init',
+            autoFixable: true,
+          }],
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.output_dir`,
+      name: 'Output Directory',
+      category: CATEGORY.VIBECHECK,
+      parallel: true,
+      check: async () => {
+        const outputDir = path.join(projectPath, '.vibecheck');
+        
+        if (!fs.existsSync(outputDir)) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Will be created on first scan',
+          };
+        }
+        
+        try {
+          const files = fs.readdirSync(outputDir);
+          const subdirs = files.filter(f => 
+            fs.statSync(path.join(outputDir, f)).isDirectory()
+          );
+          
+          const metadata = { 
+            fileCount: files.length, 
+            subdirs,
+          };
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: `${files.length} items`,
+            metadata,
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: 'Cannot read .vibecheck directory',
+            detail: err.message,
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.truthpack`,
+      name: 'Truth Pack',
+      category: CATEGORY.VIBECHECK,
+      parallel: true,
+      check: async () => {
+        const truthpackPath = path.join(projectPath, '.vibecheck', 'truth', 'truthpack.json');
+        
+        if (!fs.existsSync(truthpackPath)) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Not generated yet',
+            detail: 'Run `vibecheck ctx` to generate truth pack',
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Generate truth pack',
+              command: 'vibecheck ctx',
+              autoFixable: true,
+            }],
+          };
+        }
+        
+        try {
+          const truthpack = JSON.parse(fs.readFileSync(truthpackPath, 'utf8'));
+          const stats = fs.statSync(truthpackPath);
+          const ageMs = Date.now() - stats.mtimeMs;
+          const ageHours = Math.round(ageMs / 1000 / 60 / 60);
+          
+          const metadata = {
+            version: truthpack.version,
+            routes: truthpack.routes?.server?.length || 0,
+            envVars: truthpack.env?.vars?.length || 0,
+            ageHours,
+          };
+          
+          if (ageHours > 24) {
+            return {
+              severity: SEVERITY.WARNING,
+              message: `Stale (${ageHours}h old)`,
+              detail: 'Truth pack may be outdated',
+              metadata,
+              fixes: [{
+                type: FIX_TYPE.COMMAND,
+                description: 'Refresh truth pack',
+                command: 'vibecheck ctx',
+                autoFixable: true,
+              }],
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: `${metadata.routes} routes, ${metadata.envVars} env vars`,
+            metadata,
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: 'Invalid truth pack',
+            detail: err.message,
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Regenerate truth pack',
+              command: 'vibecheck ctx',
+              autoFixable: true,
+            }],
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.last_scan`,
+      name: 'Last Scan',
+      category: CATEGORY.VIBECHECK,
+      parallel: true,
+      check: async () => {
+        const scanResultPath = path.join(projectPath, '.vibecheck', 'ship', 'last_ship.json');
+        
+        if (!fs.existsSync(scanResultPath)) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'No scans yet',
+            detail: 'Run `vibecheck ship` for first scan',
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Run first scan',
+              command: 'vibecheck ship',
+              autoFixable: false,
+            }],
+          };
+        }
+        
+        try {
+          const result = JSON.parse(fs.readFileSync(scanResultPath, 'utf8'));
+          const stats = fs.statSync(scanResultPath);
+          const ageMs = Date.now() - stats.mtimeMs;
+          const ageMinutes = Math.round(ageMs / 1000 / 60);
+          
+          const verdict = result.verdict || result.summary?.verdict || 'unknown';
+          const metadata = {
+            verdict,
+            ageMinutes,
+            findings: result.findings?.length || 0,
+          };
+          
+          const verdictColors = {
+            SHIP: SEVERITY.PASS,
+            WARN: SEVERITY.WARNING,
+            BLOCK: SEVERITY.ERROR,
+          };
+          
+          return {
+            severity: verdictColors[verdict] || SEVERITY.INFO,
+            message: `${verdict} (${ageMinutes}m ago)`,
+            metadata,
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Could not read last scan',
+            detail: err.message,
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.api_key`,
+      name: 'API Key',
+      category: CATEGORY.VIBECHECK,
+      parallel: true,
+      check: async () => {
+        const apiKey = process.env.VIBECHECK_API_KEY;
+        
+        if (!apiKey) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Not configured (offline mode)',
+            detail: 'Set VIBECHECK_API_KEY for cloud features',
+          };
+        }
+        
+        // Basic format validation (don't log the key)
+        if (apiKey.length < 20) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: 'API key appears invalid',
+            detail: 'Key is too short',
+          };
+        }
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: 'Configured',
+          metadata: { keyLength: apiKey.length },
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.llm_config`,
+      name: 'LLM Configuration',
+      category: CATEGORY.VIBECHECK,
+      parallel: true,
+      check: async () => {
+        const baseUrl = process.env.VIBECHECK_LLM_BASE_URL;
+        const apiKey = process.env.VIBECHECK_LLM_API_KEY || process.env.OPENAI_API_KEY;
+        const model = process.env.VIBECHECK_LLM_MODEL;
+        
+        const metadata = {
+          hasBaseUrl: !!baseUrl,
+          hasApiKey: !!apiKey,
+          model: model || 'default',
+        };
+        
+        if (!apiKey) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'No LLM API key configured',
+            detail: 'Set VIBECHECK_LLM_API_KEY or OPENAI_API_KEY for AI features',
+            metadata,
+          };
+        }
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: model ? `Model: ${model}` : 'Configured',
+          metadata,
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.git`,
+      name: 'Git Repository',
+      category: CATEGORY.VIBECHECK,
+      parallel: true,
+      check: async () => {
+        const gitDir = path.join(projectPath, '.git');
+        
+        if (!fs.existsSync(gitDir)) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: 'Not a git repository',
+            detail: 'Git is recommended for versioning and CI integration',
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Initialize git repository',
+              command: 'git init',
+              autoFixable: true,
+            }],
+          };
+        }
+        
+        try {
+          const branch = execSync('git branch --show-current', {
+            cwd: projectPath,
+            encoding: 'utf8',
+            timeout: 5000,
+          }).trim();
+          
+          const status = execSync('git status --porcelain', {
+            cwd: projectPath,
+            encoding: 'utf8',
+            timeout: 5000,
+          }).trim();
+          
+          const uncommitted = status.split('\n').filter(Boolean).length;
+          const metadata = { branch, uncommitted };
+          
+          if (uncommitted > 20) {
+            return {
+              severity: SEVERITY.WARNING,
+              message: `${branch} (${uncommitted} uncommitted files)`,
+              detail: 'Many uncommitted changes may affect scan accuracy',
+              metadata,
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: `${branch}${uncommitted ? ` (+${uncommitted})` : ''}`,
+            metadata,
+          };
+        } catch {
+          return {
+            severity: SEVERITY.PASS,
+            message: 'Initialized',
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.playwright`,
+      name: 'Playwright (Runtime Verification)',
+      category: CATEGORY.VIBECHECK,
+      parallel: true,
+      check: async () => {
+        try {
+          execSync('npx playwright --version', {
+            encoding: 'utf8',
+            timeout: 10000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: 'Available',
+            detail: 'Enables runtime verification with `vibecheck reality`',
+          };
+        } catch {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Not installed (optional)',
+            detail: 'Install for runtime UI verification',
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Install Playwright',
+              command: 'npx playwright install',
+              autoFixable: false,
+            }],
+          };
+        }
+      },
+    },
+  ];
+}
+
+module.exports = { MODULE_ID, createDiagnostics };

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

@@ -0,0 +1,262 @@
+/**
+ * Doctor Report Generator
+ * 
+ * Generates JSON and Markdown reports from diagnostic results
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { SEVERITY, SEVERITY_WEIGHT, CATEGORY_META } = require('./types');
+
+const REPORT_VERSION = '2.0.0';
+
+function calculateHealthScore(diagnostics) {
+  if (diagnostics.length === 0) return 100;
+  
+  let weightedSum = 0;
+  let totalWeight = 0;
+  
+  for (const d of diagnostics) {
+    const weight = d.category === 'security' ? 2 : 1; // Security issues count more
+    weightedSum += (SEVERITY_WEIGHT[d.severity] || 1) * weight;
+    totalWeight += weight;
+  }
+  
+  return Math.round((weightedSum / totalWeight) * 100);
+}
+
+function getVerdict(healthScore, diagnostics) {
+  const criticalCount = diagnostics.filter(d => d.severity === SEVERITY.CRITICAL).length;
+  const errorCount = diagnostics.filter(d => d.severity === SEVERITY.ERROR).length;
+  
+  if (criticalCount > 0) return 'CRITICAL';
+  if (errorCount > 0) return 'UNHEALTHY';
+  if (healthScore < 80) return 'DEGRADED';
+  return 'HEALTHY';
+}
+
+function createSummary(diagnostics) {
+  const total = diagnostics.length;
+  const passed = diagnostics.filter(d => d.severity === SEVERITY.PASS).length;
+  const info = diagnostics.filter(d => d.severity === SEVERITY.INFO).length;
+  const warnings = diagnostics.filter(d => d.severity === SEVERITY.WARNING).length;
+  const errors = diagnostics.filter(d => d.severity === SEVERITY.ERROR).length;
+  const critical = diagnostics.filter(d => d.severity === SEVERITY.CRITICAL).length;
+  
+  const healthScore = calculateHealthScore(diagnostics);
+  const verdict = getVerdict(healthScore, diagnostics);
+  
+  return {
+    total,
+    passed,
+    info,
+    warnings,
+    errors,
+    critical,
+    healthScore,
+    verdict,
+  };
+}
+
+function generateJsonReport(diagnostics, projectPath, durationMs) {
+  const summary = createSummary(diagnostics);
+  
+  return {
+    version: REPORT_VERSION,
+    timestamp: new Date().toISOString(),
+    durationMs,
+    projectPath,
+    summary,
+    diagnostics: diagnostics.map(d => ({
+      id: d.id,
+      name: d.name,
+      category: d.category,
+      severity: d.severity,
+      message: d.message,
+      detail: d.detail,
+      durationMs: d.durationMs,
+      fixes: d.fixes,
+      metadata: d.metadata,
+    })),
+  };
+}
+
+function generateMarkdownReport(diagnostics, projectPath, durationMs) {
+  const summary = createSummary(diagnostics);
+  const lines = [];
+  
+  lines.push('# 🩺 Vibecheck Doctor Report');
+  lines.push('');
+  lines.push(`**Project:** \`${projectPath}\`  `);
+  lines.push(`**Generated:** ${new Date().toISOString()}  `);
+  lines.push(`**Duration:** ${(durationMs / 1000).toFixed(1)}s`);
+  lines.push('');
+  
+  // Summary Box
+  lines.push('## Summary');
+  lines.push('');
+  lines.push(`| Metric | Value |`);
+  lines.push(`|--------|-------|`);
+  lines.push(`| Health Score | **${summary.healthScore}%** |`);
+  lines.push(`| Verdict | **${summary.verdict}** |`);
+  lines.push(`| Total Checks | ${summary.total} |`);
+  lines.push(`| ✓ Passed | ${summary.passed} |`);
+  lines.push(`| ℹ Info | ${summary.info} |`);
+  lines.push(`| ⚠ Warnings | ${summary.warnings} |`);
+  lines.push(`| ✗ Errors | ${summary.errors} |`);
+  lines.push(`| 🔴 Critical | ${summary.critical} |`);
+  lines.push('');
+  
+  // Group by category
+  const byCategory = {};
+  for (const d of diagnostics) {
+    if (!byCategory[d.category]) byCategory[d.category] = [];
+    byCategory[d.category].push(d);
+  }
+  
+  // Sort categories by order
+  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;
+  });
+  
+  lines.push('## Diagnostics');
+  lines.push('');
+  
+  for (const category of sortedCategories) {
+    const meta = CATEGORY_META[category] || { name: category, icon: '📋' };
+    lines.push(`### ${meta.icon} ${meta.name}`);
+    lines.push('');
+    
+    for (const d of byCategory[category]) {
+      const icon = {
+        [SEVERITY.PASS]: '✓',
+        [SEVERITY.INFO]: 'ℹ',
+        [SEVERITY.WARNING]: '⚠',
+        [SEVERITY.ERROR]: '✗',
+        [SEVERITY.CRITICAL]: '🔴',
+      }[d.severity] || '•';
+      
+      lines.push(`- ${icon} **${d.name}**: ${d.message}`);
+      
+      if (d.detail) {
+        lines.push(`  - ${d.detail}`);
+      }
+      
+      if (d.fixes && d.fixes.length > 0) {
+        for (const fix of d.fixes) {
+          if (fix.command) {
+            lines.push(`  - Fix: \`${fix.command}\``);
+          } else if (fix.url) {
+            lines.push(`  - [${fix.description}](${fix.url})`);
+          } else if (fix.description) {
+            lines.push(`  - Fix: ${fix.description}`);
+          }
+        }
+      }
+    }
+    lines.push('');
+  }
+  
+  // Issues section
+  const issues = diagnostics.filter(d => 
+    d.severity === SEVERITY.CRITICAL || 
+    d.severity === SEVERITY.ERROR || 
+    d.severity === SEVERITY.WARNING
+  );
+  
+  if (issues.length > 0) {
+    lines.push('## Issues to Fix');
+    lines.push('');
+    
+    const critical = issues.filter(d => d.severity === SEVERITY.CRITICAL);
+    const errors = issues.filter(d => d.severity === SEVERITY.ERROR);
+    const warnings = issues.filter(d => d.severity === SEVERITY.WARNING);
+    
+    if (critical.length > 0) {
+      lines.push('### 🔴 Critical');
+      for (const d of critical) {
+        lines.push(`1. **${d.name}**: ${d.message}`);
+        if (d.fixes?.[0]?.command) {
+          lines.push(`   \`\`\`bash`);
+          lines.push(`   ${d.fixes[0].command}`);
+          lines.push(`   \`\`\``);
+        }
+      }
+      lines.push('');
+    }
+    
+    if (errors.length > 0) {
+      lines.push('### ✗ Errors');
+      for (const d of errors) {
+        lines.push(`1. **${d.name}**: ${d.message}`);
+        if (d.fixes?.[0]?.command) {
+          lines.push(`   \`\`\`bash`);
+          lines.push(`   ${d.fixes[0].command}`);
+          lines.push(`   \`\`\``);
+        }
+      }
+      lines.push('');
+    }
+    
+    if (warnings.length > 0) {
+      lines.push('### ⚠ Warnings');
+      for (const d of warnings) {
+        lines.push(`1. **${d.name}**: ${d.message}`);
+        if (d.fixes?.[0]?.command) {
+          lines.push(`   \`\`\`bash`);
+          lines.push(`   ${d.fixes[0].command}`);
+          lines.push(`   \`\`\``);
+        }
+      }
+      lines.push('');
+    }
+  }
+  
+  lines.push('---');
+  lines.push(`*Generated by vibecheck doctor v${REPORT_VERSION}*`);
+  
+  return lines.join('\n');
+}
+
+function saveReports(diagnostics, projectPath, durationMs, outputDir) {
+  const jsonReport = generateJsonReport(diagnostics, projectPath, durationMs);
+  const mdReport = generateMarkdownReport(diagnostics, projectPath, durationMs);
+  
+  // Ensure output directory exists
+  const doctorDir = path.join(outputDir, 'doctor');
+  fs.mkdirSync(doctorDir, { recursive: true });
+  
+  // Save timestamped reports
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const jsonPath = path.join(doctorDir, `doctor_${timestamp}.json`);
+  const mdPath = path.join(doctorDir, `doctor_${timestamp}.md`);
+  
+  fs.writeFileSync(jsonPath, JSON.stringify(jsonReport, null, 2));
+  fs.writeFileSync(mdPath, mdReport);
+  
+  // Save stable pointers
+  const lastJsonPath = path.join(doctorDir, 'last_doctor.json');
+  const lastMdPath = path.join(doctorDir, 'last_doctor.md');
+  
+  fs.writeFileSync(lastJsonPath, JSON.stringify(jsonReport, null, 2));
+  fs.writeFileSync(lastMdPath, mdReport);
+  
+  return {
+    json: jsonPath,
+    md: mdPath,
+    lastJson: lastJsonPath,
+    lastMd: lastMdPath,
+  };
+}
+
+module.exports = {
+  REPORT_VERSION,
+  calculateHealthScore,
+  getVerdict,
+  createSummary,
+  generateJsonReport,
+  generateMarkdownReport,
+  saveReports,
+};