@vibecheckai/cli 3.0.2 → 3.0.3

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

@@ -1,325 +0,0 @@
-/**
- * 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

@@ -1,46 +0,0 @@
-/**
- * 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,
-};

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

@@ -1,250 +0,0 @@
-/**
- * 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 };