@vibecheckai/cli 3.0.2 → 3.0.3

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

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

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