vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/doctor/modules/repo-integrity.js

@@ -0,0 +1,485 @@
+/**
+ * Repository Integrity Diagnostics Module
+ * 
+ * Checks git state, lock files, caches, and repo health
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { SEVERITY, CATEGORY, FIX_TYPE } = require('../types');
+
+const MODULE_ID = 'repo';
+
+function createDiagnostics(projectPath) {
+  return [
+    {
+      id: `${MODULE_ID}.git_status`,
+      name: 'Git Repository',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      check: async () => {
+        const gitDir = path.join(projectPath, '.git');
+        
+        if (!fs.existsSync(gitDir)) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Not a git repository',
+            metadata: { isGitRepo: false },
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Initialize git repository',
+              command: 'git init',
+              autoFixable: true,
+            }],
+          };
+        }
+        
+        try {
+          // Check git status
+          const status = execSync('git status --porcelain', {
+            cwd: projectPath,
+            encoding: 'utf8',
+            timeout: 10000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          
+          const lines = status.trim().split('\n').filter(Boolean);
+          const untracked = lines.filter(l => l.startsWith('??')).length;
+          const modified = lines.filter(l => l.startsWith(' M') || l.startsWith('M ')).length;
+          const staged = lines.filter(l => l.startsWith('A ') || l.startsWith('M ') || l.startsWith('D ')).length;
+          
+          const metadata = { isGitRepo: true, untracked, modified, staged, total: lines.length };
+          
+          if (lines.length === 0) {
+            return {
+              severity: SEVERITY.PASS,
+              message: 'Clean working directory',
+              metadata,
+            };
+          }
+          
+          return {
+            severity: SEVERITY.INFO,
+            message: `${lines.length} uncommitted changes`,
+            detail: `${modified} modified, ${untracked} untracked, ${staged} staged`,
+            metadata,
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: 'Git command failed',
+            detail: err.message,
+            metadata: { isGitRepo: true },
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.git_hooks`,
+      name: 'Git Hooks',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      check: async () => {
+        // Check for Husky
+        const huskyDir = path.join(projectPath, '.husky');
+        const hasHusky = fs.existsSync(huskyDir);
+        
+        // Check for lefthook
+        const leftHookConfig = ['lefthook.yml', 'lefthook.yaml', '.lefthook.yml'];
+        const hasLefthook = leftHookConfig.some(f => fs.existsSync(path.join(projectPath, f)));
+        
+        // Check for simple-git-hooks
+        const pkgPath = path.join(projectPath, 'package.json');
+        let hasSimpleHooks = false;
+        if (fs.existsSync(pkgPath)) {
+          try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            hasSimpleHooks = !!pkg['simple-git-hooks'];
+          } catch {}
+        }
+        
+        const metadata = { husky: hasHusky, lefthook: hasLefthook, simpleGitHooks: hasSimpleHooks };
+        
+        if (hasHusky) {
+          return { severity: SEVERITY.PASS, message: 'Husky configured', metadata };
+        }
+        if (hasLefthook) {
+          return { severity: SEVERITY.PASS, message: 'Lefthook configured', metadata };
+        }
+        if (hasSimpleHooks) {
+          return { severity: SEVERITY.PASS, message: 'simple-git-hooks configured', metadata };
+        }
+        
+        return {
+          severity: SEVERITY.INFO,
+          message: 'No git hooks configured',
+          metadata,
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.lock_file`,
+      name: 'Lock File',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      check: async () => {
+        const lockFiles = {
+          'pnpm-lock.yaml': 'pnpm',
+          'package-lock.json': 'npm',
+          'yarn.lock': 'yarn',
+          'bun.lockb': 'bun',
+        };
+        
+        const found = [];
+        for (const [file, manager] of Object.entries(lockFiles)) {
+          if (fs.existsSync(path.join(projectPath, file))) {
+            found.push({ file, manager });
+          }
+        }
+        
+        const metadata = { lockFiles: found };
+        
+        if (found.length === 0) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: 'No lock file found',
+            detail: 'Lock files ensure reproducible builds',
+            metadata,
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Generate lock file',
+              command: 'npm install',
+              autoFixable: true,
+            }],
+          };
+        }
+        
+        if (found.length > 1) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: `Multiple lock files: ${found.map(f => f.file).join(', ')}`,
+            detail: 'Having multiple lock files can cause confusion and inconsistent installs',
+            metadata,
+            fixes: [{
+              type: FIX_TYPE.MANUAL,
+              description: 'Remove extra lock files, keep only one for your chosen package manager',
+              autoFixable: false,
+            }],
+          };
+        }
+        
+        const primary = found[0];
+        return {
+          severity: SEVERITY.PASS,
+          message: `${primary.file} (${primary.manager})`,
+          metadata,
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.lock_file_sync`,
+      name: 'Lock File Sync',
+      category: CATEGORY.PROJECT,
+      parallel: false,
+      dependsOn: [`${MODULE_ID}.lock_file`],
+      check: async () => {
+        const pkgPath = path.join(projectPath, 'package.json');
+        const lockPath = path.join(projectPath, 'package-lock.json');
+        const pnpmLockPath = path.join(projectPath, 'pnpm-lock.yaml');
+        const yarnLockPath = path.join(projectPath, 'yarn.lock');
+        
+        if (!fs.existsSync(pkgPath)) {
+          return { severity: SEVERITY.INFO, message: 'No package.json' };
+        }
+        
+        let lockFile = null;
+        let command = null;
+        
+        if (fs.existsSync(pnpmLockPath)) {
+          lockFile = pnpmLockPath;
+          command = 'pnpm install --frozen-lockfile';
+        } else if (fs.existsSync(lockPath)) {
+          lockFile = lockPath;
+          command = 'npm ci';
+        } else if (fs.existsSync(yarnLockPath)) {
+          lockFile = yarnLockPath;
+          command = 'yarn install --frozen-lockfile';
+        }
+        
+        if (!lockFile) {
+          return { severity: SEVERITY.INFO, message: 'No lock file to check' };
+        }
+        
+        // Check modification times
+        const pkgStat = fs.statSync(pkgPath);
+        const lockStat = fs.statSync(lockFile);
+        
+        const metadata = {
+          packageJsonModified: pkgStat.mtime.toISOString(),
+          lockFileModified: lockStat.mtime.toISOString(),
+        };
+        
+        // If package.json is newer than lock file, might be out of sync
+        if (pkgStat.mtime > lockStat.mtime) {
+          const hoursDiff = (pkgStat.mtime - lockStat.mtime) / (1000 * 60 * 60);
+          
+          if (hoursDiff > 1) {
+            return {
+              severity: SEVERITY.WARNING,
+              message: 'Lock file may be outdated',
+              detail: `package.json modified ${Math.round(hoursDiff)}h after lock file`,
+              metadata,
+              fixes: [{
+                type: FIX_TYPE.COMMAND,
+                description: 'Regenerate lock file',
+                command: command.replace('--frozen-lockfile', '').replace(' ci', ' install'),
+                autoFixable: true,
+              }],
+            };
+          }
+        }
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: 'Lock file appears synchronized',
+          metadata,
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.node_modules`,
+      name: 'node_modules',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      check: async () => {
+        const nmPath = path.join(projectPath, 'node_modules');
+        
+        if (!fs.existsSync(nmPath)) {
+          return {
+            severity: SEVERITY.ERROR,
+            message: 'node_modules not found',
+            detail: 'Dependencies not installed',
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Install dependencies',
+              command: 'npm install',
+              autoFixable: true,
+            }],
+          };
+        }
+        
+        // Check if .bin exists
+        const binPath = path.join(nmPath, '.bin');
+        const hasBin = fs.existsSync(binPath);
+        
+        // Get approximate size (count directories)
+        try {
+          const entries = fs.readdirSync(nmPath);
+          const packageCount = entries.filter(e => !e.startsWith('.')).length;
+          
+          const metadata = { packageCount, hasBin };
+          
+          if (packageCount === 0) {
+            return {
+              severity: SEVERITY.WARNING,
+              message: 'node_modules is empty',
+              metadata,
+              fixes: [{
+                type: FIX_TYPE.COMMAND,
+                description: 'Reinstall dependencies',
+                command: 'rm -rf node_modules && npm install',
+                autoFixable: false,
+                dangerous: true,
+              }],
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: `${packageCount} packages`,
+            metadata,
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: 'Could not read node_modules',
+            detail: err.message,
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.cache_dirs`,
+      name: 'Build Caches',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      check: async () => {
+        const cacheDirs = [
+          { name: '.next', desc: 'Next.js cache' },
+          { name: '.nuxt', desc: 'Nuxt cache' },
+          { name: '.turbo', desc: 'Turborepo cache' },
+          { name: '.cache', desc: 'General cache' },
+          { name: 'dist', desc: 'Build output' },
+          { name: 'build', desc: 'Build output' },
+          { name: '.vibecheck', desc: 'Vibecheck cache' },
+          { name: 'coverage', desc: 'Test coverage' },
+          { name: '.nyc_output', desc: 'NYC coverage' },
+          { name: '.eslintcache', desc: 'ESLint cache', isFile: true },
+          { name: '.stylelintcache', desc: 'Stylelint cache', isFile: true },
+          { name: 'tsconfig.tsbuildinfo', desc: 'TypeScript incremental', isFile: true },
+        ];
+        
+        const found = [];
+        let totalSizeBytes = 0;
+        
+        for (const cache of cacheDirs) {
+          const cachePath = path.join(projectPath, cache.name);
+          if (fs.existsSync(cachePath)) {
+            try {
+              const stat = fs.statSync(cachePath);
+              found.push({
+                ...cache,
+                path: cachePath,
+                sizeBytes: stat.isDirectory() ? getDirectorySize(cachePath) : stat.size,
+              });
+              totalSizeBytes += found[found.length - 1].sizeBytes;
+            } catch {
+              found.push({ ...cache, path: cachePath, sizeBytes: 0 });
+            }
+          }
+        }
+        
+        const totalSizeMB = (totalSizeBytes / (1024 * 1024)).toFixed(1);
+        const metadata = { caches: found, totalSizeBytes, totalSizeMB };
+        
+        if (found.length === 0) {
+          return {
+            severity: SEVERITY.PASS,
+            message: 'No cache directories',
+            metadata,
+          };
+        }
+        
+        // Warn if caches are very large (> 500MB)
+        if (totalSizeBytes > 500 * 1024 * 1024) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: `${found.length} caches (${totalSizeMB}MB) — consider clearing`,
+            metadata,
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Clear all caches',
+              command: found.map(c => c.isFile ? `rm -f "${c.name}"` : `rm -rf "${c.name}"`).join(' && '),
+              autoFixable: false,
+              dangerous: true,
+            }],
+          };
+        }
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: `${found.length} caches (${totalSizeMB}MB)`,
+          metadata,
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.gitignore`,
+      name: '.gitignore Coverage',
+      category: CATEGORY.PROJECT,
+      parallel: true,
+      check: async () => {
+        const gitignorePath = path.join(projectPath, '.gitignore');
+        
+        if (!fs.existsSync(gitignorePath)) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: 'No .gitignore file',
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Create .gitignore from template',
+              command: 'npx gitignore node',
+              autoFixable: true,
+            }],
+          };
+        }
+        
+        try {
+          const content = fs.readFileSync(gitignorePath, 'utf8');
+          const lines = content.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#'));
+          
+          const essentialPatterns = [
+            { pattern: 'node_modules', desc: 'node_modules directory' },
+            { pattern: '.env', desc: 'Environment files' },
+            { pattern: 'dist', desc: 'Build output' },
+            { pattern: '.next', desc: 'Next.js cache' },
+            { pattern: 'coverage', desc: 'Test coverage' },
+          ];
+          
+          const missing = [];
+          for (const essential of essentialPatterns) {
+            const hasPattern = lines.some(l => 
+              l === essential.pattern || 
+              l.startsWith(essential.pattern + '/') ||
+              l === '/' + essential.pattern ||
+              l.includes(essential.pattern)
+            );
+            if (!hasPattern) {
+              missing.push(essential);
+            }
+          }
+          
+          const metadata = { lineCount: lines.length, missing: missing.map(m => m.pattern) };
+          
+          if (missing.length > 0) {
+            return {
+              severity: SEVERITY.WARNING,
+              message: `Missing: ${missing.map(m => m.pattern).join(', ')}`,
+              detail: `Consider adding these patterns to .gitignore`,
+              metadata,
+              fixes: [{
+                type: FIX_TYPE.MANUAL,
+                description: `Add missing patterns to .gitignore: ${missing.map(m => m.pattern).join(', ')}`,
+                autoFixable: false,
+              }],
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: `${lines.length} patterns`,
+            metadata,
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: 'Could not parse .gitignore',
+            detail: err.message,
+          };
+        }
+      },
+    },
+  ];
+}
+
+// Helper to get directory size
+function getDirectorySize(dirPath) {
+  let size = 0;
+  try {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryPath = path.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        size += getDirectorySize(entryPath);
+      } else {
+        try {
+          size += fs.statSync(entryPath).size;
+        } catch {}
+      }
+    }
+  } catch {}
+  return size;
+}
+
+module.exports = { MODULE_ID, createDiagnostics };

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

@@ -0,0 +1,224 @@
+/**
+ * Runtime Diagnostics Module
+ * 
+ * Checks Node.js, npm, package managers, and runtime environment
+ */
+
+const { execSync } = require('child_process');
+const { SEVERITY, CATEGORY, FIX_TYPE } = require('../types');
+
+const MODULE_ID = 'runtime';
+
+function createDiagnostics(projectPath) {
+  return [
+    {
+      id: `${MODULE_ID}.node_version`,
+      name: 'Node.js Version',
+      category: CATEGORY.RUNTIME,
+      parallel: true,
+      check: async () => {
+        const version = process.version;
+        const major = parseInt(version.slice(1).split('.')[0]);
+        const minor = parseInt(version.split('.')[1]);
+        
+        const metadata = { version, major, minor };
+        
+        if (major < 18) {
+          return {
+            severity: SEVERITY.ERROR,
+            message: `${version} — requires Node 18+`,
+            detail: 'vibecheck uses modern JavaScript features that require Node 18+',
+            metadata,
+            fixes: [
+              {
+                type: FIX_TYPE.COMMAND,
+                description: 'Install Node 20 via nvm',
+                command: 'nvm install 20 && nvm use 20',
+                autoFixable: false,
+              },
+              {
+                type: FIX_TYPE.LINK,
+                description: 'Download Node.js',
+                url: 'https://nodejs.org/',
+              },
+            ],
+          };
+        }
+        
+        if (major < 20) {
+          return {
+            severity: SEVERITY.WARNING,
+            message: `${version} — recommend Node 20+`,
+            detail: 'Node 20+ has better performance and LTS support',
+            metadata,
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Upgrade to Node 20',
+              command: 'nvm install 20 && nvm use 20',
+              autoFixable: false,
+            }],
+          };
+        }
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: version,
+          metadata,
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.npm_version`,
+      name: 'npm Version',
+      category: CATEGORY.RUNTIME,
+      parallel: true,
+      check: async () => {
+        try {
+          const version = execSync('npm --version', { 
+            encoding: 'utf8',
+            timeout: 10000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+          }).trim();
+          
+          const major = parseInt(version.split('.')[0]);
+          const metadata = { version, major };
+          
+          if (major < 8) {
+            return {
+              severity: SEVERITY.WARNING,
+              message: `${version} — recommend npm 9+`,
+              metadata,
+              fixes: [{
+                type: FIX_TYPE.COMMAND,
+                description: 'Update npm',
+                command: 'npm install -g npm@latest',
+                autoFixable: true,
+              }],
+            };
+          }
+          
+          return {
+            severity: SEVERITY.PASS,
+            message: version,
+            metadata,
+          };
+        } catch (err) {
+          return {
+            severity: SEVERITY.ERROR,
+            message: 'npm not found',
+            detail: err.message,
+            fixes: [{
+              type: FIX_TYPE.LINK,
+              description: 'Install Node.js (includes npm)',
+              url: 'https://nodejs.org/',
+            }],
+          };
+        }
+      },
+    },
+    {
+      id: `${MODULE_ID}.package_manager`,
+      name: 'Package Manager',
+      category: CATEGORY.RUNTIME,
+      parallel: true,
+      check: async () => {
+        const managers = [
+          { name: 'pnpm', preferred: true },
+          { name: 'yarn', preferred: false },
+          { name: 'npm', preferred: false },
+        ];
+        
+        const detected = [];
+        
+        for (const mgr of managers) {
+          try {
+            const version = execSync(`${mgr.name} --version`, {
+              encoding: 'utf8',
+              timeout: 5000,
+              stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+            detected.push({ ...mgr, version });
+          } catch {
+            // Not installed
+          }
+        }
+        
+        if (detected.length === 0) {
+          return {
+            severity: SEVERITY.ERROR,
+            message: 'No package manager found',
+            fixes: [{
+              type: FIX_TYPE.COMMAND,
+              description: 'Install pnpm (recommended)',
+              command: 'npm install -g pnpm',
+              autoFixable: true,
+            }],
+          };
+        }
+        
+        const primary = detected[0];
+        const metadata = { detected, primary: primary.name };
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: `${primary.name} ${primary.version}${detected.length > 1 ? ` (+${detected.length - 1} more)` : ''}`,
+          metadata,
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.node_env`,
+      name: 'NODE_ENV',
+      category: CATEGORY.RUNTIME,
+      parallel: true,
+      check: async () => {
+        const nodeEnv = process.env.NODE_ENV;
+        const metadata = { nodeEnv };
+        
+        if (!nodeEnv) {
+          return {
+            severity: SEVERITY.INFO,
+            message: 'Not set (defaults to development)',
+            metadata,
+          };
+        }
+        
+        if (nodeEnv === 'production') {
+          return {
+            severity: SEVERITY.WARNING,
+            message: 'production — may affect diagnostic behavior',
+            detail: 'Some checks behave differently in production mode',
+            metadata,
+          };
+        }
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: nodeEnv,
+          metadata,
+        };
+      },
+    },
+    {
+      id: `${MODULE_ID}.path_env`,
+      name: 'PATH Configuration',
+      category: CATEGORY.RUNTIME,
+      parallel: true,
+      check: async () => {
+        const pathEnv = process.env.PATH || process.env.Path || '';
+        const paths = pathEnv.split(process.platform === 'win32' ? ';' : ':');
+        
+        const hasNodeModulesBin = paths.some(p => p.includes('node_modules/.bin') || p.includes('node_modules\\.bin'));
+        const metadata = { pathCount: paths.length, hasNodeModulesBin };
+        
+        return {
+          severity: SEVERITY.PASS,
+          message: `${paths.length} paths configured`,
+          metadata,
+        };
+      },
+    },
+  ];
+}
+
+module.exports = { MODULE_ID, createDiagnostics };