@vibecheckai/cli 3.0.5 → 3.0.8

package/bin/runners/runGuard.js

@@ -0,0 +1,168 @@
+/**
+ * vibecheck guard - Unified trust boundary enforcement
+ * 
+ * Combines: validate + claim-verifier + prompt-firewall
+ * 
+ * Usage:
+ *   vibecheck guard                    # Run all checks
+ *   vibecheck guard --claims           # Verify AI claims against truthpack
+ *   vibecheck guard --prompts          # Check for prompt injection
+ *   vibecheck guard --hallucinations   # Detect AI hallucination patterns
+ */
+
+const path = require("path");
+const fs = require("fs");
+
+// Import underlying implementations
+const { runValidate } = require("./runValidate");
+const { runPromptFirewall } = require("./runPromptFirewall");
+
+// ANSI colors
+const c = {
+  reset: "\x1b[0m",
+  dim: "\x1b[2m",
+  bold: "\x1b[1m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  magenta: "\x1b[35m",
+};
+
+function printHelp() {
+  console.log(`
+${c.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c.reset}
+  ${c.bold}vibecheck guard${c.reset} - Trust boundary enforcement for AI outputs
+${c.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c.reset}
+
+${c.green}USAGE${c.reset}
+  vibecheck guard [options]
+
+${c.yellow}OPTIONS${c.reset}
+  --claims           Verify AI claims against truthpack (route_exists, auth_enforced, etc.)
+  --prompts          Check code for prompt injection vulnerabilities
+  --hallucinations   Detect AI hallucination patterns in generated code
+  --file <path>      Check specific file(s)
+  --json             Output JSON for CI integration
+  --strict           Fail on warnings (default: fail on errors only)
+
+${c.magenta}EXAMPLES${c.reset}
+  vibecheck guard                           # Run all checks
+  vibecheck guard --claims --file api.ts    # Verify claims in specific file
+  vibecheck guard --prompts                 # Prompt injection scan
+  vibecheck guard --json                    # CI-friendly output
+
+${c.dim}This command unifies trust boundary checks for AI-generated code.${c.reset}
+`);
+}
+
+async function runGuard(args = []) {
+  // Parse arguments
+  if (args.includes("--help") || args.includes("-h")) {
+    printHelp();
+    return 0;
+  }
+
+  const runClaims = args.includes("--claims") || (!args.includes("--prompts") && !args.includes("--hallucinations"));
+  const runPrompts = args.includes("--prompts") || (!args.includes("--claims") && !args.includes("--hallucinations"));
+  const runHallucinations = args.includes("--hallucinations") || (!args.includes("--claims") && !args.includes("--prompts"));
+  const jsonOutput = args.includes("--json");
+  const strict = args.includes("--strict");
+
+  const results = {
+    claims: null,
+    prompts: null,
+    hallucinations: null,
+    verdict: "PASS",
+    errors: 0,
+    warnings: 0,
+  };
+
+  console.log(`
+${c.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c.reset}
+  ${c.bold}🛡️  VIBECHECK GUARD${c.reset} - Trust Boundary Enforcement
+${c.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c.reset}
+`);
+
+  // Run claims verification (validates AI claims against truthpack)
+  if (runClaims) {
+    console.log(`${c.dim}▸ Verifying AI claims against truthpack...${c.reset}`);
+    try {
+      const validateArgs = args.filter(a => !["--claims", "--prompts", "--hallucinations"].includes(a));
+      const exitCode = await runValidate(validateArgs);
+      results.claims = { exitCode, status: exitCode === 0 ? "pass" : "fail" };
+      if (exitCode !== 0) {
+        results.errors++;
+        results.verdict = "FAIL";
+      }
+      console.log(exitCode === 0 
+        ? `  ${c.green}✓${c.reset} Claims verified` 
+        : `  ${c.red}✗${c.reset} Claim verification failed`);
+    } catch (e) {
+      results.claims = { error: e.message };
+      console.log(`  ${c.yellow}⚠${c.reset} Claims check skipped: ${e.message}`);
+    }
+  }
+
+  // Run prompt injection detection
+  if (runPrompts) {
+    console.log(`${c.dim}▸ Scanning for prompt injection vulnerabilities...${c.reset}`);
+    try {
+      const firewallArgs = args.filter(a => !["--claims", "--prompts", "--hallucinations"].includes(a));
+      const exitCode = await runPromptFirewall(firewallArgs);
+      results.prompts = { exitCode, status: exitCode === 0 ? "pass" : "fail" };
+      if (exitCode !== 0) {
+        results.warnings++;
+        if (strict) results.verdict = "FAIL";
+      }
+      console.log(exitCode === 0 
+        ? `  ${c.green}✓${c.reset} No prompt injection risks` 
+        : `  ${c.yellow}⚠${c.reset} Prompt injection risks detected`);
+    } catch (e) {
+      results.prompts = { error: e.message };
+      console.log(`  ${c.yellow}⚠${c.reset} Prompt check skipped: ${e.message}`);
+    }
+  }
+
+  // Run hallucination detection
+  if (runHallucinations) {
+    console.log(`${c.dim}▸ Detecting hallucination patterns...${c.reset}`);
+    // Use validate with hallucination focus
+    try {
+      const validateArgs = ["--hallucinations", ...args.filter(a => !["--claims", "--prompts", "--hallucinations"].includes(a))];
+      const exitCode = await runValidate(validateArgs);
+      results.hallucinations = { exitCode, status: exitCode === 0 ? "pass" : "fail" };
+      if (exitCode !== 0) {
+        results.warnings++;
+        if (strict) results.verdict = "FAIL";
+      }
+      console.log(exitCode === 0 
+        ? `  ${c.green}✓${c.reset} No hallucination patterns` 
+        : `  ${c.yellow}⚠${c.reset} Potential hallucinations detected`);
+    } catch (e) {
+      results.hallucinations = { error: e.message };
+      console.log(`  ${c.yellow}⚠${c.reset} Hallucination check skipped: ${e.message}`);
+    }
+  }
+
+  // Summary
+  console.log(`
+${c.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c.reset}`);
+  
+  if (results.verdict === "PASS") {
+    console.log(`  ${c.green}${c.bold}✓ GUARD PASS${c.reset} - All trust boundaries intact`);
+  } else {
+    console.log(`  ${c.red}${c.bold}✗ GUARD FAIL${c.reset} - Trust boundary violations detected`);
+  }
+
+  console.log(`${c.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c.reset}
+`);
+
+  if (jsonOutput) {
+    console.log(JSON.stringify(results, null, 2));
+  }
+
+  return results.verdict === "PASS" ? 0 : (results.errors > 0 ? 2 : 1);
+}
+
+module.exports = { runGuard };

package/bin/runners/runInstall.js

@@ -6,11 +6,51 @@ const { detectPackageManager, detectNext, detectFastify, detectFastifyEntry } =
 const { readPkg, writePkg, upsertScripts } = require("./lib/pkgjson");
 const { writeEnvTemplateFromTruthpack } = require("./lib/env-template");
 
+function printHelp() {
+  console.log(`
+vibecheck install - Zero-friction onboarding
+
+USAGE
+  vibecheck install [options]
+
+OPTIONS
+  --path, -p <dir>    Project path (default: current directory)
+  --help, -h          Show this help
+
+WHAT IT DOES
+  1. Detects package manager (npm, yarn, pnpm)
+  2. Detects frameworks (Next.js, Fastify)
+  3. Builds initial truthpack
+  4. Creates .vibecheck/config.json
+  5. Generates env template from truthpack
+  6. Adds vibecheck scripts to package.json
+
+CREATED FILES
+  .vibecheck/config.json     - Local configuration
+  .vibecheck/truthpack.json  - Ground truth for AI agents
+  .env.template              - Env vars from truthpack
+
+EXAMPLES
+  vibecheck install                    # Install in current directory
+  vibecheck install --path ./my-app    # Install in specific directory
+`);
+}
+
 function ensureDir(p) {
   fs.mkdirSync(p, { recursive: true });
 }
 
-async function runInstall({ repoRoot } = {}) {
+async function runInstall(argsOrContext = {}) {
+  // Handle array args from CLI
+  if (Array.isArray(argsOrContext)) {
+    if (argsOrContext.includes("--help") || argsOrContext.includes("-h")) {
+      printHelp();
+      return 0;
+    }
+    argsOrContext = { repoRoot: process.cwd() };
+  }
+  
+  const { repoRoot } = argsOrContext;
   const root = repoRoot || process.cwd();
 
   const { path: pkgPath, json: pkg } = readPkg(root);

package/bin/runners/runLabs.js

@@ -0,0 +1,341 @@
+/**
+ * vibecheck labs - Experimental Features
+ *
+ * Access to experimental, internal, and beta features.
+ * These may change or be removed without notice.
+ *
+ * @module runners/runLabs
+ */
+
+"use strict";
+
+const { c, sym, box, printHeader, table } = require("./lib/ui");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// LABS FEATURE REGISTRY
+// ═══════════════════════════════════════════════════════════════════════════════
+const LABS_FEATURES = {
+  // Experimental - Working but API may change
+  "ai-test": {
+    status: "experimental",
+    description: "AI agent for autonomous app testing",
+    docs: "https://docs.vibecheckai.dev/labs/ai-test",
+    runner: () => require("./runAIAgent").runAIAgent,
+  },
+  "launch": {
+    status: "experimental",
+    description: "Pre-launch checklist wizard",
+    docs: "https://docs.vibecheckai.dev/labs/launch",
+    runner: () => require("./runLaunch").runLaunch,
+  },
+  "dashboard": {
+    status: "experimental",
+    description: "Real-time monitoring dashboard",
+    runner: () => require("./runDashboard").runDashboard,
+  },
+  "permissions": {
+    status: "experimental",
+    description: "AuthZ matrix & IDOR vulnerability prover",
+    runner: () => require("./runPermissions").runPermissions,
+  },
+  "replay": {
+    status: "experimental",
+    description: "Record and replay user sessions for testing",
+    runner: () => require("./runReplay").runReplay,
+  },
+  "graph": {
+    status: "experimental",
+    description: "Reality proof graph visualization",
+    runner: () => require("./runGraph").runGraph,
+  },
+  
+  // Beta - Feature complete, gathering feedback
+  "ctx-diff": {
+    status: "beta",
+    description: "Diff truthpack changes across commits",
+    runner: () => require("./runCtxDiff").main,
+  },
+  
+  // Stubs - Planned but not implemented
+  "autopilot": {
+    status: "stub",
+    description: "Continuous protection mode (auto-fix on commit)",
+    eta: "Q2 2025",
+  },
+  "certify": {
+    status: "stub",
+    description: "Generate compliance certification badges",
+    eta: "Q2 2025",
+  },
+  "audit": {
+    status: "stub",
+    description: "Full audit trail for compliance (SOC2, HIPAA)",
+    eta: "Q3 2025",
+  },
+  "natural-language": {
+    status: "stub",
+    description: "Natural language command parsing",
+    eta: "Q2 2025",
+  },
+  "fix-packs": {
+    status: "stub",
+    description: "Downloadable fix pack templates",
+    eta: "Q2 2025",
+  },
+  "mdc": {
+    status: "stub",
+    description: "MDC documentation generator",
+    eta: "Q3 2025",
+  },
+  
+  // Aliases - Redirect to main commands
+  "enhanced-ship": {
+    status: "alias",
+    target: "ship --strict",
+    description: "Enhanced ship mode (use: vibecheck ship --strict)",
+  },
+  "sniff": {
+    status: "alias",
+    target: "reality --sniff",
+    description: "Reality sniff mode (use: vibecheck reality --sniff)",
+  },
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// STATUS DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+const STATUS_CONFIG = {
+  experimental: {
+    icon: sym.lightning,
+    color: c.yellow,
+    label: "EXPERIMENTAL",
+    description: "Working but API may change",
+  },
+  beta: {
+    icon: sym.star,
+    color: c.cyan,
+    label: "BETA",
+    description: "Feature complete, gathering feedback",
+  },
+  stub: {
+    icon: sym.pending,
+    color: c.dim,
+    label: "PLANNED",
+    description: "Not yet implemented",
+  },
+  alias: {
+    icon: sym.arrow,
+    color: c.dim,
+    label: "ALIAS",
+    description: "Use the main command instead",
+  },
+};
+
+function formatStatus(status) {
+  const config = STATUS_CONFIG[status];
+  if (!config) return status;
+  return `${config.color}${config.icon} ${config.label}${c.reset}`;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// HELP DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+function printHelp() {
+  printHeader("LABS", { 
+    icon: sym.lightning, 
+    subtitle: "Experimental & Internal Features" 
+  });
+  
+  console.log(`${c.yellow}${sym.warning} These features are experimental and may change without notice.${c.reset}\n`);
+  
+  // Group by status
+  const groups = {
+    experimental: [],
+    beta: [],
+    stub: [],
+    alias: [],
+  };
+  
+  for (const [name, feature] of Object.entries(LABS_FEATURES)) {
+    if (groups[feature.status]) {
+      groups[feature.status].push({ name, ...feature });
+    }
+  }
+  
+  // Experimental
+  if (groups.experimental.length > 0) {
+    console.log(`${c.yellow}${sym.lightning} EXPERIMENTAL${c.reset} ${c.dim}(working, API may change)${c.reset}\n`);
+    
+    for (const feature of groups.experimental) {
+      console.log(`  ${c.cyan}vibecheck labs ${feature.name}${c.reset}`);
+      console.log(`    ${c.dim}${feature.description}${c.reset}`);
+      if (feature.docs) {
+        console.log(`    ${c.dim}Docs: ${feature.docs}${c.reset}`);
+      }
+      console.log("");
+    }
+  }
+  
+  // Beta
+  if (groups.beta.length > 0) {
+    console.log(`${c.cyan}${sym.star} BETA${c.reset} ${c.dim}(feature complete, gathering feedback)${c.reset}\n`);
+    
+    for (const feature of groups.beta) {
+      console.log(`  ${c.cyan}vibecheck labs ${feature.name}${c.reset}`);
+      console.log(`    ${c.dim}${feature.description}${c.reset}`);
+      console.log("");
+    }
+  }
+  
+  // Stubs
+  if (groups.stub.length > 0) {
+    console.log(`${c.dim}${sym.pending} PLANNED${c.reset} ${c.dim}(not yet implemented)${c.reset}\n`);
+    
+    const stubData = groups.stub.map(f => [
+      `${c.dim}${f.name}${c.reset}`,
+      `${c.dim}${f.description}${c.reset}`,
+      f.eta ? `${c.dim}ETA: ${f.eta}${c.reset}` : "",
+    ]);
+    
+    console.log(table(stubData, { indent: 2 }));
+    console.log("");
+  }
+  
+  // Aliases
+  if (groups.alias.length > 0) {
+    console.log(`${c.dim}${sym.arrow} ALIASES${c.reset} ${c.dim}(use the main command instead)${c.reset}\n`);
+    
+    for (const feature of groups.alias) {
+      console.log(`  ${c.dim}labs ${feature.name}${c.reset} ${sym.arrow} ${c.cyan}vibecheck ${feature.target}${c.reset}`);
+    }
+    console.log("");
+  }
+  
+  // Usage
+  console.log(`${c.dim}${"─".repeat(60)}${c.reset}`);
+  console.log(`${c.bold}Usage${c.reset}\n`);
+  console.log(`  vibecheck labs <feature> [options]\n`);
+  console.log(`${c.dim}Example:${c.reset}`);
+  console.log(`  vibecheck labs ai-test --url http://localhost:3000`);
+  console.log("");
+  
+  // Feedback
+  console.log(`${c.dim}${"─".repeat(60)}${c.reset}`);
+  console.log(`${c.bold}Feedback${c.reset}\n`);
+  console.log(`  ${c.dim}Want a feature prioritized? Let us know:${c.reset}`);
+  console.log(`  ${c.cyan}https://github.com/vibecheckai/vibecheck/discussions${c.reset}`);
+  console.log("");
+}
+
+function printFeatureStub(name, feature) {
+  console.log(box(
+    `${c.bold}vibecheck labs ${name}${c.reset}\n\n` +
+    `${feature.description}\n\n` +
+    `${c.dim}This feature is not yet implemented.${c.reset}\n` +
+    (feature.eta ? `${c.dim}Expected: ${feature.eta}${c.reset}\n` : "") +
+    `\n${c.dim}Want this feature? Vote for it:${c.reset}\n` +
+    `${c.cyan}https://github.com/vibecheckai/vibecheck/discussions${c.reset}`,
+    { title: "PLANNED", borderColor: c.yellow }
+  ));
+  console.log("");
+}
+
+function printAliasWarning(name, feature) {
+  console.log(`${c.yellow}${sym.warning}${c.reset} '${name}' is now available as: ${c.cyan}vibecheck ${feature.target}${c.reset}\n`);
+  console.log(`${c.dim}The labs alias will be removed in a future version.${c.reset}\n`);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN RUNNER
+// ═══════════════════════════════════════════════════════════════════════════════
+async function runLabs(args = []) {
+  const subCmd = args[0];
+  const subArgs = args.slice(1);
+  
+  // Show help if no command
+  if (!subCmd || subCmd === "--help" || subCmd === "-h") {
+    printHelp();
+    return 0;
+  }
+  
+  // List all features
+  if (subCmd === "--list" || subCmd === "-l") {
+    const features = Object.entries(LABS_FEATURES).map(([name, f]) => [
+      name,
+      formatStatus(f.status),
+      f.description.slice(0, 40),
+    ]);
+    
+    console.log(table(features, { 
+      headers: ["Feature", "Status", "Description"],
+      indent: 2,
+    }));
+    console.log("");
+    return 0;
+  }
+  
+  // Find feature
+  const feature = LABS_FEATURES[subCmd];
+  
+  if (!feature) {
+    console.log(`${c.red}${sym.error}${c.reset} Unknown labs feature: ${c.yellow}${subCmd}${c.reset}\n`);
+    console.log(`${c.dim}Available features:${c.reset}`);
+    console.log(`  ${Object.keys(LABS_FEATURES).filter(k => LABS_FEATURES[k].status !== "stub").join(", ")}`);
+    console.log(`\n${c.dim}Run 'vibecheck labs --help' for details.${c.reset}\n`);
+    return 1;
+  }
+  
+  // Handle stubs
+  if (feature.status === "stub") {
+    printFeatureStub(subCmd, feature);
+    return 0;
+  }
+  
+  // Handle aliases
+  if (feature.status === "alias") {
+    printAliasWarning(subCmd, feature);
+    
+    // Try to run the aliased command
+    const [cmd, ...aliasArgs] = feature.target.split(" ");
+    try {
+      const { runShip } = require("./runShip");
+      if (cmd === "ship") {
+        return await runShip([...aliasArgs, ...subArgs]);
+      }
+      const { runReality } = require("./runReality");
+      if (cmd === "reality") {
+        return await runReality([...aliasArgs, ...subArgs]);
+      }
+    } catch (e) {
+      console.log(`${c.dim}Please run the command directly: vibecheck ${feature.target}${c.reset}\n`);
+    }
+    return 0;
+  }
+  
+  // Run the feature
+  try {
+    const runner = feature.runner();
+    
+    // Show experimental warning
+    if (feature.status === "experimental") {
+      console.log(`${c.yellow}${sym.warning} EXPERIMENTAL:${c.reset} ${c.dim}This feature may change without notice.${c.reset}\n`);
+    } else if (feature.status === "beta") {
+      console.log(`${c.cyan}${sym.star} BETA:${c.reset} ${c.dim}Feedback welcome! Report issues at github.com/vibecheckai/vibecheck${c.reset}\n`);
+    }
+    
+    return await runner(subArgs);
+  } catch (e) {
+    if (e.code === "MODULE_NOT_FOUND") {
+      console.log(`${c.red}${sym.error}${c.reset} Feature '${subCmd}' is not available in this version.\n`);
+      console.log(`${c.dim}Try updating: npm update -g @vibecheckai/cli${c.reset}\n`);
+    } else {
+      console.error(`${c.red}${sym.error}${c.reset} Error running labs ${subCmd}: ${e.message}`);
+      if (process.env.VIBECHECK_DEBUG) {
+        console.error(c.dim + e.stack + c.reset);
+      }
+    }
+    return 1;
+  }
+}
+
+module.exports = { runLabs, LABS_FEATURES };