@vibecheckai/cli 3.0.3 → 3.0.5

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/index.js

@@ -0,0 +1,37 @@
+/**
+ * Doctor Service — Enterprise Environment Diagnostics
+ * 
+ * Main entry point for the Doctor service
+ */
+
+const { DoctorService, diagnose } = require('./service');
+const { SEVERITY, CATEGORY, FIX_TYPE, SEVERITY_WEIGHT, CATEGORY_META } = require('./types');
+const modules = require('./modules');
+const reporter = require('./reporter');
+const autofix = require('./autofix');
+const ui = require('./ui');
+
+module.exports = {
+  // Main service
+  DoctorService,
+  diagnose,
+  
+  // Types and constants
+  SEVERITY,
+  CATEGORY,
+  FIX_TYPE,
+  SEVERITY_WEIGHT,
+  CATEGORY_META,
+  
+  // Modules
+  modules,
+  
+  // Reporter
+  reporter,
+  
+  // Auto-fix
+  autofix,
+  
+  // UI utilities
+  ui,
+};

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

@@ -0,0 +1,325 @@
+/**
+ * Dependencies Diagnostics Module
+ * 
+ * Checks for outdated packages, vulnerabilities, and dependency health
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { SEVERITY, CATEGORY, FIX_TYPE } = require('../types');
+
+const MODULE_ID = 'dependencies';
+
+function createDiagnostics(projectPath) {
+  return [
+    {
+      id: `${MODULE_ID}.outdated`,
+      name: 'Outdated Packages',
+      category: CATEGORY.DEPENDENCIES,
+      parallel: true,
+      check: async () => {
+        try {
+          // Try npm outdated (returns non-zero if outdated packages exist)
+          const result = execSync('npm outdated --json 2>/dev/null || echo "{}"', {
+            cwd: projectPath,
+            encoding: 'utf8',
+            timeout: 30000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+          }).trim();
+          
+          const outdated = JSON.parse(result || '{}');
+          const count = Object.keys(outdated).length;
+          
+          const metadata = { count, packages: outdated };
+          
+          // Check for major version updates
+          const majorUpdates = Object.entries(outdated).filter(([_, info]) => {
+            const current = parseInt((info.current || '0').split('.')[0]);
+            const latest = parseInt((info.latest || '0').split('.')[0]);
+            return latest > current;
+          });
+          
+          if (majorUpdates.length > 0) {
+            return {
+              severity: SEVERITY.INFO,
+              message: `${count} outdated (${majorUpdates.length} major)`,
+              detail: `Major updates: ${majorUpdates.slice(0, 3).map(([n]) => n).join(', ')}${majorUpdates.length > 3 ? '...' : ''}`,
+              metadata,
+              fixes: [{
+                type: FIX_TYPE.COMMAND,
+                description: 'Update all packages',
+                command: 'npm update',
+                autoFixable: false,
+              }],
+            };
+          }
+          
+          if (count > 0) {
+            return {
+              severity: SEVERITY.INFO,
+              message: `${count} minor/patch updates available`,
+              metadata,
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: 'All packages up to date',
+            metadata,
+          };
+        } catch {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Could not check for outdated packages',
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.audit`,
+      name: 'Security Vulnerabilities',
+      category: CATEGORY.DEPENDENCIES,
+      parallel: true,
+      check: async () => {
+        try {
+          const result = execSync('npm audit --json 2>/dev/null || echo "{}"', {
+            cwd: projectPath,
+            encoding: 'utf8',
+            timeout: 60000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+          }).trim();
+          
+          let audit;
+          try {
+            audit = JSON.parse(result || '{}');
+          } catch {
+            return {
+              severity: SEVERITY.INFO,
+              message: 'Could not parse audit results',
+            };
+          }
+          
+          const vulnerabilities = audit.metadata?.vulnerabilities || {};
+          const total = vulnerabilities.total || 0;
+          const critical = vulnerabilities.critical || 0;
+          const high = vulnerabilities.high || 0;
+          const moderate = vulnerabilities.moderate || 0;
+          const low = vulnerabilities.low || 0;
+          
+          const metadata = { total, critical, high, moderate, low };
+          
+          if (critical > 0) {
+            return {
+              severity: SEVERITY.ERROR,
+              message: `${critical} critical vulnerabilities`,
+              detail: `Total: ${total} (${high} high, ${moderate} moderate, ${low} low)`,
+              metadata,
+              fixes: [
+                {
+                  type: FIX_TYPE.COMMAND,
+                  description: 'Auto-fix vulnerabilities',
+                  command: 'npm audit fix',
+                  autoFixable: true,
+                },
+                {
+                  type: FIX_TYPE.COMMAND,
+                  description: 'Force fix (may have breaking changes)',
+                  command: 'npm audit fix --force',
+                  dangerous: true,
+                  autoFixable: false,
+                },
+              ],
+            };
+          }
+          
+          if (high > 0) {
+            return {
+              severity: SEVERITY.WARNING,
+              message: `${high} high severity vulnerabilities`,
+              detail: `Total: ${total} (${moderate} moderate, ${low} low)`,
+              metadata,
+              fixes: [{
+                type: FIX_TYPE.COMMAND,
+                description: 'Auto-fix vulnerabilities',
+                command: 'npm audit fix',
+                autoFixable: true,
+              }],
+            };
+          }
+          
+          if (total > 0) {
+            return {
+              severity: SEVERITY.INFO,
+              message: `${total} low/moderate vulnerabilities`,
+              metadata,
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: 'No known vulnerabilities',
+            metadata,
+          };
+        } catch {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Could not run security audit',
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.peer_deps`,
+      name: 'Peer Dependencies',
+      category: CATEGORY.DEPENDENCIES,
+      parallel: true,
+      check: async () => {
+        try {
+          const result = execSync('npm ls --json 2>&1 || true', {
+            cwd: projectPath,
+            encoding: 'utf8',
+            timeout: 30000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          
+          // Look for peer dependency warnings
+          const peerWarnings = (result.match(/WARN.*peer/gi) || []).length;
+          const missingPeers = (result.match(/missing peer/gi) || []).length;
+          
+          const metadata = { peerWarnings, missingPeers };
+          
+          if (missingPeers > 0) {
+            return {
+              severity: SEVERITY.WARNING,
+              message: `${missingPeers} missing peer dependencies`,
+              metadata,
+              fixes: [{
+                type: FIX_TYPE.COMMAND,
+                description: 'Install peer dependencies',
+                command: 'npm install --legacy-peer-deps',
+                autoFixable: false,
+              }],
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: 'Peer dependencies satisfied',
+            metadata,
+          };
+        } catch {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Could not check peer dependencies',
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.duplicate`,
+      name: 'Duplicate Packages',
+      category: CATEGORY.DEPENDENCIES,
+      parallel: true,
+      check: async () => {
+        try {
+          const result = execSync('npm dedupe --dry-run 2>&1 || true', {
+            cwd: projectPath,
+            encoding: 'utf8',
+            timeout: 30000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          
+          const wouldDedupe = result.includes('removed') || result.includes('dedupe');
+          
+          if (wouldDedupe) {
+            return {
+              severity: SEVERITY.INFO,
+              message: 'Deduplication possible',
+              fixes: [{
+                type: FIX_TYPE.COMMAND,
+                description: 'Deduplicate packages',
+                command: 'npm dedupe',
+                autoFixable: true,
+              }],
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: 'No duplicates found',
+          };
+        } catch {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Could not check for duplicates',
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.engines`,
+      name: 'Engine Requirements',
+      category: CATEGORY.DEPENDENCIES,
+      parallel: true,
+      check: async () => {
+        const pkgPath = path.join(projectPath, 'package.json');
+        
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+          
+          if (!pkg.engines) {
+            return {
+              severity: SEVERITY.INFO,
+              message: 'No engine requirements specified',
+              fixes: [{
+                type: FIX_TYPE.MANUAL,
+                description: 'Add "engines" field to package.json to enforce Node version',
+                autoFixable: false,
+              }],
+            };
+          }
+          
+          const nodeReq = pkg.engines.node;
+          const npmReq = pkg.engines.npm;
+          
+          const metadata = { nodeReq, npmReq };
+          
+          // Basic semver check against current version
+          if (nodeReq) {
+            const currentMajor = parseInt(process.version.slice(1).split('.')[0]);
+            const minMatch = nodeReq.match(/>=?\s*(\d+)/);
+            const minRequired = minMatch ? parseInt(minMatch[1]) : 0;
+            
+            if (currentMajor < minRequired) {
+              return {
+                severity: SEVERITY.ERROR,
+                message: `Node ${process.version} does not satisfy "${nodeReq}"`,
+                metadata,
+                fixes: [{
+                  type: FIX_TYPE.COMMAND,
+                  description: `Upgrade to Node ${minRequired}+`,
+                  command: `nvm install ${minRequired}`,
+                  autoFixable: false,
+                }],
+              };
+            }
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: nodeReq ? `node: ${nodeReq}` : 'Specified',
+            metadata,
+          };
+        } catch {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Could not check engine requirements',
+          };
+        }
+      },
+    },
+  ];
+}
+
+module.exports = { MODULE_ID, createDiagnostics };

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

@@ -0,0 +1,46 @@
+/**
+ * Diagnostic Modules Index
+ * 
+ * Exports all diagnostic modules for the Doctor service
+ */
+
+const system = require('./system');
+const runtime = require('./runtime');
+const project = require('./project');
+const dependencies = require('./dependencies');
+const security = require('./security');
+const network = require('./network');
+const vibecheck = require('./vibecheck');
+
+const ALL_MODULES = [
+  system,
+  runtime,
+  project,
+  dependencies,
+  security,
+  network,
+  vibecheck,
+];
+
+function getAllDiagnostics(projectPath) {
+  const diagnostics = [];
+  
+  for (const mod of ALL_MODULES) {
+    const moduleDiagnostics = mod.createDiagnostics(projectPath);
+    diagnostics.push(...moduleDiagnostics);
+  }
+  
+  return diagnostics;
+}
+
+module.exports = {
+  system,
+  runtime,
+  project,
+  dependencies,
+  security,
+  network,
+  vibecheck,
+  ALL_MODULES,
+  getAllDiagnostics,
+};