@vibecheckai/cli 3.0.3 → 3.0.5

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

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

@@ -0,0 +1,312 @@
+/**
+ * Project Diagnostics Module
+ * 
+ * Checks project structure, configuration, and build capability
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { SEVERITY, CATEGORY, FIX_TYPE } = require('../types');
+
+const MODULE_ID = 'project';
+
+function createDiagnostics(projectPath) {
+  return [
+    {
+      id: `${MODULE_ID}.package_json`,
+      name: 'package.json',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      check: async () => {
+        const pkgPath = path.join(projectPath, 'package.json');
+        
+        if (!fs.existsSync(pkgPath)) {
+          return {
+            severity: SEVERITY.ERROR,
+            message: 'Not found',
+            detail: 'This doesn\'t appear to be a Node.js project',
+            fixes: [
+              {
+                type: FIX_TYPE.COMMAND,
+                description: 'Initialize a new Node.js project',
+                command: 'npm init -y',
+                autoFixable: true,
+              },
+            ],
+          };
+        }
+        
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+          const metadata = {
+            name: pkg.name,
+            version: pkg.version,
+            hasScripts: !!pkg.scripts,
+            hasDeps: !!(pkg.dependencies || pkg.devDependencies),
+          };
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: `${pkg.name || 'unnamed'}@${pkg.version || '0.0.0'}`,
+            metadata,
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.ERROR,
+            message: 'Invalid JSON',
+            detail: err.message,
+            fixes: [{
+              type: FIX_TYPE.MANUAL,
+              description: 'Fix JSON syntax errors in package.json',
+              autoFixable: false,
+            }],
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.node_modules`,
+      name: 'Dependencies Installed',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      dependsOn: [`${MODULE_ID}.package_json`],
+      check: async () => {
+        const nodeModulesPath = path.join(projectPath, 'node_modules');
+        
+        if (!fs.existsSync(nodeModulesPath)) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: 'node_modules not found',
+            detail: 'Run your package manager install command',
+            fixes: [
+              {
+                type: FIX_TYPE.COMMAND,
+                description: 'Install dependencies with pnpm',
+                command: 'pnpm install',
+                autoFixable: true,
+              },
+              {
+                type: FIX_TYPE.COMMAND,
+                description: 'Install dependencies with npm',
+                command: 'npm install',
+                autoFixable: true,
+              },
+            ],
+          };
+        }
+        
+        try {
+          const entries = fs.readdirSync(nodeModulesPath).filter(f => !f.startsWith('.'));
+          const count = entries.length;
+          
+          // Check for common issues
+          const lockFiles = ['pnpm-lock.yaml', 'package-lock.json', 'yarn.lock']
+            .filter(f => fs.existsSync(path.join(projectPath, f)));
+          
+          const metadata = { packageCount: count, lockFiles };
+          
+          if (lockFiles.length > 1) {
+            return {
+              severity: SEVERITY.WARNING,
+              message: `${count} packages (multiple lock files detected)`,
+              detail: `Found: ${lockFiles.join(', ')}`,
+              metadata,
+              fixes: [{
+                type: FIX_TYPE.MANUAL,
+                description: 'Remove extra lock files to avoid conflicts',
+                autoFixable: false,
+              }],
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: `${count} packages installed`,
+            metadata,
+          };
+        } catch {
+          return {
+            severity: SEVERITY.WARNING,
+            message: 'Cannot read node_modules',
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.typescript`,
+      name: 'TypeScript',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      check: async () => {
+        const tsConfigPath = path.join(projectPath, 'tsconfig.json');
+        
+        if (!fs.existsSync(tsConfigPath)) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Not configured (JavaScript project)',
+          };
+        }
+        
+        try {
+          const tsConfig = JSON.parse(fs.readFileSync(tsConfigPath, 'utf8'));
+          const strict = tsConfig.compilerOptions?.strict === true;
+          
+          const metadata = {
+            strict,
+            target: tsConfig.compilerOptions?.target,
+            module: tsConfig.compilerOptions?.module,
+          };
+          
+          if (!strict) {
+            return {
+              severity: SEVERITY.INFO,
+              message: 'Configured (strict mode disabled)',
+              metadata,
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: 'Configured with strict mode',
+            metadata,
+          };
+        } catch {
+          return {
+            severity: SEVERITY.WARNING,
+            message: 'Invalid tsconfig.json',
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Regenerate TypeScript config',
+              command: 'npx tsc --init',
+              autoFixable: false,
+            }],
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.source_structure`,
+      name: 'Source Structure',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      check: async () => {
+        const structures = [
+          { dir: 'src', type: 'standard' },
+          { dir: 'app', type: 'next-app-router' },
+          { dir: 'pages', type: 'next-pages-router' },
+          { dir: 'lib', type: 'library' },
+          { dir: 'packages', type: 'monorepo' },
+        ];
+        
+        const found = structures.filter(s => 
+          fs.existsSync(path.join(projectPath, s.dir))
+        );
+        
+        if (found.length === 0) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'No standard source directory detected',
+            detail: 'Consider organizing code in src/, app/, or pages/',
+          };
+        }
+        
+        const metadata = { structures: found.map(f => f.type) };
+        const primary = found[0];
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: `${primary.dir}/ (${primary.type})`,
+          metadata,
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.framework`,
+      name: 'Framework Detection',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      dependsOn: [`${MODULE_ID}.package_json`],
+      check: async () => {
+        const pkgPath = path.join(projectPath, 'package.json');
+        
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+          const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+          
+          const frameworks = [
+            { name: 'Next.js', packages: ['next'] },
+            { name: 'Remix', packages: ['@remix-run/node', '@remix-run/react'] },
+            { name: 'Fastify', packages: ['fastify'] },
+            { name: 'Express', packages: ['express'] },
+            { name: 'Hono', packages: ['hono'] },
+            { name: 'NestJS', packages: ['@nestjs/core'] },
+            { name: 'React', packages: ['react'] },
+            { name: 'Vue', packages: ['vue'] },
+            { name: 'Svelte', packages: ['svelte'] },
+          ];
+          
+          const detected = frameworks.filter(fw =>
+            fw.packages.some(p => deps[p])
+          );
+          
+          if (detected.length === 0) {
+            return {
+              severity: SEVERITY.INFO,
+              message: 'No known framework detected',
+            };
+          }
+          
+          const metadata = { frameworks: detected.map(f => f.name) };
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: detected.map(f => f.name).join(' + '),
+            metadata,
+          };
+        } catch {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Could not detect framework',
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.build`,
+      name: 'Build Script',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      dependsOn: [`${MODULE_ID}.package_json`],
+      check: async () => {
+        const pkgPath = path.join(projectPath, 'package.json');
+        
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+          
+          if (!pkg.scripts?.build) {
+            return {
+              severity: SEVERITY.INFO,
+              message: 'No build script defined',
+            };
+          }
+          
+          const metadata = { buildCommand: pkg.scripts.build };
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: `Defined: ${pkg.scripts.build.substring(0, 40)}${pkg.scripts.build.length > 40 ? '...' : ''}`,
+            metadata,
+          };
+        } catch {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Could not check build script',
+          };
+        }
+      },
+    },
+  ];
+}
+
+module.exports = { MODULE_ID, createDiagnostics };