@vibecheckai/cli 3.5.1 → 3.5.2

package/bin/runners/runQuickstart.js

@@ -0,0 +1,531 @@
+/**
+ * Vibecheck Quickstart - 2-Minute Onboarding Flow
+ * 
+ * Orchestrates: doctor → ctx → scan → ship → report
+ * Gets user to first proof in under 2 minutes.
+ * 
+ * @module bin/runners/runQuickstart
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { withErrorHandling } = require("./lib/error-handler");
+const { parseGlobalFlags, shouldShowBanner } = require("./lib/global-flags");
+const { generateRunId, createJsonOutput, writeJsonOutput, saveArtifact } = require("./lib/cli-output");
+const { formatNextAction, formatDashboardLink, DASHBOARD_URL } = require("./lib/next-action");
+const { EXIT } = require("./lib/exit-codes");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ANSI STYLING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const SUPPORTS_COLOR = process.stdout.isTTY && !process.env.NO_COLOR;
+
+const c = SUPPORTS_COLOR ? {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  cyan: "\x1b[36m",
+  magenta: "\x1b[35m",
+  white: "\x1b[37m",
+  gray: "\x1b[90m",
+  bgGreen: "\x1b[42m",
+  bgYellow: "\x1b[43m",
+  bgRed: "\x1b[41m",
+  bgCyan: "\x1b[46m",
+} : {
+  reset: "", bold: "", dim: "", red: "", green: "", yellow: "",
+  cyan: "", magenta: "", white: "", gray: "", bgGreen: "", bgYellow: "", bgRed: "", bgCyan: "",
+};
+
+const sym = {
+  check: "✓",
+  cross: "✗",
+  arrow: "→",
+  spinner: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+  rocket: "🚀",
+  shield: "🛡️",
+  doc: "📄",
+  link: "🔗",
+  star: "★",
+  clock: "⏱",
+  warning: "⚠",
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// BANNER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const QUICKSTART_BANNER = `
+${c.cyan}  ╔═══════════════════════════════════════════════════════════════╗${c.reset}
+${c.cyan}  ║${c.reset}                ${c.bold}VIBECHECK QUICKSTART${c.reset}                        ${c.cyan}║${c.reset}
+${c.cyan}  ╠═══════════════════════════════════════════════════════════════╣${c.reset}
+${c.cyan}  ║${c.reset}  ${c.dim}Get your first proof in under 2 minutes${c.reset}                    ${c.cyan}║${c.reset}
+${c.cyan}  ║${c.reset}                                                               ${c.cyan}║${c.reset}
+${c.cyan}  ║${c.reset}  ${c.dim}This will run:${c.reset} doctor ${c.dim}→${c.reset} ctx ${c.dim}→${c.reset} scan ${c.dim}→${c.reset} ship ${c.dim}→${c.reset} report        ${c.cyan}║${c.reset}
+${c.cyan}  ║${c.reset}  ${c.dim}Estimated time:${c.reset} ~90 seconds                                ${c.cyan}║${c.reset}
+${c.cyan}  ╚═══════════════════════════════════════════════════════════════╝${c.reset}
+`;
+
+function printBanner() {
+  console.log(QUICKSTART_BANNER);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// PROGRESS DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printStepStart(stepNum, totalSteps, stepName, description) {
+  const progress = `[${stepNum}/${totalSteps}]`;
+  console.log(`  ${c.cyan}${progress}${c.reset} ${stepName}... ${c.dim}${description}${c.reset}`);
+}
+
+function printStepSuccess(stepName, duration, detail = "") {
+  const durationStr = duration ? `${c.dim}(${duration}ms)${c.reset}` : "";
+  const detailStr = detail ? `${c.dim}${detail}${c.reset}` : "";
+  console.log(`        ${c.green}${sym.check}${c.reset} ${stepName} ${durationStr} ${detailStr}`);
+}
+
+function printStepFailure(stepName, error) {
+  console.log(`        ${c.red}${sym.cross}${c.reset} ${stepName} failed: ${error}`);
+}
+
+function printStepSkipped(stepName, reason) {
+  console.log(`        ${c.yellow}${sym.arrow}${c.reset} ${stepName} skipped: ${c.dim}${reason}${c.reset}`);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// VERDICT DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printVerdictBox(verdict, score, findings) {
+  const blockers = findings.filter(f => f.severity === "BLOCK" || f.severity === "critical").length;
+  const warnings = findings.filter(f => f.severity === "WARN" || f.severity === "warning").length;
+  
+  let bgColor, icon, headline;
+  if (verdict === "SHIP") {
+    bgColor = c.bgGreen;
+    icon = sym.rocket;
+    headline = "SHIP";
+  } else if (verdict === "WARN") {
+    bgColor = c.bgYellow;
+    icon = sym.warning;
+    headline = "WARN";
+  } else {
+    bgColor = c.bgRed;
+    icon = sym.cross;
+    headline = "BLOCK";
+  }
+
+  console.log();
+  console.log(`  ${c.dim}══════════════════════════════════════════════════════════════════${c.reset}`);
+  console.log(`  ${bgColor}${c.bold}${c.white}  ${icon} VERDICT: ${headline}  ${c.reset}`);
+  console.log(`  ${c.dim}══════════════════════════════════════════════════════════════════${c.reset}`);
+  console.log();
+  console.log(`  ${c.bold}Score:${c.reset}    ${score}/100`);
+  console.log(`  ${c.bold}Blockers:${c.reset} ${blockers > 0 ? c.red : c.green}${blockers}${c.reset}`);
+  console.log(`  ${c.bold}Warnings:${c.reset} ${warnings > 0 ? c.yellow : c.green}${warnings}${c.reset}`);
+  console.log();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ARGS PARSER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function parseArgs(args) {
+  const { flags: globalFlags, cleanArgs } = parseGlobalFlags(args);
+  
+  const opts = {
+    path: globalFlags.path || process.cwd(),
+    json: globalFlags.json || false,
+    ci: globalFlags.ci || false,
+    quiet: globalFlags.quiet || false,
+    verbose: globalFlags.verbose || false,
+    noBanner: globalFlags.noBanner || false,
+    help: globalFlags.help || false,
+    fast: false,    // Skip optional checks
+    noOpen: false,  // Don't open report in browser
+  };
+  
+  for (let i = 0; i < cleanArgs.length; i++) {
+    const arg = cleanArgs[i];
+    if (arg === "--fast") opts.fast = true;
+    else if (arg === "--no-open") opts.noOpen = true;
+    else if (arg === "--path" || arg === "-p") opts.path = cleanArgs[++i] || process.cwd();
+    else if (arg.startsWith("--path=")) opts.path = arg.split("=")[1];
+  }
+  
+  return opts;
+}
+
+function printHelp(showBanner = true) {
+  if (showBanner) printBanner();
+  console.log(`
+  ${c.bold}USAGE${c.reset}
+    ${c.cyan}vibecheck quickstart${c.reset} [options]
+
+  ${c.dim}Get your first proof in under 2 minutes.${c.reset}
+  ${c.dim}Runs: doctor → ctx → scan → ship → report${c.reset}
+
+  ${c.bold}OPTIONS${c.reset}
+    ${c.cyan}--fast${c.reset}            Skip optional checks for speed
+    ${c.cyan}--no-open${c.reset}         Don't open report in browser
+    ${c.cyan}--path, -p <dir>${c.reset}  Project path ${c.dim}(default: current directory)${c.reset}
+    ${c.cyan}--json${c.reset}            Output as JSON
+    ${c.cyan}--quiet, -q${c.reset}       Suppress non-essential output
+    ${c.cyan}--help, -h${c.reset}        Show this help
+
+  ${c.bold}EXAMPLES${c.reset}
+    ${c.dim}# Quick onboarding${c.reset}
+    vibecheck quickstart
+
+    ${c.dim}# Fast mode (skip optional checks)${c.reset}
+    vibecheck quickstart --fast
+
+    ${c.dim}# JSON output for automation${c.reset}
+    vibecheck quickstart --json
+`);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// STEP RUNNERS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function runDoctorStep(projectPath, opts) {
+  const { runDoctor } = require("./runDoctor");
+  const start = Date.now();
+  
+  try {
+    // Run doctor with quiet mode
+    const result = await runDoctor(["--quiet", "--path", projectPath]);
+    return {
+      success: result === 0,
+      duration: Date.now() - start,
+      result,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      duration: Date.now() - start,
+      error: error.message,
+    };
+  }
+}
+
+async function runContextStep(projectPath, opts) {
+  const start = Date.now();
+  
+  try {
+    // Check if context module exists
+    let runContext;
+    try {
+      runContext = require("./runContext").runContext;
+    } catch {
+      // Context might not exist, skip gracefully
+      return {
+        success: true,
+        skipped: true,
+        duration: Date.now() - start,
+        reason: "Context module not available",
+      };
+    }
+    
+    const result = await runContext(["--quiet", "--path", projectPath]);
+    return {
+      success: result === 0,
+      duration: Date.now() - start,
+      result,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      duration: Date.now() - start,
+      error: error.message,
+    };
+  }
+}
+
+async function runScanStep(projectPath, opts) {
+  const { runScan } = require("./runScan");
+  const start = Date.now();
+  
+  try {
+    const scanArgs = ["--path", projectPath];
+    if (opts.fast) scanArgs.push("--no-baseline");
+    
+    const result = await runScan(scanArgs);
+    
+    // Load scan results
+    let scanData = null;
+    const latestPath = path.join(projectPath, ".vibecheck", "results", "latest.json");
+    if (fs.existsSync(latestPath)) {
+      try {
+        scanData = JSON.parse(fs.readFileSync(latestPath, "utf-8"));
+      } catch {}
+    }
+    
+    return {
+      success: true, // Scan itself succeeded even if findings exist
+      duration: Date.now() - start,
+      exitCode: result,
+      data: scanData,
+      filesScanned: scanData?.result?.stats?.filesScanned || 0,
+      findings: scanData?.result?.findings?.length || 0,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      duration: Date.now() - start,
+      error: error.message,
+    };
+  }
+}
+
+async function runShipStep(projectPath, opts, context = {}) {
+  const { runShip } = require("./runShip");
+  const start = Date.now();
+  
+  try {
+    const shipArgs = ["--path", projectPath, "--no-banner"];
+    
+    const result = await runShip(shipArgs, context);
+    
+    // Load ship results
+    let shipData = null;
+    const shipPath = path.join(projectPath, ".vibecheck", "last_ship.json");
+    if (fs.existsSync(shipPath)) {
+      try {
+        shipData = JSON.parse(fs.readFileSync(shipPath, "utf-8"));
+      } catch {}
+    }
+    
+    const verdict = shipData?.meta?.verdict || 
+                    (result === 0 ? "SHIP" : result === 1 ? "WARN" : "BLOCK");
+    
+    return {
+      success: true,
+      duration: Date.now() - start,
+      exitCode: result,
+      verdict,
+      data: shipData,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      duration: Date.now() - start,
+      error: error.message,
+    };
+  }
+}
+
+async function runReportStep(projectPath, opts) {
+  const start = Date.now();
+  
+  try {
+    let runReport;
+    try {
+      runReport = require("./runReport").runReport;
+    } catch {
+      // Report might not exist, skip gracefully
+      return {
+        success: true,
+        skipped: true,
+        duration: Date.now() - start,
+        reason: "Report module not available",
+      };
+    }
+    
+    const reportArgs = ["--format", "html", "--path", projectPath];
+    if (!opts.noOpen) reportArgs.push("--open");
+    
+    const result = await runReport(reportArgs);
+    
+    const reportPath = path.join(projectPath, ".vibecheck", "report.html");
+    
+    return {
+      success: result === 0,
+      duration: Date.now() - start,
+      reportPath: fs.existsSync(reportPath) ? reportPath : null,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      duration: Date.now() - start,
+      error: error.message,
+    };
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN QUICKSTART FUNCTION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function runQuickstart(args, context = {}) {
+  const runId = context.runId || generateRunId();
+  const startTime = context.startTime || new Date().toISOString();
+  const opts = parseArgs(args);
+  const executionStart = Date.now();
+
+  // Show help if requested
+  if (opts.help) {
+    printHelp(shouldShowBanner(opts));
+    return 0;
+  }
+
+  const projectPath = path.resolve(opts.path);
+  const projectName = path.basename(projectPath);
+
+  // Print banner
+  if (shouldShowBanner(opts)) {
+    printBanner();
+    console.log(`  ${c.dim}Project:${c.reset} ${c.bold}${projectName}${c.reset}`);
+    console.log(`  ${c.dim}Path:${c.reset}    ${projectPath}`);
+    console.log();
+  }
+
+  // Validate project path
+  if (!fs.existsSync(projectPath)) {
+    console.error(`${c.red}${sym.cross}${c.reset} Project path does not exist: ${projectPath}`);
+    return EXIT.USER_ERROR;
+  }
+
+  const steps = [
+    { name: "Doctor", description: "checking environment", runner: runDoctorStep },
+    { name: "Context", description: "generating truth pack", runner: runContextStep },
+    { name: "Scan", description: "analyzing code", runner: runScanStep },
+    { name: "Ship", description: "computing verdict", runner: runShipStep },
+    { name: "Report", description: "generating report", runner: runReportStep },
+  ];
+
+  const results = {};
+  let lastResult = null;
+  let hasError = false;
+
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    
+    if (!opts.json && !opts.quiet) {
+      printStepStart(i + 1, steps.length, step.name, step.description);
+    }
+
+    const stepResult = await step.runner(projectPath, opts, context);
+    results[step.name.toLowerCase()] = stepResult;
+    lastResult = stepResult;
+
+    if (!opts.json && !opts.quiet) {
+      if (stepResult.skipped) {
+        printStepSkipped(step.name, stepResult.reason);
+      } else if (stepResult.success) {
+        let detail = "";
+        if (step.name === "Scan" && stepResult.findings !== undefined) {
+          detail = `${stepResult.findings} findings`;
+        }
+        if (step.name === "Ship" && stepResult.verdict) {
+          detail = stepResult.verdict;
+        }
+        printStepSuccess(step.name, stepResult.duration, detail);
+      } else {
+        printStepFailure(step.name, stepResult.error);
+        hasError = true;
+        // Don't break - try to continue with remaining steps
+      }
+    }
+  }
+
+  const totalDuration = Date.now() - executionStart;
+
+  // Get final verdict from ship step
+  const shipResult = results.ship;
+  const scanResult = results.scan;
+  const verdict = shipResult?.verdict || "UNKNOWN";
+  const score = shipResult?.data?.proofGraph?.summary?.riskScore 
+    ? 100 - shipResult.data.proofGraph.summary.riskScore 
+    : scanResult?.data?.result?.score || 0;
+  const findings = shipResult?.data?.findings || scanResult?.data?.result?.findings || [];
+
+  // JSON output
+  if (opts.json) {
+    const output = createJsonOutput({
+      runId,
+      command: "quickstart",
+      startTime,
+      exitCode: hasError ? EXIT.INTERNAL_ERROR : (shipResult?.exitCode || 0),
+      verdict,
+      result: {
+        verdict,
+        score,
+        steps: results,
+        duration: totalDuration,
+        findings: findings.length,
+        reportPath: results.report?.reportPath,
+        dashboardUrl: `${DASHBOARD_URL}/runs/${runId}`,
+      },
+      artifacts: [
+        results.report?.reportPath && {
+          type: "report",
+          path: results.report.reportPath,
+          description: "HTML report",
+        },
+      ].filter(Boolean),
+    });
+    
+    writeJsonOutput(output, opts.output);
+    return output.exitCode;
+  }
+
+  // Human-readable output
+  if (!opts.quiet) {
+    // Print verdict box
+    printVerdictBox(verdict, score, findings);
+    
+    // Print report location
+    if (results.report?.reportPath) {
+      console.log(`  ${sym.doc} ${c.bold}Report:${c.reset} ${results.report.reportPath}`);
+    }
+    
+    // Print dashboard link
+    console.log(`  ${sym.link} ${c.bold}Dashboard:${c.reset} ${DASHBOARD_URL}/runs/${runId}`);
+    console.log();
+    
+    // Print completion time
+    console.log(`  ${sym.clock} ${c.dim}Completed in ${(totalDuration / 1000).toFixed(1)}s${c.reset}`);
+    console.log();
+    
+    // Print next action
+    const { getNextActionForCommand } = require("./lib/next-action");
+    const tier = context?.authInfo?.access?.tier || "free";
+    const nextAction = getNextActionForCommand("ship", { verdict, runId, findings }, tier);
+    console.log(formatNextAction(nextAction));
+  }
+
+  // Save quickstart summary
+  saveArtifact(runId, "quickstart-summary", {
+    verdict,
+    score,
+    duration: totalDuration,
+    steps: Object.fromEntries(
+      Object.entries(results).map(([k, v]) => [k, { 
+        success: v.success, 
+        duration: v.duration,
+        skipped: v.skipped || false,
+      }])
+    ),
+    timestamp: new Date().toISOString(),
+  });
+
+  // Return ship exit code
+  return shipResult?.exitCode || 0;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXPORTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+module.exports = {
+  runQuickstart: withErrorHandling(runQuickstart, "Quickstart failed"),
+};

package/bin/runners/runReality.js

@@ -32,6 +32,7 @@ const { parseGlobalFlags, shouldShowBanner } = require("./lib/global-flags");
 
 // Entitlements enforcement
 const entitlements = require("./lib/entitlements-v2");
+const upsell = require("./lib/upsell");
 
 let chromium;
 let playwrightError = null;
@@ -2076,6 +2077,19 @@ async function runReality(argsOrOpts = {}) {
     console.log();
   }
 
+  // Upsell for free tier users running in preview mode
+  const currentTier = entitlements.getCurrentTierSync ? entitlements.getCurrentTierSync() : 'free';
+  if (currentTier === 'free') {
+    console.log(upsell.formatEarnedUpsell({
+      cmd: "reality",
+      why: "cap_hit",
+      topIssues: findings.slice(0, 5),
+      upgradeTier: "starter",
+    }));
+    console.log(upsell.formatNextSteps("reality", blocks > 0 ? "BLOCK" : warns > 0 ? "WARN" : "SHIP", currentTier));
+    console.log();
+  }
+
   process.exitCode = blocks ? 2 : warns ? 1 : 0;
   return process.exitCode;
 }

package/bin/runners/runReport.js

@@ -18,6 +18,8 @@
 const path = require("path");
 const fs = require("fs");
 const { parseGlobalFlags, shouldShowBanner } = require("./lib/global-flags");
+const { EXIT } = require("./lib/exit-codes");
+const { ensureScanResults } = require("./lib/prerequisites");
 
 // Entitlements enforcement
 let entitlements;
@@ -201,13 +203,43 @@ async function runReport(args) {
   const spinner = new Spinner({ color: colors.accent });
   spinner.start(`Generating ${opts.type} report`);
 
-  // Load ship results
+  // Auto-run scan if results are missing (unless in CI or explicitly disabled)
+  const scanPrereq = await ensureScanResults(projectPath, {
+    quiet: opts.quiet,
+    json: opts.json,
+    ci: opts.ci,
+    colors,
+    icons,
+    ansi,
+  });
+  
+  if (scanPrereq.ran && !scanPrereq.success && !opts.quiet) {
+    spinner.warn("Auto-run scan failed - continuing with available data");
+  }
+
+  // Load ship results (prefer ship results, fall back to scan results)
   let shipResults = loadShipResults(projectPath, outputDir);
+  
+  // If no ship results, try to load scan results
+  if (!shipResults) {
+    const scanResultsPath = path.join(projectPath, ".vibecheck", "results", "latest.json");
+    if (fs.existsSync(scanResultsPath)) {
+      try {
+        const scanData = JSON.parse(fs.readFileSync(scanResultsPath, "utf8"));
+        shipResults = {
+          score: scanData.result?.score || scanData.score || 0,
+          verdict: scanData.result?.verdict || scanData.verdict || "UNKNOWN",
+          findings: scanData.result?.findings || scanData.findings || [],
+          truthpack: scanData.truthpack || null,
+        };
+      } catch {}
+    }
+  }
 
   if (!shipResults) {
     spinner.warn("No scan results found - using demo data");
     if (!opts.quiet) {
-      console.log(`  ${ansi.dim}Tip: Run 'vibecheck ship' first for real results.${ansi.reset}\n`);
+      console.log(`  ${ansi.dim}Tip: Run 'vibecheck scan' first for real results.${ansi.reset}\n`);
     }
     shipResults = getDemoData();
   }
@@ -264,11 +296,11 @@ async function runReport(args) {
       default:
         spinner.fail(`Unknown format: ${format}`);
         console.log(`  ${ansi.dim}Supported: html, md, json, sarif, csv, pdf${ansi.reset}`);
-        return 1;
+        return EXIT.USER_ERROR;
     }
   } catch (err) {
     spinner.fail(`Failed to generate report: ${err.message}`);
-    return 1;
+    return EXIT.INTERNAL_ERROR;
   }
 
   // Determine output path