@vibecheckai/cli 3.7.0 → 3.8.0

package/bin/runners/lib/doctor/modules/build-tools.js

@@ -0,0 +1,453 @@
+/**
+ * Build Tools Diagnostics Module
+ * 
+ * Checks tsconfig, ESLint, Prettier, Jest, Vitest, and build configuration
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { SEVERITY, CATEGORY, FIX_TYPE } = require('../types');
+
+const MODULE_ID = 'build';
+
+function createDiagnostics(projectPath) {
+  return [
+    {
+      id: `${MODULE_ID}.tsconfig`,
+      name: 'TypeScript Config',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      check: async () => {
+        const tsconfigPath = path.join(projectPath, 'tsconfig.json');
+        
+        if (!fs.existsSync(tsconfigPath)) {
+          // Check for jsconfig.json as fallback
+          const jsconfigPath = path.join(projectPath, 'jsconfig.json');
+          if (fs.existsSync(jsconfigPath)) {
+            return {
+              severity: SEVERITY.PASS,
+              message: 'jsconfig.json found (JavaScript project)',
+              metadata: { type: 'javascript', path: jsconfigPath },
+            };
+          }
+          
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Not found (JavaScript project)',
+            metadata: { type: 'javascript' },
+          };
+        }
+        
+        try {
+          const content = fs.readFileSync(tsconfigPath, 'utf8');
+          const config = JSON.parse(content);
+          
+          const issues = [];
+          const metadata = { path: tsconfigPath, config: {} };
+          
+          // Check for common misconfigurations
+          const compilerOptions = config.compilerOptions || {};
+          metadata.config = compilerOptions;
+          
+          // Check strict mode
+          if (!compilerOptions.strict) {
+            issues.push('strict mode disabled');
+          }
+          
+          // Check module resolution
+          if (compilerOptions.moduleResolution === 'node' && compilerOptions.module?.toLowerCase().includes('esnext')) {
+            issues.push('moduleResolution should be "bundler" or "nodenext" for ESM');
+          }
+          
+          // Check for skipLibCheck (acceptable but worth noting)
+          if (compilerOptions.skipLibCheck === false) {
+            metadata.slowBuild = true;
+          }
+          
+          // Check target
+          const target = (compilerOptions.target || 'es5').toLowerCase();
+          if (['es5', 'es6', 'es2015', 'es2016'].includes(target)) {
+            issues.push(`target "${compilerOptions.target}" is outdated, recommend ES2020+`);
+          }
+          
+          if (issues.length > 0) {
+            return {
+              severity: SEVERITY.WARNING,
+              message: issues.length === 1 ? issues[0] : `${issues.length} issues found`,
+              detail: issues.join('; '),
+              metadata,
+              fixes: [{
+                type: FIX_TYPE.LINK,
+                description: 'TypeScript configuration reference',
+                url: 'https://www.typescriptlang.org/tsconfig',
+              }],
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: `Valid (target: ${compilerOptions.target || 'default'})`,
+            metadata,
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.ERROR,
+            message: 'Invalid tsconfig.json',
+            detail: err.message,
+            fixes: [{
+              type: FIX_TYPE.MANUAL,
+              description: 'Fix JSON syntax errors in tsconfig.json',
+              autoFixable: false,
+            }],
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.eslint`,
+      name: 'ESLint Configuration',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      check: async () => {
+        const eslintConfigs = [
+          'eslint.config.js',
+          'eslint.config.mjs',
+          'eslint.config.cjs',
+          '.eslintrc.js',
+          '.eslintrc.cjs',
+          '.eslintrc.json',
+          '.eslintrc.yml',
+          '.eslintrc.yaml',
+          '.eslintrc',
+        ];
+        
+        let foundConfig = null;
+        for (const configFile of eslintConfigs) {
+          const configPath = path.join(projectPath, configFile);
+          if (fs.existsSync(configPath)) {
+            foundConfig = configFile;
+            break;
+          }
+          // Also check config/ directory
+          const configDirPath = path.join(projectPath, 'config', configFile);
+          if (fs.existsSync(configDirPath)) {
+            foundConfig = `config/${configFile}`;
+            break;
+          }
+        }
+        
+        // Check package.json for eslintConfig
+        const pkgPath = path.join(projectPath, 'package.json');
+        let pkgHasEslint = false;
+        if (fs.existsSync(pkgPath)) {
+          try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            if (pkg.eslintConfig) {
+              pkgHasEslint = true;
+            }
+          } catch {}
+        }
+        
+        if (!foundConfig && !pkgHasEslint) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'No ESLint config found',
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Initialize ESLint',
+              command: 'npm init @eslint/config',
+              autoFixable: false,
+            }],
+          };
+        }
+        
+        const configType = foundConfig?.startsWith('eslint.config') ? 'flat config' : 'legacy config';
+        const metadata = { config: foundConfig || 'package.json', type: configType };
+        
+        // Check if eslint is installed
+        try {
+          execSync('npx eslint --version', {
+            cwd: projectPath,
+            encoding: 'utf8',
+            timeout: 10000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: `${foundConfig || 'package.json'} (${configType})`,
+            metadata,
+          };
+        } catch {
+          return {
+            severity: SEVERITY.WARNING,
+            message: `Config found but ESLint not installed`,
+            metadata,
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Install ESLint',
+              command: 'npm install -D eslint',
+              autoFixable: true,
+            }],
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.prettier`,
+      name: 'Prettier Configuration',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      check: async () => {
+        const prettierConfigs = [
+          '.prettierrc',
+          '.prettierrc.json',
+          '.prettierrc.yml',
+          '.prettierrc.yaml',
+          '.prettierrc.js',
+          '.prettierrc.cjs',
+          '.prettierrc.mjs',
+          'prettier.config.js',
+          'prettier.config.cjs',
+          'prettier.config.mjs',
+        ];
+        
+        let foundConfig = null;
+        for (const configFile of prettierConfigs) {
+          if (fs.existsSync(path.join(projectPath, configFile))) {
+            foundConfig = configFile;
+            break;
+          }
+        }
+        
+        // Check package.json
+        const pkgPath = path.join(projectPath, 'package.json');
+        let pkgHasPrettier = false;
+        if (fs.existsSync(pkgPath)) {
+          try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            if (pkg.prettier) {
+              pkgHasPrettier = true;
+            }
+          } catch {}
+        }
+        
+        if (!foundConfig && !pkgHasPrettier) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'No Prettier config found',
+            fixes: [{
+              type: FIX_TYPE.FILE_CREATE,
+              description: 'Create default Prettier config',
+              path: '.prettierrc',
+              content: JSON.stringify({ semi: true, singleQuote: true, tabWidth: 2 }, null, 2),
+              autoFixable: true,
+            }],
+          };
+        }
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: foundConfig || 'package.json',
+          metadata: { config: foundConfig || 'package.json' },
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.test_framework`,
+      name: 'Test Framework',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      check: async () => {
+        const pkgPath = path.join(projectPath, 'package.json');
+        if (!fs.existsSync(pkgPath)) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'No package.json',
+          };
+        }
+        
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+          const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+          
+          const frameworks = [];
+          
+          if (deps.vitest) frameworks.push({ name: 'Vitest', version: deps.vitest });
+          if (deps.jest) frameworks.push({ name: 'Jest', version: deps.jest });
+          if (deps.mocha) frameworks.push({ name: 'Mocha', version: deps.mocha });
+          if (deps.ava) frameworks.push({ name: 'AVA', version: deps.ava });
+          if (deps.playwright || deps['@playwright/test']) {
+            frameworks.push({ name: 'Playwright', version: deps.playwright || deps['@playwright/test'] });
+          }
+          if (deps.cypress) frameworks.push({ name: 'Cypress', version: deps.cypress });
+          
+          if (frameworks.length === 0) {
+            return {
+              severity: SEVERITY.INFO,
+              message: 'No test framework detected',
+              fixes: [{
+                type: FIX_TYPE.COMMAND,
+                description: 'Install Vitest (recommended)',
+                command: 'npm install -D vitest',
+                autoFixable: false,
+              }],
+            };
+          }
+          
+          // Check for test config files
+          const configFiles = [];
+          const testConfigs = [
+            'vitest.config.ts', 'vitest.config.js',
+            'jest.config.ts', 'jest.config.js', 'jest.config.json',
+            'playwright.config.ts', 'playwright.config.js',
+          ];
+          
+          for (const config of testConfigs) {
+            if (fs.existsSync(path.join(projectPath, config))) {
+              configFiles.push(config);
+            }
+            if (fs.existsSync(path.join(projectPath, 'config', config))) {
+              configFiles.push(`config/${config}`);
+            }
+          }
+          
+          const primary = frameworks[0];
+          return {
+            severity: SEVERITY.PASS,
+            message: `${primary.name}${frameworks.length > 1 ? ` (+${frameworks.length - 1} more)` : ''}`,
+            metadata: { frameworks, configFiles },
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: 'Could not parse package.json',
+            detail: err.message,
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.bundler`,
+      name: 'Build/Bundler',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      check: async () => {
+        const pkgPath = path.join(projectPath, 'package.json');
+        if (!fs.existsSync(pkgPath)) {
+          return { severity: SEVERITY.INFO, message: 'No package.json' };
+        }
+        
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+          const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+          
+          const bundlers = [];
+          
+          // Frameworks (which include bundlers)
+          if (deps.next) bundlers.push({ name: 'Next.js', version: deps.next, type: 'framework' });
+          if (deps.nuxt) bundlers.push({ name: 'Nuxt', version: deps.nuxt, type: 'framework' });
+          if (deps['@remix-run/node'] || deps.remix) bundlers.push({ name: 'Remix', type: 'framework' });
+          if (deps.astro) bundlers.push({ name: 'Astro', version: deps.astro, type: 'framework' });
+          
+          // Bundlers
+          if (deps.vite) bundlers.push({ name: 'Vite', version: deps.vite, type: 'bundler' });
+          if (deps.webpack) bundlers.push({ name: 'Webpack', version: deps.webpack, type: 'bundler' });
+          if (deps.esbuild) bundlers.push({ name: 'esbuild', version: deps.esbuild, type: 'bundler' });
+          if (deps.rollup) bundlers.push({ name: 'Rollup', version: deps.rollup, type: 'bundler' });
+          if (deps.parcel) bundlers.push({ name: 'Parcel', version: deps.parcel, type: 'bundler' });
+          if (deps.turbo || deps.turbopack) bundlers.push({ name: 'Turbopack', type: 'bundler' });
+          if (deps.tsup) bundlers.push({ name: 'tsup', version: deps.tsup, type: 'bundler' });
+          
+          if (bundlers.length === 0) {
+            return {
+              severity: SEVERITY.INFO,
+              message: 'No bundler detected (possibly Node.js project)',
+              metadata: { type: 'node' },
+            };
+          }
+          
+          const primary = bundlers[0];
+          return {
+            severity: SEVERITY.PASS,
+            message: `${primary.name}${primary.version ? ` ${primary.version}` : ''}`,
+            metadata: { bundlers, primary: primary.name },
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: 'Could not detect bundler',
+            detail: err.message,
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.typescript_installed`,
+      name: 'TypeScript Installation',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      dependsOn: [`${MODULE_ID}.tsconfig`],
+      check: async () => {
+        const tsconfigPath = path.join(projectPath, 'tsconfig.json');
+        if (!fs.existsSync(tsconfigPath)) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Not applicable (no tsconfig.json)',
+          };
+        }
+        
+        // Check if TypeScript is installed
+        try {
+          const version = execSync('npx tsc --version', {
+            cwd: projectPath,
+            encoding: 'utf8',
+            timeout: 15000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+          }).trim();
+          
+          const match = version.match(/Version\s+(\d+\.\d+\.\d+)/);
+          const versionNum = match ? match[1] : version;
+          const major = parseInt(versionNum.split('.')[0]);
+          
+          const metadata = { version: versionNum, major };
+          
+          if (major < 5) {
+            return {
+              severity: SEVERITY.WARNING,
+              message: `${versionNum} — recommend TypeScript 5+`,
+              metadata,
+              fixes: [{
+                type: FIX_TYPE.COMMAND,
+                description: 'Update TypeScript',
+                command: 'npm install -D typescript@latest',
+                autoFixable: true,
+              }],
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: versionNum,
+            metadata,
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.ERROR,
+            message: 'TypeScript not installed',
+            detail: 'tsconfig.json exists but TypeScript is not installed',
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Install TypeScript',
+              command: 'npm install -D typescript',
+              autoFixable: true,
+            }],
+          };
+        }
+      },
+    },
+  ];
+}
+
+module.exports = { MODULE_ID, createDiagnostics };

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

@@ -1,7 +1,19 @@
 /**
  * Diagnostic Modules Index
  * 
- * Exports all diagnostic modules for the Doctor service
+ * 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');
@@ -11,11 +23,17 @@ 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,
@@ -26,13 +44,49 @@ function getAllDiagnostics(projectPath) {
   const diagnostics = [];
   
   for (const mod of ALL_MODULES) {
-    const moduleDiagnostics = mod.createDiagnostics(projectPath);
-    diagnostics.push(...moduleDiagnostics);
+    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,
@@ -41,6 +95,11 @@ module.exports = {
   security,
   network,
   vibecheck,
+  buildTools,
+  repoIntegrity,
+  osQuirks,
   ALL_MODULES,
   getAllDiagnostics,
+  getDiagnosticsByCategory,
+  getDiagnosticCounts,
 };