@vibecheckai/cli 2.8.2 → 3.0.0

package/bin/runners/lib/doctor-v2.js

@@ -0,0 +1,608 @@
+/**
+ * Doctor V2 — Enhanced Environment Diagnostics
+ * 
+ * Beautiful, comprehensive environment checks with:
+ * - Animated progress indicators
+ * - Detailed system info
+ * - Auto-fix suggestions with commands
+ * - Health score
+ * - Category-based organization
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+
+// Import CLI UI utilities
+let cliUI;
+try {
+  cliUI = require('./cli-ui');
+} catch {
+  // Fallback colors
+  cliUI = {
+    c: {
+      reset: '\x1b[0m',
+      bold: '\x1b[1m',
+      dim: '\x1b[2m',
+      red: '\x1b[31m',
+      green: '\x1b[32m',
+      yellow: '\x1b[33m',
+      blue: '\x1b[34m',
+      cyan: '\x1b[36m',
+      magenta: '\x1b[35m',
+    }
+  };
+}
+
+const c = cliUI.c || cliUI.colors || {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
+};
+
+// Check categories
+const CATEGORIES = {
+  SYSTEM: { name: 'System', icon: '💻', color: c.blue },
+  NODE: { name: 'Node.js', icon: '🟢', color: c.green },
+  PROJECT: { name: 'Project', icon: '📁', color: c.cyan },
+  SECURITY: { name: 'Security', icon: '🔐', color: c.magenta },
+  TOOLS: { name: 'Tools', icon: '🔧', color: c.yellow },
+  VIBECHECK: { name: 'Vibecheck', icon: '⚡', color: c.cyan },
+};
+
+class DoctorV2 {
+  constructor(projectPath, options = {}) {
+    this.projectPath = projectPath;
+    this.options = options;
+    this.checks = [];
+    this.startTime = Date.now();
+  }
+
+  async diagnose() {
+    this.printHeader();
+    
+    // Run all checks with progress
+    await this.runChecks();
+    
+    // Print results
+    this.printResults();
+    
+    // Print summary
+    this.printSummary();
+    
+    // Return exit code based on errors
+    const errors = this.checks.filter(c => c.status === 'error');
+    return errors.length > 0 ? 1 : 0;
+  }
+
+  printHeader() {
+    console.log('');
+    console.log(`${c.cyan}╔══════════════════════════════════════════════════════════════════════╗${c.reset}`);
+    console.log(`${c.cyan}║${c.reset}                                                                      ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}║${c.reset}   ${c.bold}🩺 VIBECHECK DOCTOR${c.reset}                                              ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}║${c.reset}   ${c.dim}Comprehensive Environment Diagnostics${c.reset}                            ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}║${c.reset}                                                                      ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}╚══════════════════════════════════════════════════════════════════════╝${c.reset}`);
+    console.log('');
+  }
+
+  async runChecks() {
+    const checkGroups = [
+      { category: CATEGORIES.SYSTEM, checks: this.getSystemChecks() },
+      { category: CATEGORIES.NODE, checks: this.getNodeChecks() },
+      { category: CATEGORIES.PROJECT, checks: this.getProjectChecks() },
+      { category: CATEGORIES.TOOLS, checks: this.getToolsChecks() },
+      { category: CATEGORIES.SECURITY, checks: this.getSecurityChecks() },
+      { category: CATEGORIES.VIBECHECK, checks: this.getVibecheckChecks() },
+    ];
+
+    for (const group of checkGroups) {
+      console.log(`${group.category.color}${group.category.icon} ${c.bold}${group.category.name}${c.reset}`);
+      console.log(`${c.dim}${'─'.repeat(50)}${c.reset}`);
+      
+      for (const check of group.checks) {
+        process.stdout.write(`   ${c.dim}○${c.reset} ${check.name}...`);
+        
+        try {
+          const result = await check.fn();
+          this.checks.push({
+            category: group.category.name,
+            name: check.name,
+            ...result,
+          });
+          
+          this.printCheckResult(result);
+        } catch (err) {
+          const result = {
+            status: 'error',
+            message: err.message,
+            fix: check.defaultFix,
+          };
+          this.checks.push({
+            category: group.category.name,
+            name: check.name,
+            ...result,
+          });
+          this.printCheckResult(result);
+        }
+      }
+      console.log('');
+    }
+  }
+
+  printCheckResult(result) {
+    const icons = {
+      pass: `${c.green}✓${c.reset}`,
+      warning: `${c.yellow}!${c.reset}`,
+      error: `${c.red}✗${c.reset}`,
+      info: `${c.blue}ℹ${c.reset}`,
+    };
+    
+    const colors = {
+      pass: c.green,
+      warning: c.yellow,
+      error: c.red,
+      info: c.blue,
+    };
+    
+    // Clear the line and print result
+    process.stdout.write('\r');
+    process.stdout.write(' '.repeat(60) + '\r');
+    
+    const icon = icons[result.status] || icons.info;
+    const color = colors[result.status] || c.dim;
+    
+    console.log(`   ${icon} ${result.message || 'OK'}${color}${c.reset}`);
+    
+    if (result.detail) {
+      console.log(`      ${c.dim}${result.detail}${c.reset}`);
+    }
+  }
+
+  printResults() {
+    const errors = this.checks.filter(c => c.status === 'error');
+    const warnings = this.checks.filter(c => c.status === 'warning');
+    
+    if (errors.length === 0 && warnings.length === 0) {
+      return;
+    }
+
+    console.log(`${c.cyan}╔══════════════════════════════════════════════════════════════════════╗${c.reset}`);
+    console.log(`${c.cyan}║${c.reset} ${c.bold}ISSUES FOUND${c.reset}                                                         ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}╚══════════════════════════════════════════════════════════════════════╝${c.reset}`);
+    console.log('');
+
+    if (errors.length > 0) {
+      console.log(`${c.red}${c.bold}❌ ERRORS (${errors.length})${c.reset} — Must fix before using vibecheck\n`);
+      
+      for (const check of errors) {
+        console.log(`   ${c.red}●${c.reset} ${c.bold}${check.name}${c.reset}`);
+        console.log(`     ${c.dim}${check.message}${c.reset}`);
+        if (check.fix) {
+          console.log(`     ${c.cyan}→ ${check.fix}${c.reset}`);
+        }
+        console.log('');
+      }
+    }
+
+    if (warnings.length > 0) {
+      console.log(`${c.yellow}${c.bold}⚠️  WARNINGS (${warnings.length})${c.reset} — Recommended fixes\n`);
+      
+      for (const check of warnings) {
+        console.log(`   ${c.yellow}●${c.reset} ${c.bold}${check.name}${c.reset}`);
+        console.log(`     ${c.dim}${check.message}${c.reset}`);
+        if (check.fix) {
+          console.log(`     ${c.cyan}→ ${check.fix}${c.reset}`);
+        }
+        console.log('');
+      }
+    }
+  }
+
+  printSummary() {
+    const passed = this.checks.filter(c => c.status === 'pass').length;
+    const warnings = this.checks.filter(c => c.status === 'warning').length;
+    const errors = this.checks.filter(c => c.status === 'error').length;
+    const total = this.checks.length;
+    
+    const healthScore = Math.round(((passed + warnings * 0.5) / total) * 100);
+    const duration = ((Date.now() - this.startTime) / 1000).toFixed(1);
+    
+    const healthColor = healthScore >= 80 ? c.green : healthScore >= 60 ? c.yellow : c.red;
+    const healthIcon = healthScore >= 80 ? '💚' : healthScore >= 60 ? '💛' : '❤️';
+    
+    console.log(`${c.cyan}╔══════════════════════════════════════════════════════════════════════╗${c.reset}`);
+    console.log(`${c.cyan}║${c.reset}                                                                      ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}║${c.reset}   ${healthIcon} ${c.bold}Health Score: ${healthColor}${healthScore}%${c.reset}                                         ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}║${c.reset}                                                                      ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}║${c.reset}   ${c.green}✓ ${passed} passed${c.reset}  ${c.yellow}! ${warnings} warnings${c.reset}  ${c.red}✗ ${errors} errors${c.reset}                      ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}║${c.reset}   ${c.dim}Completed in ${duration}s${c.reset}                                              ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}║${c.reset}                                                                      ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}╚══════════════════════════════════════════════════════════════════════╝${c.reset}`);
+    console.log('');
+    
+    if (errors.length > 0) {
+      console.log(`${c.red}${c.bold}⚠ Fix the errors above before running vibecheck.${c.reset}\n`);
+    } else if (warnings.length > 0) {
+      console.log(`${c.yellow}Your environment is ready, but consider fixing the warnings.${c.reset}\n`);
+    } else {
+      console.log(`${c.green}${c.bold}✓ Your environment is perfectly configured!${c.reset}\n`);
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // CHECK DEFINITIONS
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  getSystemChecks() {
+    return [
+      {
+        name: 'Operating System',
+        fn: async () => {
+          const os = require('os');
+          const platform = os.platform();
+          const release = os.release();
+          const arch = os.arch();
+          return {
+            status: 'pass',
+            message: `${platform} ${release} (${arch})`,
+          };
+        },
+      },
+      {
+        name: 'Memory',
+        fn: async () => {
+          const os = require('os');
+          const totalGB = (os.totalmem() / 1024 / 1024 / 1024).toFixed(1);
+          const freeGB = (os.freemem() / 1024 / 1024 / 1024).toFixed(1);
+          const usedPercent = Math.round((1 - os.freemem() / os.totalmem()) * 100);
+          
+          if (freeGB < 0.5) {
+            return {
+              status: 'warning',
+              message: `Low memory: ${freeGB}GB free of ${totalGB}GB`,
+              fix: 'Close other applications to free memory',
+            };
+          }
+          return {
+            status: 'pass',
+            message: `${freeGB}GB free of ${totalGB}GB (${usedPercent}% used)`,
+          };
+        },
+      },
+      {
+        name: 'Disk Space',
+        fn: async () => {
+          // Simple check - just verify we can write
+          try {
+            const testPath = path.join(this.projectPath, '.vibecheck-test');
+            fs.writeFileSync(testPath, 'test');
+            fs.unlinkSync(testPath);
+            return { status: 'pass', message: 'Writable' };
+          } catch {
+            return {
+              status: 'error',
+              message: 'Cannot write to project directory',
+              fix: 'Check disk space and permissions',
+            };
+          }
+        },
+      },
+    ];
+  }
+
+  getNodeChecks() {
+    return [
+      {
+        name: 'Node.js Version',
+        fn: async () => {
+          const version = process.version;
+          const major = parseInt(version.slice(1).split('.')[0]);
+          
+          if (major < 18) {
+            return {
+              status: 'error',
+              message: `${version} (requires 18+)`,
+              fix: 'nvm install 20 && nvm use 20',
+            };
+          }
+          if (major < 20) {
+            return {
+              status: 'warning',
+              message: `${version} (recommend 20+)`,
+              fix: 'nvm install 20',
+            };
+          }
+          return { status: 'pass', message: version };
+        },
+      },
+      {
+        name: 'npm Version',
+        fn: async () => {
+          try {
+            const version = execSync('npm --version', { encoding: 'utf8' }).trim();
+            const major = parseInt(version.split('.')[0]);
+            if (major < 8) {
+              return {
+                status: 'warning',
+                message: `${version} (recommend 9+)`,
+                fix: 'npm install -g npm@latest',
+              };
+            }
+            return { status: 'pass', message: version };
+          } catch {
+            return {
+              status: 'error',
+              message: 'npm not found',
+              fix: 'Install Node.js from nodejs.org',
+            };
+          }
+        },
+      },
+      {
+        name: 'Package Manager',
+        fn: async () => {
+          const managers = ['pnpm', 'yarn', 'npm'];
+          for (const mgr of managers) {
+            try {
+              const version = execSync(`${mgr} --version`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+              return { status: 'pass', message: `${mgr} ${version}` };
+            } catch {}
+          }
+          return { status: 'error', message: 'No package manager found', fix: 'npm install -g pnpm' };
+        },
+      },
+    ];
+  }
+
+  getProjectChecks() {
+    return [
+      {
+        name: 'package.json',
+        fn: async () => {
+          const pkgPath = path.join(this.projectPath, 'package.json');
+          if (!fs.existsSync(pkgPath)) {
+            return {
+              status: 'error',
+              message: 'Not found',
+              fix: 'npm init -y',
+            };
+          }
+          try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            return { status: 'pass', message: `${pkg.name || 'unnamed'} v${pkg.version || '0.0.0'}` };
+          } catch {
+            return { status: 'error', message: 'Invalid JSON', fix: 'Fix package.json syntax' };
+          }
+        },
+      },
+      {
+        name: 'Dependencies Installed',
+        fn: async () => {
+          const nodeModules = path.join(this.projectPath, 'node_modules');
+          if (!fs.existsSync(nodeModules)) {
+            return {
+              status: 'warning',
+              message: 'node_modules not found',
+              fix: 'npm install',
+            };
+          }
+          try {
+            const count = fs.readdirSync(nodeModules).filter(f => !f.startsWith('.')).length;
+            return { status: 'pass', message: `${count} packages installed` };
+          } catch {
+            return { status: 'pass', message: 'Installed' };
+          }
+        },
+      },
+      {
+        name: 'TypeScript',
+        fn: async () => {
+          const tsConfig = path.join(this.projectPath, 'tsconfig.json');
+          if (fs.existsSync(tsConfig)) {
+            return { status: 'pass', message: 'Configured' };
+          }
+          return { status: 'info', message: 'Not configured (JavaScript project)' };
+        },
+      },
+      {
+        name: 'Source Directory',
+        fn: async () => {
+          const dirs = ['src', 'app', 'pages', 'lib'];
+          for (const dir of dirs) {
+            if (fs.existsSync(path.join(this.projectPath, dir))) {
+              return { status: 'pass', message: `${dir}/` };
+            }
+          }
+          return { status: 'info', message: 'No standard source directory' };
+        },
+      },
+    ];
+  }
+
+  getToolsChecks() {
+    return [
+      {
+        name: 'Git',
+        fn: async () => {
+          try {
+            const version = execSync('git --version', { encoding: 'utf8' }).trim();
+            return { status: 'pass', message: version.replace('git version ', '') };
+          } catch {
+            return {
+              status: 'error',
+              message: 'Not installed',
+              fix: 'Install git from git-scm.com',
+            };
+          }
+        },
+      },
+      {
+        name: 'Git Repository',
+        fn: async () => {
+          const gitDir = path.join(this.projectPath, '.git');
+          if (fs.existsSync(gitDir)) {
+            try {
+              const branch = execSync('git branch --show-current', { cwd: this.projectPath, encoding: 'utf8' }).trim();
+              return { status: 'pass', message: `Branch: ${branch || 'detached'}` };
+            } catch {
+              return { status: 'pass', message: 'Initialized' };
+            }
+          }
+          return {
+            status: 'warning',
+            message: 'Not a git repository',
+            fix: 'git init',
+          };
+        },
+      },
+      {
+        name: 'Playwright',
+        fn: async () => {
+          try {
+            execSync('npx playwright --version', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
+            return { status: 'pass', message: 'Available for runtime verification' };
+          } catch {
+            return {
+              status: 'info',
+              message: 'Not installed (optional)',
+              detail: 'Enables runtime verification with `vibecheck verify`',
+              fix: 'npx playwright install',
+            };
+          }
+        },
+      },
+    ];
+  }
+
+  getSecurityChecks() {
+    return [
+      {
+        name: '.env File',
+        fn: async () => {
+          const envPath = path.join(this.projectPath, '.env');
+          if (!fs.existsSync(envPath)) {
+            return {
+              status: 'info',
+              message: 'Not found',
+              detail: 'Create .env for local secrets',
+            };
+          }
+          return { status: 'pass', message: 'Found' };
+        },
+      },
+      {
+        name: '.gitignore',
+        fn: async () => {
+          const gitignorePath = path.join(this.projectPath, '.gitignore');
+          if (!fs.existsSync(gitignorePath)) {
+            return {
+              status: 'warning',
+              message: 'Not found',
+              fix: 'Create .gitignore with node_modules, .env, etc.',
+            };
+          }
+          const content = fs.readFileSync(gitignorePath, 'utf8');
+          const hasEnv = content.includes('.env');
+          const hasNodeModules = content.includes('node_modules');
+          
+          if (!hasEnv) {
+            return {
+              status: 'warning',
+              message: '.env not in .gitignore',
+              fix: 'Add .env to .gitignore',
+            };
+          }
+          return { status: 'pass', message: 'Properly configured' };
+        },
+      },
+      {
+        name: 'Exposed Secrets',
+        fn: async () => {
+          // Quick check for common secret patterns in key files
+          const patterns = [
+            /sk_live_[a-zA-Z0-9]{20,}/,
+            /sk_test_[a-zA-Z0-9]{20,}/,
+            /AKIA[0-9A-Z]{16}/,
+            /ghp_[a-zA-Z0-9]{36}/,
+          ];
+          
+          const filesToCheck = ['package.json', 'src/config.ts', 'src/config.js'];
+          for (const file of filesToCheck) {
+            const filePath = path.join(this.projectPath, file);
+            if (fs.existsSync(filePath)) {
+              const content = fs.readFileSync(filePath, 'utf8');
+              for (const pattern of patterns) {
+                if (pattern.test(content)) {
+                  return {
+                    status: 'error',
+                    message: `Potential secret in ${file}`,
+                    fix: 'Move secrets to .env file',
+                  };
+                }
+              }
+            }
+          }
+          return { status: 'pass', message: 'No exposed secrets found' };
+        },
+      },
+    ];
+  }
+
+  getVibecheckChecks() {
+    return [
+      {
+        name: 'Config File',
+        fn: async () => {
+          const configPaths = ['.vibecheckrc', '.vibecheck.json', 'vibecheck.config.js'];
+          for (const configPath of configPaths) {
+            if (fs.existsSync(path.join(this.projectPath, configPath))) {
+              return { status: 'pass', message: configPath };
+            }
+          }
+          return {
+            status: 'info',
+            message: 'Using defaults',
+            detail: 'Run vibecheck init to create config',
+          };
+        },
+      },
+      {
+        name: 'Output Directory',
+        fn: async () => {
+          const outputDir = path.join(this.projectPath, '.vibecheck');
+          if (fs.existsSync(outputDir)) {
+            try {
+              const files = fs.readdirSync(outputDir);
+              return { status: 'pass', message: `${files.length} files` };
+            } catch {
+              return { status: 'pass', message: 'Exists' };
+            }
+          }
+          return { status: 'info', message: 'Will be created on first scan' };
+        },
+      },
+      {
+        name: 'API Key',
+        fn: async () => {
+          if (process.env.VIBECHECK_API_KEY) {
+            return { status: 'pass', message: 'Configured' };
+          }
+          return {
+            status: 'info',
+            message: 'Not set (offline mode)',
+            detail: 'Set VIBECHECK_API_KEY for cloud features',
+          };
+        },
+      },
+    ];
+  }
+}
+
+module.exports = { DoctorV2 };

package/bin/runners/lib/enforcement.js

@@ -0,0 +1,72 @@
+// bin/runners/lib/enforcement.js
+const fs = require("fs");
+const path = require("path");
+
+const ENFORCE_HINTS = [
+  "enforceFeature",
+  "enforceLimit",
+  "getEntitlements",
+  "requirePlan",
+  "requireTier",
+  "requireSubscription",
+  "checkAccess",
+  "entitlements",
+  "plan",
+  "tier",
+  "subscription",
+  "stripe",
+  "credits"
+];
+
+function looksPaidSurface(routePath) {
+  const p = String(routePath || "");
+  return (
+    p.includes("/api/ship") ||
+    p.includes("/api/verdict") ||
+    p.includes("/api/fix") ||
+    p.includes("/api/autopilot") ||
+    p.includes("/api/missions") ||
+    p.includes("/api/pr") ||
+    p.includes("/api/credits") ||
+    p.includes("/api/billing") ||
+    p.includes("/api/stripe") ||
+    p.includes("/api/entitlements")
+  );
+}
+
+function handlerHasEnforcementSignal(repoRoot, handlerRel) {
+  const abs = path.join(repoRoot, handlerRel);
+  if (!fs.existsSync(abs)) return { ok: false, hits: [] };
+
+  const code = fs.readFileSync(abs, "utf8");
+  const hits = ENFORCE_HINTS.filter(k => code.includes(k));
+  return { ok: hits.length > 0, hits };
+}
+
+function buildEnforcementTruth(repoRoot, serverRoutes) {
+  const checked = [];
+  const routeList = serverRoutes || [];
+
+  for (const r of routeList) {
+    if (!r.handler) continue;
+    if (!looksPaidSurface(r.path)) continue;
+
+    const res = handlerHasEnforcementSignal(repoRoot, r.handler);
+    checked.push({
+      method: r.method,
+      path: r.path,
+      handler: r.handler,
+      enforced: res.ok,
+      hits: res.hits
+    });
+  }
+
+  return {
+    checkedCount: checked.length,
+    enforcedCount: checked.filter(x => x.enforced).length,
+    missingCount: checked.filter(x => !x.enforced).length,
+    checks: checked
+  };
+}
+
+module.exports = { buildEnforcementTruth };