vibecheck-ai 2.0.1 → 5.0.0

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,105 @@
+/**
+ * Diagnostic Modules Index
+ * 
+ * Exports all diagnostic modules for the Doctor service.
+ * 
+ * Modules:
+ * - system: OS, memory, disk, CPU resources
+ * - runtime: Node.js, npm, package managers
+ * - project: package.json, dependencies, config files
+ * - dependencies: Outdated packages, vulnerabilities
+ * - security: Secrets, gitignore, env files
+ * - network: Internet, npm registry, API connectivity
+ * - vibecheck: Config, truth pack, scan status
+ * - buildTools: TypeScript, ESLint, Prettier, test frameworks
+ * - repoIntegrity: Git state, lock files, caches
+ * - osQuirks: Windows/macOS/Linux specific checks
+ */
+
+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 buildTools = require('./build-tools');
+const repoIntegrity = require('./repo-integrity');
+const osQuirks = require('./os-quirks');
+
+const ALL_MODULES = [
+  system,
+  osQuirks,     // OS-specific after system
+  runtime,
+  buildTools,   // Build tools after runtime
+  project,
+  repoIntegrity, // Repo integrity with project
+  dependencies,
+  security,
+  network,
+  vibecheck,
+];
+
+function getAllDiagnostics(projectPath) {
+  const diagnostics = [];
+  
+  for (const mod of ALL_MODULES) {
+    try {
+      const moduleDiagnostics = mod.createDiagnostics(projectPath);
+      diagnostics.push(...moduleDiagnostics);
+    } catch (err) {
+      // If a module fails to load, log but continue
+      console.error(`Warning: Could not load diagnostics from ${mod.MODULE_ID || 'unknown'}: ${err.message}`);
+    }
+  }
+  
+  return diagnostics;
+}
+
+/**
+ * Get diagnostics for specific categories only
+ * @param {string} projectPath - Project path
+ * @param {string[]} categories - Categories to include
+ * @returns {object[]} Filtered diagnostics
+ */
+function getDiagnosticsByCategory(projectPath, categories) {
+  const all = getAllDiagnostics(projectPath);
+  return all.filter(d => categories.includes(d.category));
+}
+
+/**
+ * Get a count of diagnostics by module
+ * @param {string} projectPath - Project path
+ * @returns {object} Module -> count mapping
+ */
+function getDiagnosticCounts(projectPath) {
+  const counts = {};
+  
+  for (const mod of ALL_MODULES) {
+    try {
+      const diagnostics = mod.createDiagnostics(projectPath);
+      counts[mod.MODULE_ID] = diagnostics.length;
+    } catch {
+      counts[mod.MODULE_ID] = 0;
+    }
+  }
+  
+  return counts;
+}
+
+module.exports = {
+  system,
+  runtime,
+  project,
+  dependencies,
+  security,
+  network,
+  vibecheck,
+  buildTools,
+  repoIntegrity,
+  osQuirks,
+  ALL_MODULES,
+  getAllDiagnostics,
+  getDiagnosticsByCategory,
+  getDiagnosticCounts,
+};

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

