vibecheck-ai 2.0.1 → 5.0.0

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

@@ -0,0 +1,254 @@
+/**
+ * Doctor Auto-Fix Engine
+ * 
+ * Executes fixes for diagnostic issues automatically when safe
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawn } = require('child_process');
+const { FIX_TYPE, SEVERITY } = require('./types');
+
+const FIX_RESULT = {
+  SUCCESS: 'success',
+  FAILED: 'failed',
+  SKIPPED: 'skipped',
+  REQUIRES_CONFIRMATION: 'requires_confirmation',
+};
+
+function canAutoFix(fix) {
+  if (!fix) return false;
+  if (fix.dangerous) return false;
+  if (fix.autoFixable === false) return false;
+  
+  // Only auto-fix commands and file operations
+  return [FIX_TYPE.COMMAND, FIX_TYPE.FILE_CREATE, FIX_TYPE.FILE_EDIT].includes(fix.type);
+}
+
+async function executeFix(fix, projectPath, options = {}) {
+  const { dryRun = false, interactive = false } = options;
+  
+  if (!fix) {
+    return { status: FIX_RESULT.SKIPPED, reason: 'No fix provided' };
+  }
+  
+  if (fix.dangerous && !options.allowDangerous) {
+    return { 
+      status: FIX_RESULT.REQUIRES_CONFIRMATION, 
+      reason: 'Fix is marked as dangerous',
+      fix,
+    };
+  }
+  
+  if (dryRun) {
+    return { 
+      status: FIX_RESULT.SKIPPED, 
+      reason: 'Dry run mode',
+      wouldExecute: fix,
+    };
+  }
+  
+  try {
+    switch (fix.type) {
+      case FIX_TYPE.COMMAND:
+        return await executeCommand(fix, projectPath, options);
+      
+      case FIX_TYPE.FILE_CREATE:
+        return await createFile(fix, projectPath);
+      
+      case FIX_TYPE.FILE_EDIT:
+        return await editFile(fix, projectPath);
+      
+      case FIX_TYPE.MANUAL:
+        return { 
+          status: FIX_RESULT.SKIPPED, 
+          reason: 'Manual fix required',
+          instructions: fix.description,
+        };
+      
+      case FIX_TYPE.LINK:
+        return { 
+          status: FIX_RESULT.SKIPPED, 
+          reason: 'External documentation',
+          url: fix.url,
+        };
+      
+      default:
+        return { 
+          status: FIX_RESULT.SKIPPED, 
+          reason: `Unknown fix type: ${fix.type}`,
+        };
+    }
+  } catch (err) {
+    return {
+      status: FIX_RESULT.FAILED,
+      error: err.message,
+      fix,
+    };
+  }
+}
+
+async function executeCommand(fix, projectPath, options = {}) {
+  const { timeout = 60000 } = options;
+  
+  if (!fix.command) {
+    return { status: FIX_RESULT.SKIPPED, reason: 'No command specified' };
+  }
+  
+  try {
+    const result = execSync(fix.command, {
+      cwd: projectPath,
+      encoding: 'utf8',
+      timeout,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    
+    return {
+      status: FIX_RESULT.SUCCESS,
+      command: fix.command,
+      output: result.trim(),
+    };
+  } catch (err) {
+    return {
+      status: FIX_RESULT.FAILED,
+      command: fix.command,
+      error: err.message,
+      stderr: err.stderr,
+    };
+  }
+}
+
+async function createFile(fix, projectPath) {
+  if (!fix.path || fix.content === undefined) {
+    return { status: FIX_RESULT.SKIPPED, reason: 'No path or content specified' };
+  }
+  
+  const fullPath = path.isAbsolute(fix.path) ? fix.path : path.join(projectPath, fix.path);
+  
+  // Don't overwrite existing files
+  if (fs.existsSync(fullPath)) {
+    return { 
+      status: FIX_RESULT.SKIPPED, 
+      reason: 'File already exists',
+      path: fullPath,
+    };
+  }
+  
+  // Ensure directory exists
+  fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+  
+  // Write file
+  fs.writeFileSync(fullPath, fix.content);
+  
+  return {
+    status: FIX_RESULT.SUCCESS,
+    action: 'created',
+    path: fullPath,
+  };
+}
+
+async function editFile(fix, projectPath) {
+  if (!fix.path || fix.content === undefined) {
+    return { status: FIX_RESULT.SKIPPED, reason: 'No path or content specified' };
+  }
+  
+  const fullPath = path.isAbsolute(fix.path) ? fix.path : path.join(projectPath, fix.path);
+  
+  // Backup existing file
+  if (fs.existsSync(fullPath)) {
+    const backupPath = `${fullPath}.doctor-backup`;
+    fs.copyFileSync(fullPath, backupPath);
+  }
+  
+  // Write new content
+  fs.writeFileSync(fullPath, fix.content);
+  
+  return {
+    status: FIX_RESULT.SUCCESS,
+    action: 'edited',
+    path: fullPath,
+  };
+}
+
+async function autoFixAll(diagnostics, projectPath, options = {}) {
+  const { 
+    dryRun = false, 
+    severity = [SEVERITY.CRITICAL, SEVERITY.ERROR],
+    maxFixes = 10,
+  } = options;
+  
+  const results = [];
+  let fixCount = 0;
+  
+  // Sort by severity (critical first)
+  const severityOrder = [SEVERITY.CRITICAL, SEVERITY.ERROR, SEVERITY.WARNING];
+  const sortedDiagnostics = [...diagnostics].sort((a, b) => {
+    return severityOrder.indexOf(a.severity) - severityOrder.indexOf(b.severity);
+  });
+  
+  for (const diagnostic of sortedDiagnostics) {
+    if (fixCount >= maxFixes) break;
+    if (!severity.includes(diagnostic.severity)) continue;
+    if (!diagnostic.fixes || diagnostic.fixes.length === 0) continue;
+    
+    // Try the first auto-fixable fix
+    const fix = diagnostic.fixes.find(f => canAutoFix(f));
+    if (!fix) continue;
+    
+    const result = await executeFix(fix, projectPath, { ...options, dryRun });
+    results.push({
+      diagnosticId: diagnostic.id,
+      diagnosticName: diagnostic.name,
+      ...result,
+    });
+    
+    if (result.status === FIX_RESULT.SUCCESS) {
+      fixCount++;
+    }
+  }
+  
+  return {
+    attempted: results.length,
+    succeeded: results.filter(r => r.status === FIX_RESULT.SUCCESS).length,
+    failed: results.filter(r => r.status === FIX_RESULT.FAILED).length,
+    skipped: results.filter(r => r.status === FIX_RESULT.SKIPPED).length,
+    results,
+  };
+}
+
+function getFixCommands(diagnostics, options = {}) {
+  const { severity = [SEVERITY.CRITICAL, SEVERITY.ERROR, SEVERITY.WARNING] } = options;
+  
+  const commands = [];
+  
+  for (const diagnostic of diagnostics) {
+    if (!severity.includes(diagnostic.severity)) continue;
+    if (!diagnostic.fixes) continue;
+    
+    for (const fix of diagnostic.fixes) {
+      if (fix.type === FIX_TYPE.COMMAND && fix.command) {
+        commands.push({
+          diagnosticId: diagnostic.id,
+          diagnosticName: diagnostic.name,
+          command: fix.command,
+          description: fix.description,
+          dangerous: fix.dangerous,
+          autoFixable: canAutoFix(fix),
+        });
+      }
+    }
+  }
+  
+  return commands;
+}
+
+module.exports = {
+  FIX_RESULT,
+  canAutoFix,
+  executeFix,
+  executeCommand,
+  createFile,
+  editFile,
+  autoFixAll,
+  getFixCommands,
+};

package/bin/runners/lib/doctor/diagnosis-receipt.js

@@ -0,0 +1,454 @@
+/**
+ * Diagnosis Receipt Generator
+ * 
+ * Generates comprehensive, machine-readable diagnostic reports in JSON format.
+ * The "receipt" format provides complete audit trail for troubleshooting.
+ */
+
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+const crypto = require('crypto');
+const { SEVERITY, CATEGORY, CATEGORY_META } = require('./types');
+
+const RECEIPT_VERSION = '2.0.0';
+
+/**
+ * Generate a complete diagnosis receipt
+ * @param {object[]} diagnostics - Array of diagnostic results
+ * @param {object} options - Generation options
+ * @returns {object} Complete diagnosis receipt
+ */
+function generateDiagnosisReceipt(diagnostics, options = {}) {
+  const {
+    projectPath = process.cwd(),
+    startTime,
+    endTime = new Date().toISOString(),
+    runId,
+    command = 'doctor',
+    triggeredBy = 'cli',
+    additionalContext = {},
+  } = options;
+  
+  const durationMs = startTime ? new Date(endTime) - new Date(startTime) : 0;
+  
+  // Calculate health score
+  const healthScore = calculateHealthScore(diagnostics);
+  
+  // Generate summary
+  const summary = generateSummary(diagnostics);
+  
+  // Collect environment info
+  const environment = collectEnvironmentInfo(projectPath);
+  
+  // Generate receipt hash for integrity verification
+  const receiptHash = generateReceiptHash(diagnostics, environment);
+  
+  // Build the receipt
+  const receipt = {
+    // Metadata
+    $schema: 'https://vibecheck.dev/schemas/diagnosis-receipt-v2.json',
+    version: RECEIPT_VERSION,
+    receiptId: runId || generateReceiptId(),
+    receiptHash,
+    generatedAt: endTime,
+    
+    // Execution context
+    execution: {
+      command,
+      triggeredBy,
+      startTime,
+      endTime,
+      durationMs,
+      exitCode: healthScore.exitCode,
+    },
+    
+    // Project info
+    project: {
+      path: projectPath,
+      name: path.basename(projectPath),
+      ...detectProjectType(projectPath),
+    },
+    
+    // Environment snapshot
+    environment,
+    
+    // Diagnostic results
+    diagnostics: diagnostics.map(d => formatDiagnosticResult(d)),
+    
+    // Summary and verdict
+    summary,
+    
+    // Health assessment
+    health: {
+      score: healthScore.score,
+      grade: healthScore.grade,
+      verdict: healthScore.verdict,
+      status: healthScore.status,
+    },
+    
+    // Fix recommendations
+    recommendations: generateRecommendations(diagnostics),
+    
+    // Additional context (if provided)
+    ...(Object.keys(additionalContext).length > 0 && { context: additionalContext }),
+  };
+  
+  return receipt;
+}
+
+function collectEnvironmentInfo(projectPath) {
+  const nodeVersion = process.version;
+  const nodeMajor = parseInt(nodeVersion.slice(1).split('.')[0]);
+  
+  // Try to get npm version
+  let npmVersion = 'unknown';
+  try {
+    const { execSync } = require('child_process');
+    npmVersion = execSync('npm --version', { encoding: 'utf8', timeout: 5000 }).trim();
+  } catch {}
+  
+  // Try to get git info
+  let gitInfo = null;
+  const gitDir = path.join(projectPath, '.git');
+  if (fs.existsSync(gitDir)) {
+    try {
+      const { execSync } = require('child_process');
+      const branch = execSync('git rev-parse --abbrev-ref HEAD', { 
+        cwd: projectPath, encoding: 'utf8', timeout: 5000 
+      }).trim();
+      const commit = execSync('git rev-parse --short HEAD', { 
+        cwd: projectPath, encoding: 'utf8', timeout: 5000 
+      }).trim();
+      gitInfo = { branch, commit };
+    } catch {}
+  }
+  
+  return {
+    // System
+    platform: os.platform(),
+    arch: os.arch(),
+    osRelease: os.release(),
+    hostname: os.hostname(),
+    
+    // Resources
+    cpuCores: os.cpus().length,
+    totalMemoryGB: (os.totalmem() / (1024 ** 3)).toFixed(1),
+    freeMemoryGB: (os.freemem() / (1024 ** 3)).toFixed(1),
+    
+    // Runtime
+    nodeVersion,
+    nodeMajor,
+    npmVersion,
+    
+    // Process
+    pid: process.pid,
+    cwd: process.cwd(),
+    argv: process.argv.slice(2),
+    
+    // Environment variables (safe subset)
+    env: {
+      NODE_ENV: process.env.NODE_ENV || 'undefined',
+      CI: process.env.CI || 'false',
+      TERM: process.env.TERM || 'unknown',
+      SHELL: process.env.SHELL || process.env.ComSpec || 'unknown',
+    },
+    
+    // Git info
+    git: gitInfo,
+    
+    // Timestamps
+    timestamp: new Date().toISOString(),
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+  };
+}
+
+function detectProjectType(projectPath) {
+  const pkgPath = path.join(projectPath, 'package.json');
+  
+  const info = {
+    type: 'unknown',
+    framework: null,
+    language: 'javascript',
+    monorepo: false,
+  };
+  
+  if (!fs.existsSync(pkgPath)) {
+    return info;
+  }
+  
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    
+    // Detect language
+    if (deps.typescript || fs.existsSync(path.join(projectPath, 'tsconfig.json'))) {
+      info.language = 'typescript';
+    }
+    
+    // Detect framework
+    if (deps.next) info.framework = 'next';
+    else if (deps.nuxt) info.framework = 'nuxt';
+    else if (deps.remix || deps['@remix-run/node']) info.framework = 'remix';
+    else if (deps.astro) info.framework = 'astro';
+    else if (deps.svelte || deps['@sveltejs/kit']) info.framework = 'svelte';
+    else if (deps.vue) info.framework = 'vue';
+    else if (deps.react) info.framework = 'react';
+    else if (deps.express) info.framework = 'express';
+    else if (deps.fastify) info.framework = 'fastify';
+    else if (deps.nest || deps['@nestjs/core']) info.framework = 'nestjs';
+    
+    // Detect project type
+    if (info.framework) {
+      info.type = info.framework;
+    } else if (pkg.bin) {
+      info.type = 'cli';
+    } else if (pkg.main || pkg.module || pkg.exports) {
+      info.type = 'library';
+    } else {
+      info.type = 'application';
+    }
+    
+    // Detect monorepo
+    if (pkg.workspaces || fs.existsSync(path.join(projectPath, 'pnpm-workspace.yaml'))) {
+      info.monorepo = true;
+    }
+    
+    // Add version
+    info.version = pkg.version;
+    info.name = pkg.name;
+    
+  } catch {}
+  
+  return info;
+}
+
+function formatDiagnosticResult(diag) {
+  return {
+    id: diag.id,
+    name: diag.name,
+    category: diag.category,
+    severity: diag.severity,
+    status: severityToStatus(diag.severity),
+    message: diag.message,
+    detail: diag.detail || null,
+    durationMs: diag.durationMs || 0,
+    metadata: diag.metadata || null,
+    fixes: (diag.fixes || []).map(f => ({
+      type: f.type,
+      description: f.description,
+      command: f.command || null,
+      url: f.url || null,
+      autoFixable: f.autoFixable !== false && !f.dangerous,
+      dangerous: f.dangerous || false,
+    })),
+  };
+}
+
+function severityToStatus(severity) {
+  const map = {
+    [SEVERITY.CRITICAL]: 'critical',
+    [SEVERITY.ERROR]: 'error',
+    [SEVERITY.WARNING]: 'warning',
+    [SEVERITY.INFO]: 'info',
+    [SEVERITY.PASS]: 'pass',
+  };
+  return map[severity] || 'unknown';
+}
+
+function generateSummary(diagnostics) {
+  const byCategory = {};
+  const bySeverity = {
+    critical: 0,
+    error: 0,
+    warning: 0,
+    info: 0,
+    pass: 0,
+  };
+  
+  for (const diag of diagnostics) {
+    // By category
+    if (!byCategory[diag.category]) {
+      byCategory[diag.category] = {
+        name: CATEGORY_META[diag.category]?.name || diag.category,
+        icon: CATEGORY_META[diag.category]?.icon || '?',
+        total: 0,
+        passed: 0,
+        failed: 0,
+        warnings: 0,
+      };
+    }
+    
+    const cat = byCategory[diag.category];
+    cat.total++;
+    
+    if (diag.severity === SEVERITY.PASS) cat.passed++;
+    else if (diag.severity === SEVERITY.ERROR || diag.severity === SEVERITY.CRITICAL) cat.failed++;
+    else if (diag.severity === SEVERITY.WARNING) cat.warnings++;
+    
+    // By severity
+    const sev = severityToStatus(diag.severity);
+    if (bySeverity[sev] !== undefined) bySeverity[sev]++;
+  }
+  
+  return {
+    total: diagnostics.length,
+    bySeverity,
+    byCategory: Object.values(byCategory),
+    fixableCount: diagnostics.filter(d => 
+      d.fixes?.some(f => f.autoFixable !== false && !f.dangerous)
+    ).length,
+    dangerouxFixCount: diagnostics.filter(d =>
+      d.fixes?.some(f => f.dangerous)
+    ).length,
+  };
+}
+
+function calculateHealthScore(diagnostics) {
+  let score = 100;
+  let criticalCount = 0;
+  let errorCount = 0;
+  let warningCount = 0;
+  
+  for (const diag of diagnostics) {
+    switch (diag.severity) {
+      case SEVERITY.CRITICAL:
+        score -= 25;
+        criticalCount++;
+        break;
+      case SEVERITY.ERROR:
+        score -= 15;
+        errorCount++;
+        break;
+      case SEVERITY.WARNING:
+        score -= 5;
+        warningCount++;
+        break;
+    }
+  }
+  
+  score = Math.max(0, Math.min(100, score));
+  
+  // Determine grade
+  let grade, verdict, status, exitCode;
+  
+  if (criticalCount > 0) {
+    grade = 'F';
+    verdict = 'CRITICAL';
+    status = 'Environment has critical issues that must be fixed';
+    exitCode = 3;
+  } else if (errorCount > 0) {
+    grade = score >= 50 ? 'D' : 'F';
+    verdict = 'UNHEALTHY';
+    status = 'Environment has errors that should be fixed';
+    exitCode = 2;
+  } else if (warningCount > 0) {
+    grade = score >= 80 ? 'B' : 'C';
+    verdict = 'DEGRADED';
+    status = 'Environment has warnings to review';
+    exitCode = 1;
+  } else {
+    grade = 'A';
+    verdict = 'HEALTHY';
+    status = 'Environment is healthy';
+    exitCode = 0;
+  }
+  
+  return {
+    score,
+    grade,
+    verdict,
+    status,
+    exitCode,
+    breakdown: {
+      critical: criticalCount,
+      errors: errorCount,
+      warnings: warningCount,
+      passed: diagnostics.filter(d => d.severity === SEVERITY.PASS).length,
+    },
+  };
+}
+
+function generateRecommendations(diagnostics) {
+  const recommendations = [];
+  
+  // Priority: Critical > Error > Warning
+  const prioritized = [...diagnostics]
+    .filter(d => d.fixes?.length > 0)
+    .sort((a, b) => {
+      const order = { critical: 0, error: 1, warning: 2, info: 3, pass: 4 };
+      return (order[a.severity] || 4) - (order[b.severity] || 4);
+    });
+  
+  for (const diag of prioritized.slice(0, 5)) { // Top 5 recommendations
+    const autoFix = diag.fixes.find(f => f.autoFixable !== false && !f.dangerous && f.command);
+    
+    recommendations.push({
+      priority: recommendations.length + 1,
+      diagnosticId: diag.id,
+      name: diag.name,
+      severity: diag.severity,
+      message: diag.message,
+      quickFix: autoFix?.command || null,
+      description: autoFix?.description || diag.fixes[0]?.description || null,
+    });
+  }
+  
+  return recommendations;
+}
+
+function generateReceiptId() {
+  const timestamp = Date.now().toString(36);
+  const random = crypto.randomBytes(4).toString('hex');
+  return `dr-${timestamp}-${random}`;
+}
+
+function generateReceiptHash(diagnostics, environment) {
+  const content = JSON.stringify({
+    diagnostics: diagnostics.map(d => ({ id: d.id, severity: d.severity })),
+    env: environment.nodeVersion + environment.platform,
+  });
+  return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+
+/**
+ * Save diagnosis receipt to file
+ * @param {object} receipt - The diagnosis receipt
+ * @param {string} outputPath - Where to save
+ * @returns {string} Path to saved file
+ */
+function saveReceipt(receipt, outputPath) {
+  const dir = path.dirname(outputPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  
+  fs.writeFileSync(outputPath, JSON.stringify(receipt, null, 2));
+  return outputPath;
+}
+
+/**
+ * Generate a compact one-line receipt for logging
+ * @param {object} receipt - Full receipt
+ * @returns {string} Compact summary
+ */
+function generateCompactReceipt(receipt) {
+  return JSON.stringify({
+    id: receipt.receiptId,
+    ts: receipt.generatedAt,
+    score: receipt.health.score,
+    grade: receipt.health.grade,
+    verdict: receipt.health.verdict,
+    checks: receipt.summary.total,
+    errors: receipt.summary.bySeverity.error,
+    warnings: receipt.summary.bySeverity.warning,
+  });
+}
+
+module.exports = {
+  RECEIPT_VERSION,
+  generateDiagnosisReceipt,
+  saveReceipt,
+  generateCompactReceipt,
+  calculateHealthScore,
+};