@vibecheckai/cli 2.8.2 → 3.0.0

package/bin/runners/runCtxGuard.js

@@ -0,0 +1,176 @@
+/**
+ * vibecheck ctx guard - Context Contracts Guard
+ * 
+ * CI gate that validates code against contracts.
+ * Blocks if:
+ * - New route usage not declared
+ * - Env var used not declared
+ * - Protected matcher changes without proof
+ * - Webhook without verification
+ */
+
+"use strict";
+
+const path = require("path");
+const fs = require("fs");
+const { buildTruthpack, loadTruthpack } = require("./lib/truth");
+const { 
+  loadContracts, 
+  guardContracts,
+  getGuardSummary,
+  formatGuardResult
+} = require("./lib/contracts");
+
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+  blue: '\x1b[34m',
+};
+
+async function runCtxGuard(opts = {}) {
+  const root = path.resolve(opts.repoRoot || process.cwd());
+
+  console.log(`\n${c.cyan}${c.bold}🛡️ vibecheck ctx guard${c.reset}`);
+  console.log(`${c.dim}Validating code against contracts...${c.reset}\n`);
+
+  // Load contracts
+  const contracts = loadContracts(root);
+  
+  if (Object.keys(contracts).length === 0) {
+    console.log(`${c.yellow}⚠️ No contracts found${c.reset}`);
+    console.log(`${c.dim}Run 'vibecheck ctx sync' first to generate contracts${c.reset}\n`);
+    return opts.failOnMissing ? 2 : 0;
+  }
+
+  // Load or build truthpack
+  let truthpack = loadTruthpack(root);
+  if (!truthpack) {
+    console.log(`${c.dim}Building truthpack...${c.reset}`);
+    truthpack = await buildTruthpack({ repoRoot: root, fastifyEntry: opts.fastifyEntry });
+  }
+
+  // Run guard validation
+  const guardResult = guardContracts(contracts, truthpack, {
+    realityResults: opts.realityResults
+  });
+
+  const summary = getGuardSummary(guardResult);
+
+  // Print results
+  console.log(`${c.bold}Contracts Loaded:${c.reset}`);
+  if (contracts.routes) console.log(`  ✓ routes.json (${contracts.routes.routes?.length || 0} routes)`);
+  if (contracts.env) console.log(`  ✓ env.json (${contracts.env.vars?.length || 0} vars)`);
+  if (contracts.auth) console.log(`  ✓ auth.json (${contracts.auth.protectedPatterns?.length || 0} patterns)`);
+  if (contracts.external) console.log(`  ✓ external.json (${contracts.external.services?.length || 0} services)`);
+
+  console.log("");
+  console.log(formatGuardResult(guardResult));
+
+  // Print verdict
+  console.log("");
+  if (summary.verdict === "PASS") {
+    console.log(`${c.green}✅ PASS${c.reset} - All contracts satisfied`);
+  } else if (summary.verdict === "WARN") {
+    console.log(`${c.yellow}⚠️ WARN${c.reset} - ${summary.summary.warns} warnings`);
+  } else {
+    console.log(`${c.red}🛑 BLOCK${c.reset} - ${summary.summary.blocks} violations`);
+  }
+
+  // JSON output for CI
+  if (opts.json) {
+    const jsonPath = path.join(root, ".vibecheck", "guard-result.json");
+    fs.mkdirSync(path.dirname(jsonPath), { recursive: true });
+    fs.writeFileSync(jsonPath, JSON.stringify(summary, null, 2), "utf8");
+    console.log(`\n${c.dim}JSON output: .vibecheck/guard-result.json${c.reset}`);
+  }
+
+  console.log("");
+
+  // Return appropriate exit code
+  if (opts.failOnWarn && summary.verdict === "WARN") {
+    return 1;
+  }
+  
+  return summary.exitCode;
+}
+
+function parseArgs(args) {
+  const opts = {
+    repoRoot: process.cwd(),
+    fastifyEntry: null,
+    json: false,
+    failOnWarn: false,
+    failOnMissing: false,
+    help: false
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--json") opts.json = true;
+    else if (arg === "--fail-on-warn") opts.failOnWarn = true;
+    else if (arg === "--fail-on-missing") opts.failOnMissing = true;
+    else if (arg === "--fastify-entry") opts.fastifyEntry = args[++i];
+    else if (arg === "--path" || arg === "-p") opts.repoRoot = args[++i];
+    else if (arg === "--help" || arg === "-h") opts.help = true;
+  }
+
+  return opts;
+}
+
+function printHelp() {
+  console.log(`
+${c.cyan}${c.bold}🛡️ vibecheck ctx guard${c.reset} - Contract Guard (CI Gate)
+
+Validates current code against contracts. Use in CI to block drift.
+
+${c.bold}USAGE${c.reset}
+  vibecheck ctx guard                 ${c.dim}# Validate against contracts${c.reset}
+  vibecheck ctx guard --json          ${c.dim}# Output JSON for CI${c.reset}
+  vibecheck ctx guard --fail-on-warn  ${c.dim}# Exit 1 on warnings${c.reset}
+
+${c.bold}OPTIONS${c.reset}
+  --json              Output JSON result to .vibecheck/guard-result.json
+  --fail-on-warn      Exit 1 on warnings (default: only blocks)
+  --fail-on-missing   Exit 2 if no contracts exist
+  --fastify-entry     Fastify entry file (e.g. src/server.ts)
+  --path, -p          Project path (default: current directory)
+  --help, -h          Show this help
+
+${c.bold}VIOLATIONS (BLOCK)${c.reset}
+  • Route used in code but not in routes.json
+  • Webhook without signature verification
+  • Protected route accessible anonymously
+
+${c.bold}WARNINGS${c.reset}
+  • Env var used but not in env.json
+  • Required env var not used
+  • Undeclared external service
+
+${c.bold}EXIT CODES${c.reset}
+  0 = PASS (or WARN without --fail-on-warn)
+  1 = WARN (with --fail-on-warn)
+  2 = BLOCK
+
+${c.bold}EXAMPLES${c.reset}
+  vibecheck ctx guard                           ${c.dim}# Local validation${c.reset}
+  vibecheck ctx guard --json --fail-on-warn     ${c.dim}# CI mode${c.reset}
+`);
+}
+
+async function main(args) {
+  const opts = parseArgs(args);
+  
+  if (opts.help) {
+    printHelp();
+    return 0;
+  }
+
+  return runCtxGuard(opts);
+}
+
+module.exports = { runCtxGuard, main };

