@vibecheckai/cli 3.0.10 → 3.1.0

package/bin/vibecheck.js

@@ -12,6 +12,7 @@ const path = require("path");
 const fs = require("fs");
 const os = require("os");
 const { performance } = require("perf_hooks");
+const crypto = require("crypto");
 
 // ═══════════════════════════════════════════════════════════════════════════════
 // PERFORMANCE: Track startup time
@@ -235,58 +236,28 @@ function findSimilarCommands(input, commands, maxDistance = 3) {
 const entitlements = require("./runners/lib/entitlements-v2");
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// COMMAND REGISTRY - Tiers match entitlements-v2.js EXACTLY
+// UPSELL COPY MODULE - Central copy generator for all upgrade messaging
 // ═══════════════════════════════════════════════════════════════════════════════
-const COMMANDS = {
-  // PROOF LOOP
-  scan: { description: "Static analysis - routes, secrets, contracts", tier: "free", category: "proof", aliases: ["s", "check"], runner: () => require("./runners/runScan").runScan },
-  ship: { description: "Verdict engine - SHIP / WARN / BLOCK", tier: "free", category: "proof", aliases: ["verdict"], caps: "static-only on FREE", runner: () => require("./runners/runShip").runShip },
-  reality: { description: "Runtime proof - Playwright clicks every button", tier: "free", category: "proof", aliases: ["r", "test", "e2e"], caps: "preview mode on FREE (5 pages, no auth)", runner: () => { try { return require("./runners/runReality").runReality; } catch (e) { return async () => { console.error("Reality runner unavailable:", e.message); return 1; }; } } },
-  prove: { description: "Full proof loop - ctx → reality → ship → fix", tier: "pro", category: "proof", aliases: ["p", "full", "all"], runner: () => require("./runners/runProve").runProve },
-  fix: { description: "AI-powered auto-fix", tier: "free", category: "proof", caps: "--plan-only on FREE/STARTER", aliases: ["f", "repair"], runner: () => require("./runners/runFix").runFix },
-  report: { description: "Generate HTML/MD/SARIF reports", tier: "free", category: "proof", caps: "HTML/MD only on FREE", aliases: ["html", "artifact"], runner: () => require("./runners/runReport").runReport },
-  
-  // SETUP & DX
-  install: { description: "Zero-friction onboarding", tier: "free", category: "setup", aliases: ["i", "bootstrap"], runner: () => require("./runners/runInstall").runInstall },
-  init: { description: "Project setup wizard", tier: "free", category: "setup", aliases: ["setup", "configure"], runner: () => require("./runners/runInit").runInit },
-  doctor: { description: "Environment diagnostics", tier: "free", category: "setup", aliases: ["health", "diag"], runner: () => require("./runners/runDoctor").runDoctor },
-  status: { description: "Project health dashboard", tier: "free", category: "setup", aliases: ["st"], runner: () => require("./runners/runStatus").runStatus },
-  watch: { description: "Continuous mode - re-runs on changes", tier: "free", category: "setup", aliases: ["w", "dev"], runner: () => require("./runners/runWatch").runWatch },
-  launch: { description: "Pre-launch checklist wizard", tier: "starter", category: "setup", aliases: ["checklist", "preflight"], runner: () => require("./runners/runLaunch").runLaunch },
-  
-  // AI TRUTH
-  ctx: { description: "Generate truthpack for AI agents", tier: "free", category: "truth", aliases: ["truthpack", "tp"], subcommands: ["build", "diff", "guard", "sync", "search"], runner: () => require("./runners/runCtx").runCtx },
-  guard: { description: "Validate AI claims against truth", tier: "free", category: "truth", aliases: ["validate", "trust"], runner: () => require("./runners/runGuard").runGuard },
-  context: { description: "Generate .cursorrules, .windsurf/rules", tier: "free", category: "truth", aliases: ["rules", "ai-rules"], runner: () => require("./runners/runContext").runContext },
-  mdc: { description: "Generate MDC specifications", tier: "free", category: "truth", aliases: [], runner: () => require("./runners/runMdc").runMdc },
-  
-  // CI & COLLABORATION (STARTER+)
-  gate: { description: "CI/CD gate - blocks deploys on failures", tier: "starter", category: "ci", aliases: ["ci", "block"], runner: () => require("./runners/runGate").runGate },
-  pr: { description: "Generate PR comment with findings", tier: "starter", category: "ci", aliases: ["pull-request"], runner: () => require("./runners/runPR").runPR },
-  badge: { description: "Generate ship badge for README", tier: "starter", category: "ci", aliases: ["b"], runner: () => require("./runners/runBadge").runBadge },
-  
-  // AUTOMATION (STARTER+/PRO)
-  mcp: { description: "Start MCP server for AI IDEs", tier: "starter", category: "automation", aliases: [], runner: () => require("./runners/runMcp").runMcp },
-  share: { description: "Generate share pack for PR/docs", tier: "pro", category: "automation", aliases: [], runner: () => require("./runners/runShare").runShare },
-  "ai-test": { description: "AI autonomous test generation", tier: "pro", category: "automation", aliases: ["ai", "agent"], runner: () => require("./runners/runAIAgent").runAIAgent },
-  
-  // ACCOUNT (always free)
-  login: { description: "Authenticate with API key", tier: "free", category: "account", aliases: ["auth", "signin"], runner: () => require("./runners/runAuth").runLogin, skipAuth: true },
-  logout: { description: "Remove stored credentials", tier: "free", category: "account", aliases: ["signout"], runner: () => require("./runners/runAuth").runLogout, skipAuth: true },
-  whoami: { description: "Show current user and plan", tier: "free", category: "account", aliases: ["me", "user"], runner: () => require("./runners/runAuth").runWhoami, skipAuth: true },
-  
-  // EXTRAS
-  labs: { description: "Experimental features", tier: "free", category: "extras", aliases: ["experimental", "beta"], runner: () => require("./runners/runLabs").runLabs },
-};
+const upsell = require("./runners/lib/upsell");
 
-const ALIAS_MAP = {};
-for (const [cmd, def] of Object.entries(COMMANDS)) { for (const alias of def.aliases || []) ALIAS_MAP[alias] = cmd; }
-const ALL_COMMANDS = [...Object.keys(COMMANDS), ...Object.values(COMMANDS).flatMap(c => c.aliases || [])];
+// ═══════════════════════════════════════════════════════════════════════════════
+// CLI OUTPUT UTILITIES
+// ═══════════════════════════════════════════════════════════════════════════════
+const { 
+  generateRunId, 
+  withStandardOutput, 
+  parseStandardFlags,
+  exitCodeToVerdict 
+} = require("./runners/lib/cli-output");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// COMMAND REGISTRY - Imported from bin/registry.js (single source of truth)
+// ═══════════════════════════════════════════════════════════════════════════════
+const { COMMANDS, ALIAS_MAP, ALL_COMMANDS, getRunner: _getRunner } = require("./registry");
 
+// Wrap getRunner to pass styling
 function getRunner(cmd) {
-  const def = COMMANDS[cmd];
-  if (!def) return null;
-  try { return def.runner(); } catch (e) { return async () => { console.error(`${c.red}${sym.error}${c.reset} Failed to load ${cmd}: ${e.message}`); return 1; }; }
+  return _getRunner(cmd, { red: c.red, reset: c.reset, errorSymbol: sym.error });
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -331,22 +302,11 @@ async function checkCommandAccess(cmd, args, authInfo) {
 }
 
 function formatAccessDenied(cmd, requiredTier, currentTier) {
-  const tierColors = { starter: c.cyan, pro: c.magenta, enterprise: c.yellow };
-  const tierColor = tierColors[requiredTier] || c.white;
-  const tierLabel = entitlements.getTierLabel(requiredTier);
-  const currentLabel = entitlements.getTierLabel(currentTier);
-  
-  let msg = `\n${c.red}${c.bold}⛔ Feature Not Available${c.reset}\n\n`;
-  msg += `  ${c.yellow}${cmd}${c.reset} requires ${tierColor}${tierLabel}${c.reset} plan.\n`;
-  msg += `  Your current plan: ${c.dim}${currentLabel}${c.reset}\n\n`;
-  
-  if (currentTier === "free") {
-    msg += `  ${c.cyan}Get started:${c.reset} vibecheck login\n`;
-  }
-  msg += `  ${c.cyan}Upgrade at:${c.reset} https://vibecheckai.dev/pricing\n`;
-  msg += `\n  ${c.dim}Exit code: ${entitlements.EXIT_FEATURE_NOT_ALLOWED}${c.reset}\n`;
-  
-  return msg;
+  // Use centralized upsell copy module
+  return upsell.formatDenied(cmd, {
+    currentTier,
+    requiredTier,
+  });
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -456,52 +416,71 @@ async function main() {
   const config = loadConfig();
   const state = loadState();
   
-  const globalFlags = {
-    debug: rawArgs.includes("--debug") || rawArgs.includes("-d"),
-    verbose: rawArgs.includes("--verbose") || rawArgs.includes("-v"),
-    quiet: rawArgs.includes("--quiet") || rawArgs.includes("-q"),
-    help: rawArgs.includes("--help") || rawArgs.includes("-h"),
-    version: rawArgs.includes("--version") || rawArgs.includes("-V"),
-  };
+  // Parse standard flags
+  const { flags: globalFlags, parsed: cleanArgs } = parseStandardFlags(rawArgs);
   
+  // Update config based on flags
   if (globalFlags.debug) config.debug = true;
   if (globalFlags.verbose) config.verbose = true;
   if (globalFlags.quiet) config.quiet = true;
+  if (globalFlags.ci) config.quiet = true; // CI mode implies quiet
   
-  const args = rawArgs.filter(a => !["--debug", "-d", "--verbose", "-v", "--quiet", "-q", "--help", "-h", "--version", "-V"].includes(a));
-  
-  if (globalFlags.version || args[0] === "version") {
+  // Handle version
+  if (globalFlags.version) {
     console.log(`vibecheck v${VERSION}`);
     process.exit(0);
   }
   
-  if (!args[0]) { printHelp(); process.exit(0); }
+  // Handle no command
+  if (!cleanArgs[0]) { printHelp(); process.exit(0); }
   
   // Handle command-specific help (vibecheck <cmd> --help)
-  if (globalFlags.help && args[0] && COMMANDS[args[0]]) {
+  if (globalFlags.help && cleanArgs[0] && COMMANDS[cleanArgs[0]]) {
     // Pass --help to the command runner
-  } else if (globalFlags.help && !args[0]) {
+  } else if (globalFlags.help && !cleanArgs[0]) {
     printHelp(); process.exit(0);
   }
   
-  let cmd = args[0];
+  let cmd = cleanArgs[0];
   if (ALIAS_MAP[cmd]) { cmd = ALIAS_MAP[cmd]; }
-  let cmdArgs = args.slice(1);
+  let cmdArgs = cleanArgs.slice(1);
   
   // Add --help back to cmdArgs if it was passed with a command
   if (globalFlags.help) cmdArgs = ["--help", ...cmdArgs];
   
+  // Pass standard flags to runners
+  cmdArgs = [...cmdArgs];
+  if (globalFlags.json) cmdArgs.push("--json");
+  if (globalFlags.ci) cmdArgs.push("--ci");
+  if (globalFlags.path && globalFlags.path !== process.cwd()) {
+    cmdArgs.push("--path", globalFlags.path);
+  }
+  if (globalFlags.output) {
+    cmdArgs.push("--output", globalFlags.output);
+  }
+  if (globalFlags.verbose) cmdArgs.push("--verbose");
+  if (globalFlags.strict) cmdArgs.push("--strict");
+  
   if (!COMMANDS[cmd]) {
     const suggestions = findSimilarCommands(cmd, ALL_COMMANDS);
     console.log(`\n${c.red}${sym.error}${c.reset} Unknown command: ${c.yellow}${cmd}${c.reset}`);
-    if (suggestions.length > 0) {
+    
+    // Check for specific common misses
+    if (cmd === "replay" || cmd === "record") {
+      console.log(`\n${c.dim}replay is a PRO feature for session recording.${c.reset}`);
+      console.log(`${c.dim}Free alternative:${c.reset} ${c.cyan}vibecheck reality${c.reset} ${c.dim}(one-time runtime proof)${c.reset}`);
+    } else if (suggestions.length > 0) {
       console.log(`\n${c.dim}Did you mean:${c.reset}`);
       suggestions.forEach(s => { const actual = ALIAS_MAP[s] || s; const def = COMMANDS[actual]; console.log(`  ${c.cyan}vibecheck ${s}${c.reset}  ${c.dim}${def?.description || ""}${c.reset}`); });
     }
     console.log(`\n${c.dim}Run 'vibecheck --help' for available commands.${c.reset}\n`);
-    process.exit(1);
+    process.exit(4); // INVALID_INPUT
   }
   
+  // Generate runId for tracking
+  const runId = generateRunId();
+  const runStart = new Date().toISOString();
+  
   const cmdDef = COMMANDS[cmd];
   let authInfo = { key: null };
   
@@ -516,18 +495,22 @@ async function main() {
     if (!access.allowed) {
       console.log(access.reason);
       // Use proper exit code: 3 = feature not allowed
-      process.exit(access.exitCode || entitlements.EXIT_FEATURE_NOT_ALLOWED);
+      process.exit(access.exitCode || 3);
     }
     
-    // Show downgrade notice if applicable
+    // Show downgrade notice if applicable (single-line at start)
     if (access.downgrade && !config.quiet) {
-      console.log(`${c.yellow}${sym.warning}${c.reset} Running in ${c.yellow}${access.downgrade}${c.reset} mode (upgrade for full access)`);
+      console.log(upsell.formatDowngrade(cmd, {
+        currentTier: access.tier,
+        effectiveMode: access.downgrade,
+        caps: access.caps,
+      }));
     }
     
     // Show tier badge
     if (!config.quiet) {
-      if (access.tier === "starter") console.log(`${c.cyan}${sym.arrowRight} STARTER${c.reset} ${c.dim}feature${c.reset}`);
-      else if (access.tier === "pro") console.log(`${c.magenta}${sym.arrowRight} PRO${c.reset} ${c.dim}feature${c.reset}`);
+      if (access.tier === "pro") console.log(`${c.magenta}${sym.arrowRight} PRO${c.reset} ${c.dim}feature${c.reset}`);
+      else if (access.tier === "complete") console.log(`${c.yellow}${sym.arrowRight} COMPLETE${c.reset} ${c.dim}feature${c.reset}`);
     }
     
     // Attach access info for runners to use
@@ -543,27 +526,58 @@ async function main() {
     const runner = getRunner(cmd);
     if (!runner) { console.error(`${c.red}${sym.error}${c.reset} Failed to load runner for: ${cmd}`); process.exit(1); }
     
-    const context = { repoRoot: process.cwd(), config, state, authInfo, version: VERSION, isCI: isCI() };
+    const context = { 
+      repoRoot: process.cwd(), 
+      config, 
+      state, 
+      authInfo, 
+      version: VERSION, 
+      isCI: isCI(),
+      runId,
+      runStart
+    };
     
+    // Pass context to runners that support it
     switch (cmd) {
-      case "prove": exitCode = await runner(cmdArgs); break;
-      case "reality": exitCode = await runner(cmdArgs); break;
-      case "watch": exitCode = await runner(cmdArgs); break;
+      case "prove": exitCode = await runner(cmdArgs, context); break;
+      case "reality": exitCode = await runner(cmdArgs, context); break;
+      case "watch": exitCode = await runner(cmdArgs, context); break;
+      case "ship": exitCode = await runner(cmdArgs, context); break;
       case "ctx": case "truthpack":
         if (cmdArgs[0] === "sync") { const { runCtxSync } = require("./runners/runCtxSync"); exitCode = await runCtxSync({ ...context, fastifyEntry: getArgValue(cmdArgs, ["--fastify-entry"]) }); }
         else if (cmdArgs[0] === "guard") { const { runCtxGuard } = require("./runners/runCtxGuard"); exitCode = await runCtxGuard.main(cmdArgs.slice(1)); }
         else if (cmdArgs[0] === "diff") { const { main: ctxDiffMain } = require("./runners/runCtxDiff"); exitCode = await ctxDiffMain(cmdArgs.slice(1)); }
         else if (cmdArgs[0] === "search") { const { runContext } = require("./runners/runContext"); exitCode = await runContext(["--search", ...cmdArgs.slice(1)]); }
-        else { exitCode = await runner(cmdArgs); }
+        else { exitCode = await runner(cmdArgs, context); }
         break;
-      case "install": exitCode = await runner(cmdArgs); break;
+      case "install": exitCode = await runner(cmdArgs, context); break;
       case "status": exitCode = await runner({ ...context, json: cmdArgs.includes("--json") }); break;
-      case "pr": exitCode = await runner(cmdArgs); break;
-      case "share": exitCode = await runner(cmdArgs); break;
+      case "pr": exitCode = await runner(cmdArgs, context); break;
+      case "share": exitCode = await runner(cmdArgs, context); break;
       default: exitCode = await runner(cmdArgs);
     }
   } catch (error) { console.error(formatError(error, config)); exitCode = 1; }
   
+  // Create manifest and receipt for paid commands
+  if (cmdDef.tier !== "free" && runId) {
+    try {
+      const { createManifestAndReceipt } = require("./runners/lib/receipts");
+      await createManifestAndReceipt({
+        runId,
+        command: cmd,
+        args: cmdArgs,
+        tier: authInfo.access?.tier || "free",
+        exitCode,
+        startTime: runStart,
+        endTime: new Date().toISOString(),
+        projectPath: process.cwd(),
+      });
+    } catch (e) {
+      // Don't fail the command if receipt creation fails
+      if (config.debug) console.error(`Failed to create receipt: ${e.message}`);
+    }
+  }
+  
   if (config.debug) console.log(`\n${c.dim}${sym.clock} Total: ${(performance.now() - startTime).toFixed(0)}ms${c.reset}`);
   process.exit(exitCode);
 }

package/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibecheck-mcp-server",
-  "version": "3.0.9",
+  "version": "3.1.0",
   "description": "Professional MCP server for vibecheck - Intelligent development environment vibechecks",
   "type": "module",
   "main": "index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibecheckai/cli",
-  "version": "3.0.10",
+  "version": "3.1.0",
   "description": "Vibecheck CLI - Ship with confidence. One verdict: SHIP | WARN | BLOCK.",
   "main": "bin/vibecheck.js",
   "bin": {