vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/doctor/safe-repair.js

@@ -0,0 +1,384 @@
+/**
+ * Safe Repair Mode
+ * 
+ * Executes only safe, non-destructive repair actions.
+ * Actions that can cause data loss or require elevated permissions are excluded.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+const { SEVERITY, FIX_TYPE } = require('./types');
+
+const REPAIR_RESULT = {
+  SUCCESS: 'success',
+  FAILED: 'failed',
+  SKIPPED: 'skipped',
+  NOT_APPLICABLE: 'not_applicable',
+};
+
+/**
+ * Safe repair actions that can be automatically executed
+ */
+const SAFE_REPAIR_ACTIONS = [
+  {
+    id: 'clear-npm-cache',
+    name: 'Clear npm cache',
+    description: 'Removes npm cache to fix integrity issues',
+    applicableTo: ['npm-cache-corrupt', 'npm-permission-error'],
+    check: () => true, // Always applicable
+    execute: async (projectPath, options) => {
+      try {
+        execSync('npm cache clean --force', {
+          cwd: projectPath,
+          encoding: 'utf8',
+          timeout: 60000,
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return { status: REPAIR_RESULT.SUCCESS, message: 'npm cache cleared' };
+      } catch (err) {
+        return { status: REPAIR_RESULT.FAILED, message: err.message };
+      }
+    },
+  },
+  {
+    id: 'clear-node-modules-cache',
+    name: 'Clear node_modules cache directories',
+    description: 'Removes .cache directories inside node_modules',
+    applicableTo: ['cache-large', 'build-cache-corrupt'],
+    check: (projectPath) => {
+      const cachePath = path.join(projectPath, 'node_modules', '.cache');
+      return fs.existsSync(cachePath);
+    },
+    execute: async (projectPath, options) => {
+      const cachePath = path.join(projectPath, 'node_modules', '.cache');
+      try {
+        fs.rmSync(cachePath, { recursive: true, force: true });
+        return { status: REPAIR_RESULT.SUCCESS, message: 'node_modules/.cache cleared' };
+      } catch (err) {
+        return { status: REPAIR_RESULT.FAILED, message: err.message };
+      }
+    },
+  },
+  {
+    id: 'remove-eslint-cache',
+    name: 'Remove ESLint cache',
+    description: 'Removes .eslintcache file',
+    applicableTo: ['eslint-error', 'cache-large'],
+    check: (projectPath) => fs.existsSync(path.join(projectPath, '.eslintcache')),
+    execute: async (projectPath, options) => {
+      try {
+        fs.unlinkSync(path.join(projectPath, '.eslintcache'));
+        return { status: REPAIR_RESULT.SUCCESS, message: '.eslintcache removed' };
+      } catch (err) {
+        return { status: REPAIR_RESULT.FAILED, message: err.message };
+      }
+    },
+  },
+  {
+    id: 'remove-tsbuildinfo',
+    name: 'Remove TypeScript build info',
+    description: 'Removes tsconfig.tsbuildinfo for clean TypeScript rebuild',
+    applicableTo: ['typescript-error', 'build-error'],
+    check: (projectPath) => {
+      // Check for any .tsbuildinfo file
+      return fs.existsSync(path.join(projectPath, 'tsconfig.tsbuildinfo')) ||
+        fs.existsSync(path.join(projectPath, '.tsbuildinfo'));
+    },
+    execute: async (projectPath, options) => {
+      const removed = [];
+      const files = ['tsconfig.tsbuildinfo', '.tsbuildinfo'];
+      
+      for (const file of files) {
+        const fullPath = path.join(projectPath, file);
+        if (fs.existsSync(fullPath)) {
+          try {
+            fs.unlinkSync(fullPath);
+            removed.push(file);
+          } catch {}
+        }
+      }
+      
+      if (removed.length > 0) {
+        return { status: REPAIR_RESULT.SUCCESS, message: `Removed: ${removed.join(', ')}` };
+      }
+      return { status: REPAIR_RESULT.NOT_APPLICABLE, message: 'No build info files found' };
+    },
+  },
+  {
+    id: 'remove-git-lock',
+    name: 'Remove git lock files',
+    description: 'Removes stale .git/*.lock files',
+    applicableTo: ['git-lock-file'],
+    check: (projectPath) => {
+      const gitDir = path.join(projectPath, '.git');
+      if (!fs.existsSync(gitDir)) return false;
+      
+      try {
+        const files = fs.readdirSync(gitDir);
+        return files.some(f => f.endsWith('.lock'));
+      } catch {
+        return false;
+      }
+    },
+    execute: async (projectPath, options) => {
+      const gitDir = path.join(projectPath, '.git');
+      const removed = [];
+      
+      try {
+        const files = fs.readdirSync(gitDir);
+        for (const file of files) {
+          if (file.endsWith('.lock')) {
+            fs.unlinkSync(path.join(gitDir, file));
+            removed.push(file);
+          }
+        }
+      } catch (err) {
+        return { status: REPAIR_RESULT.FAILED, message: err.message };
+      }
+      
+      if (removed.length > 0) {
+        return { status: REPAIR_RESULT.SUCCESS, message: `Removed: ${removed.join(', ')}` };
+      }
+      return { status: REPAIR_RESULT.NOT_APPLICABLE, message: 'No lock files found' };
+    },
+  },
+  {
+    id: 'create-vibecheck-dir',
+    name: 'Create .vibecheck directory',
+    description: 'Creates missing .vibecheck output directory',
+    applicableTo: ['vibecheck-dir-missing'],
+    check: (projectPath) => !fs.existsSync(path.join(projectPath, '.vibecheck')),
+    execute: async (projectPath, options) => {
+      try {
+        fs.mkdirSync(path.join(projectPath, '.vibecheck'), { recursive: true });
+        return { status: REPAIR_RESULT.SUCCESS, message: '.vibecheck directory created' };
+      } catch (err) {
+        return { status: REPAIR_RESULT.FAILED, message: err.message };
+      }
+    },
+  },
+  {
+    id: 'fix-npm-registry',
+    name: 'Reset npm registry URL',
+    description: 'Sets npm registry to default npmjs.org',
+    applicableTo: ['npm-network-error'],
+    check: () => true,
+    execute: async (projectPath, options) => {
+      try {
+        execSync('npm config set registry https://registry.npmjs.org/', {
+          encoding: 'utf8',
+          timeout: 10000,
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return { status: REPAIR_RESULT.SUCCESS, message: 'npm registry reset to default' };
+      } catch (err) {
+        return { status: REPAIR_RESULT.FAILED, message: err.message };
+      }
+    },
+  },
+  {
+    id: 'npm-dedupe',
+    name: 'Deduplicate npm packages',
+    description: 'Runs npm dedupe to reduce duplicate packages',
+    applicableTo: ['dependencies-large', 'peer-deps'],
+    check: (projectPath) => fs.existsSync(path.join(projectPath, 'node_modules')),
+    execute: async (projectPath, options) => {
+      try {
+        execSync('npm dedupe', {
+          cwd: projectPath,
+          encoding: 'utf8',
+          timeout: 120000, // 2 minutes
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return { status: REPAIR_RESULT.SUCCESS, message: 'npm dedupe completed' };
+      } catch (err) {
+        return { status: REPAIR_RESULT.FAILED, message: err.message };
+      }
+    },
+  },
+  {
+    id: 'rebuild-native-modules',
+    name: 'Rebuild native modules',
+    description: 'Runs npm rebuild for native module issues',
+    applicableTo: ['native-module-build', 'node-version-mismatch'],
+    check: (projectPath) => fs.existsSync(path.join(projectPath, 'node_modules')),
+    execute: async (projectPath, options) => {
+      try {
+        execSync('npm rebuild', {
+          cwd: projectPath,
+          encoding: 'utf8',
+          timeout: 300000, // 5 minutes
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return { status: REPAIR_RESULT.SUCCESS, message: 'npm rebuild completed' };
+      } catch (err) {
+        return { status: REPAIR_RESULT.FAILED, message: err.message };
+      }
+    },
+  },
+  {
+    id: 'prune-dev-dependencies',
+    name: 'Prune development dependencies',
+    description: 'Removes extraneous packages',
+    applicableTo: ['dependencies-large'],
+    check: (projectPath) => fs.existsSync(path.join(projectPath, 'node_modules')),
+    execute: async (projectPath, options) => {
+      try {
+        execSync('npm prune', {
+          cwd: projectPath,
+          encoding: 'utf8',
+          timeout: 60000,
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return { status: REPAIR_RESULT.SUCCESS, message: 'npm prune completed' };
+      } catch (err) {
+        return { status: REPAIR_RESULT.FAILED, message: err.message };
+      }
+    },
+  },
+];
+
+/**
+ * Run safe repair on a project
+ * @param {object[]} diagnostics - Diagnostic results
+ * @param {string} projectPath - Project path
+ * @param {object} options - Repair options
+ * @returns {object} Repair results
+ */
+async function runSafeRepair(diagnostics, projectPath, options = {}) {
+  const {
+    dryRun = false,
+    verbose = false,
+    maxActions = 10,
+  } = options;
+  
+  const results = [];
+  let actionsRun = 0;
+  
+  // Identify which repairs are applicable
+  const applicableRepairs = [];
+  
+  for (const action of SAFE_REPAIR_ACTIONS) {
+    // Check if this repair applies to any diagnostics
+    const relevantDiag = diagnostics.find(d => 
+      (d.severity === SEVERITY.ERROR || d.severity === SEVERITY.WARNING) &&
+      action.applicableTo.some(pattern => d.id.includes(pattern) || d.message?.toLowerCase().includes(pattern))
+    );
+    
+    if (relevantDiag && action.check(projectPath)) {
+      applicableRepairs.push({
+        action,
+        diagnostic: relevantDiag,
+      });
+    }
+  }
+  
+  // Execute repairs
+  for (const { action, diagnostic } of applicableRepairs) {
+    if (actionsRun >= maxActions) break;
+    
+    const result = {
+      actionId: action.id,
+      actionName: action.name,
+      description: action.description,
+      relatedDiagnostic: diagnostic.id,
+    };
+    
+    if (dryRun) {
+      result.status = REPAIR_RESULT.SKIPPED;
+      result.message = 'Dry run - would execute';
+      results.push(result);
+      continue;
+    }
+    
+    try {
+      const execResult = await action.execute(projectPath, options);
+      result.status = execResult.status;
+      result.message = execResult.message;
+      
+      if (execResult.status === REPAIR_RESULT.SUCCESS) {
+        actionsRun++;
+      }
+    } catch (err) {
+      result.status = REPAIR_RESULT.FAILED;
+      result.message = err.message;
+    }
+    
+    results.push(result);
+  }
+  
+  // Summary
+  const summary = {
+    total: results.length,
+    succeeded: results.filter(r => r.status === REPAIR_RESULT.SUCCESS).length,
+    failed: results.filter(r => r.status === REPAIR_RESULT.FAILED).length,
+    skipped: results.filter(r => r.status === REPAIR_RESULT.SKIPPED).length,
+    notApplicable: results.filter(r => r.status === REPAIR_RESULT.NOT_APPLICABLE).length,
+  };
+  
+  return {
+    projectPath,
+    timestamp: new Date().toISOString(),
+    dryRun,
+    results,
+    summary,
+    needsRecheck: summary.succeeded > 0,
+  };
+}
+
+/**
+ * Get list of all available safe repair actions
+ * @returns {object[]} Safe repair actions
+ */
+function listSafeRepairActions() {
+  return SAFE_REPAIR_ACTIONS.map(a => ({
+    id: a.id,
+    name: a.name,
+    description: a.description,
+    applicableTo: a.applicableTo,
+  }));
+}
+
+/**
+ * Run a specific repair action by ID
+ * @param {string} actionId - Action ID to run
+ * @param {string} projectPath - Project path
+ * @param {object} options - Options
+ * @returns {object} Result
+ */
+async function runRepairAction(actionId, projectPath, options = {}) {
+  const action = SAFE_REPAIR_ACTIONS.find(a => a.id === actionId);
+  
+  if (!action) {
+    return {
+      status: REPAIR_RESULT.FAILED,
+      message: `Unknown repair action: ${actionId}`,
+    };
+  }
+  
+  if (!action.check(projectPath)) {
+    return {
+      status: REPAIR_RESULT.NOT_APPLICABLE,
+      message: 'Repair action not applicable to current project state',
+    };
+  }
+  
+  if (options.dryRun) {
+    return {
+      status: REPAIR_RESULT.SKIPPED,
+      message: 'Dry run - would execute',
+      action: action.name,
+    };
+  }
+  
+  return action.execute(projectPath, options);
+}
+
+module.exports = {
+  REPAIR_RESULT,
+  SAFE_REPAIR_ACTIONS,
+  runSafeRepair,
+  listSafeRepairActions,
+  runRepairAction,
+};

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