@@ -0,0 +1,250 @@
+/**
+ * Network Diagnostics Module
+ * 
+ * Checks network connectivity, API availability, and proxy configuration
+ */
+
+const https = require('https');
+const http = require('http');
+const { SEVERITY, CATEGORY, FIX_TYPE } = require('../types');
+
+const MODULE_ID = 'network';
+
+const ENDPOINTS = [
+  { name: 'npm Registry', url: 'https://registry.npmjs.org/', required: true },
+  { name: 'GitHub API', url: 'https://api.github.com/', required: false },
+  { name: 'vibecheck API', url: 'https://api.vibecheck.dev/health', required: false },
+];
+
+function checkUrl(url, timeout = 5000) {
+  return new Promise((resolve) => {
+    const protocol = url.startsWith('https') ? https : http;
+    const startTime = Date.now();
+    
+    const req = protocol.get(url, { timeout }, (res) => {
+      const latency = Date.now() - startTime;
+      resolve({
+        ok: res.statusCode >= 200 && res.statusCode < 400,
+        statusCode: res.statusCode,
+        latency,
+      });
+      res.destroy();
+    });
+    
+    req.on('error', (err) => {
+      resolve({
+        ok: false,
+        error: err.message,
+        latency: Date.now() - startTime,
+      });
+    });
+    
+    req.on('timeout', () => {
+      resolve({
+        ok: false,
+        error: 'Timeout',
+        latency: timeout,
+      });
+      req.destroy();
+    });
+  });
+}
+
+function createDiagnostics(projectPath) {
+  return [
+    {
+      id: `${MODULE_ID}.internet`,
+      name: 'Internet Connectivity',
+      category: CATEGORY.NETWORK,
+      parallel: true,
+      check: async () => {
+        const result = await checkUrl('https://www.google.com/', 5000);
+        
+        if (!result.ok) {
+          return {
+            severity: SEVERITY.ERROR,
+            message: 'No internet connection',
+            detail: result.error || 'Cannot reach google.com',
+            fixes: [{
+              type: FIX_TYPE.MANUAL,
+              description: 'Check your network connection and firewall settings',
+              autoFixable: false,
+            }],
+          };
+        }
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: `Connected (${result.latency}ms)`,
+          metadata: { latency: result.latency },
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.npm_registry`,
+      name: 'npm Registry',
+      category: CATEGORY.NETWORK,
+      parallel: true,
+      check: async () => {
+        const result = await checkUrl('https://registry.npmjs.org/', 10000);
+        
+        if (!result.ok) {
+          return {
+            severity: SEVERITY.ERROR,
+            message: 'Cannot reach npm registry',
+            detail: result.error,
+            fixes: [
+              {
+                type: FIX_TYPE.MANUAL,
+                description: 'Check if npm registry is blocked by firewall',
+                autoFixable: false,
+              },
+              {
+                type: FIX_TYPE.COMMAND,
+                description: 'Use alternative registry',
+                command: 'npm config set registry https://registry.npmmirror.com',
+                autoFixable: false,
+              },
+            ],
+          };
+        }
+        
+        if (result.latency > 3000) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: `Slow connection (${result.latency}ms)`,
+            detail: 'Package installations may be slow',
+            metadata: { latency: result.latency },
+          };
+        }
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: `Reachable (${result.latency}ms)`,
+          metadata: { latency: result.latency },
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.github`,
+      name: 'GitHub API',
+      category: CATEGORY.NETWORK,
+      parallel: true,
+      check: async () => {
+        const result = await checkUrl('https://api.github.com/', 5000);
+        
+        if (!result.ok) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Cannot reach GitHub API',
+            detail: 'Some features may be limited',
+            metadata: { error: result.error },
+          };
+        }
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: `Reachable (${result.latency}ms)`,
+          metadata: { latency: result.latency },
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.vibecheck_api`,
+      name: 'vibecheck API',
+      category: CATEGORY.NETWORK,
+      parallel: true,
+      check: async () => {
+        // Check if API key is configured
+        const hasApiKey = !!process.env.VIBECHECK_API_KEY;
+        
+        if (!hasApiKey) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'API key not configured (offline mode)',
+            detail: 'Set VIBECHECK_API_KEY for cloud features',
+          };
+        }
+        
+        const apiUrl = process.env.VIBECHECK_API_URL || 'https://api.vibecheck.dev';
+        const result = await checkUrl(`${apiUrl}/health`, 5000);
+        
+        if (!result.ok) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: 'vibecheck API unreachable',
+            detail: 'Cloud features may be unavailable',
+            metadata: { error: result.error, apiUrl },
+          };
+        }
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: `Connected (${result.latency}ms)`,
+          metadata: { latency: result.latency, apiUrl },
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.proxy`,
+      name: 'Proxy Configuration',
+      category: CATEGORY.NETWORK,
+      parallel: true,
+      check: async () => {
+        const httpProxy = process.env.HTTP_PROXY || process.env.http_proxy;
+        const httpsProxy = process.env.HTTPS_PROXY || process.env.https_proxy;
+        const noProxy = process.env.NO_PROXY || process.env.no_proxy;
+        
+        const metadata = { httpProxy, httpsProxy, noProxy };
+        
+        if (httpProxy || httpsProxy) {
+          return {
+            severity: SEVERITY.INFO,
+            message: `Proxy configured: ${httpsProxy || httpProxy}`,
+            metadata,
+          };
+        }
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: 'No proxy configured',
+          metadata,
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.dns`,
+      name: 'DNS Resolution',
+      category: CATEGORY.NETWORK,
+      parallel: true,
+      check: async () => {
+        const dns = require('dns').promises;
+        const startTime = Date.now();
+        
+        try {
+          await dns.resolve('registry.npmjs.org');
+          const latency = Date.now() - startTime;
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: `Working (${latency}ms)`,
+            metadata: { latency },
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.ERROR,
+            message: 'DNS resolution failed',
+            detail: err.message,
+            fixes: [{
+              type: FIX_TYPE.MANUAL,
+              description: 'Check DNS settings or use 8.8.8.8 / 1.1.1.1',
+              autoFixable: false,
+            }],
+          };
+        }
+      },
+    },
+  ];
+}
+
+module.exports = { MODULE_ID, createDiagnostics, checkUrl };