package/bin/runners/runCtxSync.js

@@ -0,0 +1,116 @@
+/**
+ * vibecheck ctx sync - Context Contracts Sync
+ * 
+ * Generates/updates contracts from truthpack:
+ * - routes.json
+ * - env.json
+ * - auth.json
+ * - external.json
+ */
+
+"use strict";
+
+const path = require("path");
+const fs = require("fs");
+const { buildTruthpack, loadTruthpack } = require("./lib/truth");
+const { 
+  buildAllContracts, 
+  loadContracts, 
+  saveContracts,
+  diffAllContracts,
+  hasContractChanges
+} = require("./lib/contracts");
+
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+  blue: '\x1b[34m',
+};
+
+async function runCtxSync(opts = {}) {
+  const root = path.resolve(opts.repoRoot || process.cwd());
+  const contractDir = path.join(root, ".vibecheck", "contracts");
+
+  console.log(`\n${c.cyan}${c.bold}📜 vibecheck ctx sync${c.reset}`);
+  console.log(`${c.dim}Syncing contracts from truthpack...${c.reset}\n`);
+
+  // Load or build truthpack
+  let truthpack = loadTruthpack(root);
+  if (!truthpack) {
+    console.log(`${c.dim}Building truthpack...${c.reset}`);
+    truthpack = await buildTruthpack({ repoRoot: root, fastifyEntry: opts.fastifyEntry });
+  }
+
+  // Load existing contracts for diff
+  const existingContracts = loadContracts(root);
+  const hasExisting = Object.keys(existingContracts).length > 0;
+
+  // Build new contracts
+  const newContracts = buildAllContracts(truthpack);
+
+  // Calculate diff
+  let diff = null;
+  if (hasExisting) {
+    diff = diffAllContracts(existingContracts, newContracts);
+  }
+
+  // Save contracts
+  saveContracts(root, newContracts);
+
+  // Print summary
+  console.log(`${c.bold}Contracts saved to:${c.reset} .vibecheck/contracts/\n`);
+
+  console.log(`${c.bold}Routes Contract${c.reset}`);
+  console.log(`  Routes: ${newContracts.routes.routes.length}`);
+  if (diff?.routes) {
+    if (diff.routes.added?.length) console.log(`  ${c.green}+${diff.routes.added.length} added${c.reset}`);
+    if (diff.routes.removed?.length) console.log(`  ${c.red}-${diff.routes.removed.length} removed${c.reset}`);
+  }
+
+  console.log(`\n${c.bold}Env Contract${c.reset}`);
+  console.log(`  Variables: ${newContracts.env.vars.length}`);
+  const required = newContracts.env.vars.filter(v => v.required).length;
+  console.log(`  Required: ${required}`);
+  if (diff?.env) {
+    if (diff.env.added?.length) console.log(`  ${c.green}+${diff.env.added.length} added${c.reset}`);
+    if (diff.env.removed?.length) console.log(`  ${c.red}-${diff.env.removed.length} removed${c.reset}`);
+  }
+
+  console.log(`\n${c.bold}Auth Contract${c.reset}`);
+  console.log(`  Protected patterns: ${newContracts.auth.protectedPatterns.length}`);
+  console.log(`  Roles: ${newContracts.auth.roles.length}`);
+  if (diff?.auth) {
+    if (diff.auth.protectedAdded?.length) console.log(`  ${c.green}+${diff.auth.protectedAdded.length} patterns added${c.reset}`);
+    if (diff.auth.protectedRemoved?.length) console.log(`  ${c.red}-${diff.auth.protectedRemoved.length} patterns removed${c.reset}`);
+  }
+
+  console.log(`\n${c.bold}External Contract${c.reset}`);
+  console.log(`  Services: ${newContracts.external.services.length}`);
+  for (const svc of newContracts.external.services) {
+    console.log(`    - ${svc.name} (${svc.envVars.length} env vars)`);
+  }
+
+  // Print files created
+  console.log(`\n${c.bold}Files:${c.reset}`);
+  console.log(`  ${c.dim}routes.json${c.reset}   Route definitions + auth requirements`);
+  console.log(`  ${c.dim}env.json${c.reset}      Environment variable contract`);
+  console.log(`  ${c.dim}auth.json${c.reset}     Authentication patterns + roles`);
+  console.log(`  ${c.dim}external.json${c.reset} External service integrations`);
+
+  if (hasExisting && hasContractChanges(diff)) {
+    console.log(`\n${c.yellow}⚠️ Contracts changed since last sync${c.reset}`);
+    console.log(`${c.dim}Run 'vibecheck ctx diff' to see detailed changes${c.reset}`);
+  }
+
+  console.log(`\n${c.green}✓${c.reset} Contracts synced successfully`);
+  console.log(`${c.dim}Run 'vibecheck ctx guard' to validate code against contracts${c.reset}\n`);
+
+  return 0;
+}
+
+module.exports = { runCtxSync };

package/bin/runners/runDashboard.js

@@ -0,0 +1,10 @@
+// Stub: runDashboard.js
+async function runDashboard(args) {
+  console.log("Dashboard command not yet implemented");
+  return 0;
+}
+async function runDemo(args) {
+  console.log("Demo command not yet implemented");
+  return 0;
+}
+module.exports = { runDashboard, runDemo };

package/bin/runners/runDoctor.js

@@ -0,0 +1,245 @@
+const fs = require("fs");
+const path = require("path");
+
+// Use Enterprise Doctor Service
+let DoctorService;
+try {
+  DoctorService = require("./lib/doctor").DoctorService;
+} catch {
+  // Fallback to legacy implementations
+  try {
+    DoctorService = require("./lib/doctor-v2").DoctorV2;
+  } catch {
+    DoctorService = require("./lib/doctor-enhanced").DoctorEnhanced;
+  }
+}
+
+async function runDoctor(args) {
+  const opts = parseArgs(args);
+  
+  if (opts.help) {
+    printHelp();
+    return 0;
+  }
+
+  const projectPath = path.resolve(opts.path || process.cwd());
+  
+  // Use new DoctorService if available
+  if (DoctorService.name === 'DoctorService') {
+    const doctor = new DoctorService(projectPath, {
+      json: opts.json,
+      fix: opts.fix,
+      fixDryRun: opts.dryRun,
+      quiet: opts.quiet,
+      verbose: opts.verbose,
+      categories: opts.categories,
+      skipNetwork: opts.skipNetwork,
+      saveReport: opts.saveReport,
+      failOnWarn: opts.failOnWarn,
+    });
+    return await doctor.run();
+  }
+  
+  // Legacy fallback
+  const doctor = new DoctorService(projectPath, opts);
+  return await doctor.diagnose();
+}
+
+function parseArgs(args) {
+  const opts = {
+    path: process.cwd(),
+    help: false,
+    json: false,
+    fix: false,
+    dryRun: false,
+    quiet: false,
+    verbose: false,
+    categories: null,
+    skipNetwork: false,
+    saveReport: true,
+    failOnWarn: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case '--help':
+      case '-h':
+        opts.help = true;
+        break;
+      case '--path':
+      case '-p':
+        opts.path = args[++i];
+        break;
+      case '--json':
+        opts.json = true;
+        break;
+      case '--fix':
+        opts.fix = true;
+        break;
+      case '--dry-run':
+        opts.dryRun = true;
+        break;
+      case '--quiet':
+      case '-q':
+        opts.quiet = true;
+        break;
+      case '--verbose':
+      case '-v':
+        opts.verbose = true;
+        break;
+      case '--category':
+      case '-c':
+        if (!opts.categories) opts.categories = [];
+        opts.categories.push(args[++i]);
+        break;
+      case '--skip-network':
+        opts.skipNetwork = true;
+        break;
+      case '--no-report':
+        opts.saveReport = false;
+        break;
+      case '--fail-on-warn':
+        opts.failOnWarn = true;
+        break;
+      default:
+        if (!arg.startsWith('-')) {
+          opts.path = path.resolve(arg);
+        }
+    }
+  }
+
+  return opts;
+}
+
+function printHelp() {
+  console.log(`
+${'\x1b[36m'}🩺 vibecheck doctor${'\x1b[0m'} — Enterprise Environment Diagnostics
+
+Comprehensive environment checks with auto-fix capability.
+
+${'\x1b[1m'}Usage:${'\x1b[0m'} vibecheck doctor [options] [path]
+
+${'\x1b[1m'}Options:${'\x1b[0m'}
+  --path, -p <path>     Project path (default: current directory)
+  --json                Output JSON report only
+  --fix                 Auto-fix issues when possible
+  --dry-run             Show what fixes would be applied
+  --quiet, -q           Minimal output
+  --verbose, -v         Show detailed output and fix commands
+  --category, -c <cat>  Run specific category (can repeat)
+  --skip-network        Skip network connectivity checks
+  --no-report           Don't save report files
+  --fail-on-warn        Exit code 2 for warnings (CI mode)
+  --help, -h            Show this help
+
+${'\x1b[1m'}Categories:${'\x1b[0m'}
+  system         OS, memory, disk, CPU
+  runtime        Node.js, npm, package managers
+  project        package.json, dependencies, TypeScript
+  dependencies   Outdated packages, vulnerabilities
+  security       Secrets, gitignore, env files
+  network        Internet, npm registry, API connectivity
+  vibecheck      Config, truth pack, scan status
+
+${'\x1b[1m'}Examples:${'\x1b[0m'}
+  vibecheck doctor                    # Full diagnostic
+  vibecheck doctor --json             # JSON output for CI
+  vibecheck doctor --fix              # Auto-fix issues
+  vibecheck doctor -c security        # Security checks only
+  vibecheck doctor --skip-network     # Skip slow network checks
+
+${'\x1b[1m'}Exit Codes:${'\x1b[0m'}
+  0 = Healthy (or warnings without --fail-on-warn)
+  1 = Errors found
+  2 = Warnings found (with --fail-on-warn)
+  3 = Critical issues found
+`);
+}
+
+// Legacy function for backwards compatibility
+function runDoctorLegacy() {
+  console.log("\n  🩺 vibecheck DOCTOR\n");
+
+  const checks = [];
+
+  // Node version
+  const nodeVersion = process.version;
+  const nodeMajor = parseInt(nodeVersion.slice(1).split(".")[0], 10);
+  checks.push({
+    name: "Node.js",
+    status: nodeMajor >= 18 ? "pass" : "fail",
+    message: `${nodeVersion}`,
+    fix: nodeMajor < 18 ? "Upgrade to Node.js 18+" : null,
+  });
+
+  // Config file
+  const configPath = path.join(process.cwd(), ".vibecheckrc");
+  const hasConfig =
+    fs.existsSync(configPath) ||
+    fs.existsSync(path.join(process.cwd(), ".vibecheckrc"));
+  checks.push({
+    name: "Config",
+    status: hasConfig ? "pass" : "warn",
+    message: hasConfig ? "Found" : "Not found",
+    fix: !hasConfig ? "Run: vibecheck init" : null,
+  });
+
+  // Output directory
+  const outputDir = path.join(process.cwd(), ".vibecheck");
+  const hasOutput = fs.existsSync(outputDir);
+  checks.push({
+    name: "Output Dir",
+    status: hasOutput ? "pass" : "info",
+    message: hasOutput ? ".vibecheck/" : "Will be created on first scan",
+  });
+
+  // Package.json
+  const pkgPath = path.join(process.cwd(), "package.json");
+  const hasPkg = fs.existsSync(pkgPath);
+  checks.push({
+    name: "package.json",
+    status: hasPkg ? "pass" : "warn",
+    message: hasPkg ? "Found" : "Not found",
+  });
+
+  // TypeScript
+  const hasTsConfig = fs.existsSync(path.join(process.cwd(), "tsconfig.json"));
+  checks.push({
+    name: "TypeScript",
+    status: hasTsConfig ? "pass" : "info",
+    message: hasTsConfig ? "Enabled" : "JavaScript project",
+  });
+
+  // Print results
+  let hasIssues = false;
+  for (const check of checks) {
+    const icon =
+      check.status === "pass"
+        ? "✅"
+        : check.status === "fail"
+          ? "❌"
+          : check.status === "warn"
+            ? "⚠️"
+            : "ℹ️";
+    console.log(`  ${icon} ${check.name.padEnd(12)} ${check.message}`);
+    if (check.fix) {
+      console.log(`     Fix: ${check.fix}`);
+    }
+    if (check.status === "fail") hasIssues = true;
+  }
+
+  console.log("");
+  if (hasIssues) {
+    console.log("  ❌ Issues found. Fix them and run doctor again.\n");
+    return 2;
+  } else {
+    console.log("  ✅ Environment healthy!\n");
+    return 0;
+  }
+}
+
+module.exports = { 
+  runDoctor: runDoctor,
+  runDoctorLegacy: runDoctorLegacy,
+};

package/bin/runners/runEnhancedShip.js

@@ -0,0 +1,2 @@
+async function runEnhancedShip(args) { console.log("Enhanced ship not yet implemented"); return 0; }
+module.exports = { runEnhancedShip };