@vibecheckai/cli 3.5.0 → 3.5.2

package/bin/runners/lib/next-action.js

@@ -0,0 +1,560 @@
+/**
+ * Next Best Action Engine
+ * 
+ * Single source of truth for "what should user do next?"
+ * Used across CLI, Web, VS Code, and MCP to provide consistent guidance.
+ * 
+ * @module bin/runners/lib/next-action
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONSTANTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const PRICING_URL = "https://vibecheckai.dev/pricing";
+const DASHBOARD_URL = "https://app.vibecheckai.dev";
+const DOCS_URL = "https://docs.vibecheckai.dev";
+
+// Time estimates for each command (in seconds, displayed as human-readable)
+const TIME_ESTIMATES = {
+  init: "~30 seconds",
+  doctor: "~10 seconds",
+  ctx: "~10 seconds",
+  scan: "~45 seconds",
+  ship: "~15 seconds",
+  report: "~5 seconds",
+  fix: "~30 seconds",
+  prove: "~2 minutes",
+  watch: "continuous",
+  badge: "~5 seconds",
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ANSI STYLING (for CLI output)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const SUPPORTS_COLOR = process.stdout.isTTY && !process.env.NO_COLOR;
+
+const c = SUPPORTS_COLOR ? {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  magenta: "\x1b[35m",
+  red: "\x1b[31m",
+  gray: "\x1b[90m",
+  underline: "\x1b[4m",
+} : {
+  reset: "", bold: "", dim: "", cyan: "", green: "", yellow: "",
+  magenta: "", red: "", gray: "", underline: "",
+};
+
+const sym = {
+  arrow: "→",
+  check: "✓",
+  star: "★",
+  rocket: "🚀",
+  link: "🔗",
+  clock: "⏱",
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// STATE DETECTION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Detect current project state for next action computation
+ * @param {string} projectPath - Path to project root
+ * @returns {object} Project state
+ */
+function detectProjectState(projectPath) {
+  const state = {
+    hasConfig: false,
+    hasTruthpack: false,
+    lastDoctorStatus: null,
+    lastScan: null,
+    lastShip: null,
+    tier: "free",
+    runId: null,
+    githubConnected: false,
+    limits: null,
+  };
+
+  try {
+    // Check for config file
+    const configPath = path.join(projectPath, ".vibecheckrc");
+    state.hasConfig = fs.existsSync(configPath);
+
+    // Check for truthpack
+    const truthpackPath = path.join(projectPath, ".vibecheck", "truthpack.json");
+    state.hasTruthpack = fs.existsSync(truthpackPath);
+
+    // Check for latest scan results
+    const latestScanPath = path.join(projectPath, ".vibecheck", "results", "latest.json");
+    if (fs.existsSync(latestScanPath)) {
+      try {
+        const scanData = JSON.parse(fs.readFileSync(latestScanPath, "utf-8"));
+        state.lastScan = {
+          verdict: scanData.result?.verdict || scanData.verdict,
+          score: scanData.result?.score || scanData.score,
+          findings: scanData.result?.findings?.length || 0,
+          runId: scanData.runId,
+          timestamp: scanData.timestamp || scanData.startTime,
+        };
+        state.runId = scanData.runId;
+      } catch {}
+    }
+
+    // Check for ship results
+    const lastShipPath = path.join(projectPath, ".vibecheck", "last_ship.json");
+    if (fs.existsSync(lastShipPath)) {
+      try {
+        const shipData = JSON.parse(fs.readFileSync(lastShipPath, "utf-8"));
+        state.lastShip = {
+          verdict: shipData.meta?.verdict || shipData.verdict,
+          findings: shipData.findings?.length || 0,
+          timestamp: shipData.meta?.generatedAt,
+        };
+      } catch {}
+    }
+
+    // Check summary for latest run info
+    const summaryPath = path.join(projectPath, ".vibecheck", "summary.json");
+    if (fs.existsSync(summaryPath)) {
+      try {
+        const summary = JSON.parse(fs.readFileSync(summaryPath, "utf-8"));
+        if (summary.runId) state.runId = summary.runId;
+        if (summary.verdict && !state.lastShip) {
+          state.lastShip = {
+            verdict: summary.verdict,
+            score: summary.score,
+          };
+        }
+      } catch {}
+    }
+
+  } catch (error) {
+    // Silently handle errors - return partial state
+  }
+
+  return state;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// NEXT ACTION COMPUTATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Compute next best action based on project state
+ * @param {object} state - Project state (from detectProjectState or manual)
+ * @returns {object} Next action recommendation
+ */
+function computeNextAction(state) {
+  const {
+    hasConfig = false,
+    hasTruthpack = false,
+    lastDoctorStatus = null,
+    lastScan = null,
+    lastShip = null,
+    tier = "free",
+    runId = null,
+  } = state;
+
+  const isPro = tier === "pro" || tier === "starter" || tier === "enterprise";
+
+  // Priority order: setup → scan → ship → fix → prove
+
+  // 1. No config - need init
+  if (!hasConfig) {
+    return {
+      action: "init",
+      command: "vibecheck init",
+      dashboardLink: null,
+      why: "Project not initialized. Run init to create config and Truth Pack.",
+      timeEstimate: TIME_ESTIMATES.init,
+      tier: "free",
+      priority: "high",
+    };
+  }
+
+  // 2. No truthpack - need context
+  if (!hasTruthpack) {
+    return {
+      action: "ctx",
+      command: "vibecheck context",
+      dashboardLink: null,
+      why: "Truth Pack missing. Generate context for accurate analysis.",
+      timeEstimate: TIME_ESTIMATES.ctx,
+      tier: "free",
+      priority: "high",
+    };
+  }
+
+  // 3. No scans yet - run first scan
+  if (!lastScan) {
+    return {
+      action: "scan",
+      command: "vibecheck scan",
+      dashboardLink: `${DASHBOARD_URL}/scan`,
+      why: "No scans yet. Run your first scan to detect issues.",
+      timeEstimate: TIME_ESTIMATES.scan,
+      tier: "free",
+      priority: "high",
+    };
+  }
+
+  // 4. Has scan but no ship verdict (PRO only)
+  if (!lastShip && isPro) {
+    return {
+      action: "ship",
+      command: "vibecheck ship",
+      dashboardLink: `${DASHBOARD_URL}/ship`,
+      why: "Scan complete. Get your SHIP/WARN/BLOCK verdict.",
+      timeEstimate: TIME_ESTIMATES.ship,
+      tier: "pro",
+      priority: "medium",
+    };
+  }
+
+  // 5. Ship passed - suggest badge (PRO)
+  if (lastShip?.verdict === "SHIP" && isPro) {
+    return {
+      action: "badge",
+      command: "vibecheck ship --badge",
+      dashboardLink: `${DASHBOARD_URL}/runs/${runId}`,
+      why: "SHIP passed! Generate a verified badge for your README.",
+      timeEstimate: TIME_ESTIMATES.badge,
+      tier: "pro",
+      priority: "low",
+    };
+  }
+
+  // 6. Ship failed with issues - suggest fix (PRO)
+  if (lastShip && lastShip.verdict !== "SHIP" && isPro) {
+    const issueCount = lastShip.findings || lastScan?.findings || 0;
+    return {
+      action: "fix",
+      command: "vibecheck fix",
+      dashboardLink: `${DASHBOARD_URL}/findings`,
+      why: `${issueCount} issue${issueCount !== 1 ? "s" : ""} found. Auto-fix them.`,
+      timeEstimate: TIME_ESTIMATES.fix,
+      tier: "pro",
+      priority: "high",
+    };
+  }
+
+  // 7. Free tier after scan - suggest report or upgrade
+  if (tier === "free") {
+    return {
+      action: "report",
+      command: "vibecheck report",
+      dashboardLink: `${DASHBOARD_URL}/runs/${runId}`,
+      why: "Scan complete. Export report or upgrade to get verdict.",
+      timeEstimate: TIME_ESTIMATES.report,
+      tier: "free",
+      priority: "medium",
+      upgradeHint: {
+        feature: "Ship Verdict",
+        benefit: "Get SHIP/WARN/BLOCK verdict with evidence",
+        url: PRICING_URL,
+      },
+    };
+  }
+
+  // 8. Default: watch mode for continuous monitoring
+  return {
+    action: "watch",
+    command: "vibecheck watch",
+    dashboardLink: `${DASHBOARD_URL}/dashboard`,
+    why: "All caught up. Enable watch mode for continuous verification.",
+    timeEstimate: TIME_ESTIMATES.watch,
+    tier: "free",
+    priority: "low",
+  };
+}
+
+/**
+ * Get next action for a specific command completion
+ * @param {string} completedCmd - Command that just completed
+ * @param {object} result - Result of the command
+ * @param {string} tier - User's tier
+ * @returns {object} Next action
+ */
+function getNextActionForCommand(completedCmd, result = {}, tier = "free") {
+  const isPro = tier === "pro" || tier === "starter" || tier === "enterprise";
+  const verdict = result.verdict;
+  const runId = result.runId;
+  const findings = result.findings?.length || 0;
+
+  switch (completedCmd) {
+    case "init":
+      return {
+        action: "scan",
+        command: "vibecheck scan",
+        dashboardLink: `${DASHBOARD_URL}/scan`,
+        why: "Setup complete. Run your first scan.",
+        timeEstimate: TIME_ESTIMATES.scan,
+        tier: "free",
+      };
+
+    case "doctor":
+      return {
+        action: "scan",
+        command: "vibecheck scan",
+        dashboardLink: `${DASHBOARD_URL}/scan`,
+        why: "Environment healthy. Run a scan to check your code.",
+        timeEstimate: TIME_ESTIMATES.scan,
+        tier: "free",
+      };
+
+    case "scan":
+      if (isPro) {
+        return {
+          action: "ship",
+          command: "vibecheck ship",
+          dashboardLink: `${DASHBOARD_URL}/ship`,
+          why: `Scan complete (${findings} findings). Get your verdict.`,
+          timeEstimate: TIME_ESTIMATES.ship,
+          tier: "pro",
+        };
+      }
+      return {
+        action: "report",
+        command: "vibecheck report",
+        dashboardLink: `${DASHBOARD_URL}/runs/${runId}`,
+        why: `Scan complete. Export report.`,
+        timeEstimate: TIME_ESTIMATES.report,
+        tier: "free",
+        upgradeHint: {
+          feature: "Ship Verdict",
+          benefit: "Get SHIP/WARN/BLOCK verdict",
+          url: PRICING_URL,
+        },
+      };
+
+    case "ship":
+      if (verdict === "SHIP" && isPro) {
+        return {
+          action: "badge",
+          command: "vibecheck ship --badge",
+          dashboardLink: `${DASHBOARD_URL}/runs/${runId}`,
+          why: "SHIP passed! Generate a verified badge.",
+          timeEstimate: TIME_ESTIMATES.badge,
+          tier: "pro",
+        };
+      }
+      if (verdict !== "SHIP" && isPro) {
+        return {
+          action: "fix",
+          command: "vibecheck fix",
+          dashboardLink: `${DASHBOARD_URL}/findings`,
+          why: `${findings} issues blocking ship. Auto-fix them.`,
+          timeEstimate: TIME_ESTIMATES.fix,
+          tier: "pro",
+        };
+      }
+      return {
+        action: "report",
+        command: "vibecheck report",
+        dashboardLink: `${DASHBOARD_URL}/runs/${runId}`,
+        why: "Export detailed report.",
+        timeEstimate: TIME_ESTIMATES.report,
+        tier: "free",
+      };
+
+    case "fix":
+      return {
+        action: "ship",
+        command: "vibecheck ship",
+        dashboardLink: `${DASHBOARD_URL}/ship`,
+        why: "Fixes applied. Verify with ship.",
+        timeEstimate: TIME_ESTIMATES.ship,
+        tier: "pro",
+      };
+
+    case "report":
+      if (isPro) {
+        return {
+          action: "ship",
+          command: "vibecheck ship",
+          dashboardLink: `${DASHBOARD_URL}/ship`,
+          why: "Report generated. Get your verdict.",
+          timeEstimate: TIME_ESTIMATES.ship,
+          tier: "pro",
+        };
+      }
+      return {
+        action: "watch",
+        command: "vibecheck watch",
+        dashboardLink: `${DASHBOARD_URL}/dashboard`,
+        why: "Enable watch for continuous monitoring.",
+        timeEstimate: TIME_ESTIMATES.watch,
+        tier: "free",
+      };
+
+    default:
+      return computeNextAction({ tier });
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// FORMATTING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Format next action for CLI output
+ * @param {object} nextAction - Result from computeNextAction
+ * @param {object} opts - Options
+ * @returns {string} Formatted string
+ */
+function formatNextAction(nextAction, opts = {}) {
+  const { color = true, compact = false } = opts;
+  const cc = color ? c : { reset: "", bold: "", dim: "", cyan: "", green: "", magenta: "", gray: "", underline: "" };
+
+  if (compact) {
+    return `${cc.dim}Next:${cc.reset} ${cc.cyan}${nextAction.command}${cc.reset}`;
+  }
+
+  let output = "";
+  
+  // Box header
+  output += `\n${cc.dim}┌─────────────────────────────────────────────────────────────────────┐${cc.reset}\n`;
+  output += `${cc.dim}│${cc.reset} ${cc.bold}NEXT BEST ACTION${cc.reset}${" ".repeat(51)}${cc.dim}│${cc.reset}\n`;
+  output += `${cc.dim}├─────────────────────────────────────────────────────────────────────┤${cc.reset}\n`;
+  
+  // Command
+  output += `${cc.dim}│${cc.reset}  ${cc.cyan}${sym.arrow}${cc.reset} ${cc.bold}${nextAction.command}${cc.reset}`;
+  output += `${" ".repeat(Math.max(1, 54 - nextAction.command.length))}`;
+  output += `${cc.dim}${nextAction.timeEstimate}${cc.reset} ${cc.dim}│${cc.reset}\n`;
+  
+  // Why
+  const whyTruncated = nextAction.why.length > 60 ? nextAction.why.slice(0, 57) + "..." : nextAction.why;
+  output += `${cc.dim}│${cc.reset}  ${cc.gray}${whyTruncated}${cc.reset}`;
+  output += `${" ".repeat(Math.max(1, 67 - whyTruncated.length))}${cc.dim}│${cc.reset}\n`;
+  
+  // Dashboard link
+  if (nextAction.dashboardLink) {
+    output += `${cc.dim}│${cc.reset}  ${cc.dim}${sym.link}${cc.reset} ${cc.underline}${nextAction.dashboardLink}${cc.reset}`;
+    const linkLen = nextAction.dashboardLink.length + 4;
+    output += `${" ".repeat(Math.max(1, 67 - linkLen))}${cc.dim}│${cc.reset}\n`;
+  }
+  
+  // Upgrade hint
+  if (nextAction.upgradeHint) {
+    output += `${cc.dim}│${cc.reset}  ${cc.magenta}${sym.star} PRO:${cc.reset} ${nextAction.upgradeHint.benefit}`;
+    const hintLen = nextAction.upgradeHint.benefit.length + 8;
+    output += `${" ".repeat(Math.max(1, 67 - hintLen))}${cc.dim}│${cc.reset}\n`;
+  }
+  
+  output += `${cc.dim}└─────────────────────────────────────────────────────────────────────┘${cc.reset}\n`;
+
+  return output;
+}
+
+/**
+ * Format next action as simple one-liner
+ * @param {object} nextAction 
+ * @param {object} opts 
+ * @returns {string}
+ */
+function formatNextActionOneLine(nextAction, opts = {}) {
+  const { color = true } = opts;
+  const cc = color ? c : { reset: "", dim: "", cyan: "", magenta: "" };
+  
+  let line = `${cc.dim}Next:${cc.reset} ${cc.cyan}${nextAction.command}${cc.reset}`;
+  
+  if (nextAction.dashboardLink) {
+    line += ` ${cc.dim}|${cc.reset} ${nextAction.dashboardLink}`;
+  }
+  
+  if (nextAction.upgradeHint) {
+    line += ` ${cc.dim}|${cc.reset} ${cc.magenta}PRO: ${nextAction.upgradeHint.feature}${cc.reset}`;
+  }
+  
+  return line;
+}
+
+/**
+ * Format dashboard link for CLI output
+ * @param {string} runId - Run ID
+ * @param {string} type - Type of link (runs, findings, ship)
+ * @returns {string}
+ */
+function formatDashboardLink(runId, type = "runs") {
+  const url = runId 
+    ? `${DASHBOARD_URL}/${type}/${runId}`
+    : `${DASHBOARD_URL}/${type}`;
+  return `${c.dim}Dashboard:${c.reset} ${url}`;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// JSON OUTPUT (for MCP, API, VS Code)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Get next action as JSON (for MCP tool, API, VS Code)
+ * @param {string} projectPath 
+ * @param {string} tier 
+ * @returns {object}
+ */
+function getNextActionJson(projectPath, tier = "free") {
+  const state = detectProjectState(projectPath);
+  state.tier = tier;
+  const nextAction = computeNextAction(state);
+  
+  return {
+    action: nextAction.action,
+    command: nextAction.command,
+    cliCommand: `vibecheck ${nextAction.action}`,
+    dashboardLink: nextAction.dashboardLink,
+    docsLink: `${DOCS_URL}/cli/${nextAction.action}`,
+    why: nextAction.why,
+    timeEstimate: nextAction.timeEstimate,
+    requiredTier: nextAction.tier,
+    priority: nextAction.priority,
+    upgradeHint: nextAction.upgradeHint || null,
+    projectState: {
+      hasConfig: state.hasConfig,
+      hasTruthpack: state.hasTruthpack,
+      lastScanVerdict: state.lastScan?.verdict || null,
+      lastShipVerdict: state.lastShip?.verdict || null,
+      runId: state.runId,
+    },
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXPORTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+module.exports = {
+  // Core functions
+  computeNextAction,
+  getNextActionForCommand,
+  detectProjectState,
+  
+  // Formatting
+  formatNextAction,
+  formatNextActionOneLine,
+  formatDashboardLink,
+  
+  // JSON output
+  getNextActionJson,
+  
+  // Constants
+  PRICING_URL,
+  DASHBOARD_URL,
+  DOCS_URL,
+  TIME_ESTIMATES,
+  
+  // Styling (for consistent use elsewhere)
+  c,
+  sym,
+};

package/bin/runners/lib/prerequisites.js

@@ -0,0 +1,149 @@
+/**
+ * Prerequisite Auto-Running
+ * 
+ * Automatically runs prerequisites (like scan) if they're missing
+ * to improve UX - users don't need to know the correct command order.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Check if scan results exist
+ */
+function hasScanResults(projectPath) {
+  const latestPath = path.join(projectPath, ".vibecheck", "results", "latest.json");
+  return fs.existsSync(latestPath);
+}
+
+/**
+ * Check if ship results exist
+ */
+function hasShipResults(projectPath) {
+  const shipPath = path.join(projectPath, ".vibecheck", "last_ship.json");
+  return fs.existsSync(shipPath);
+}
+
+/**
+ * Check if truthpack exists
+ */
+function hasTruthpack(projectPath) {
+  const truthpackPath = path.join(projectPath, ".vibecheck", "truthpack.json");
+  return fs.existsSync(truthpackPath);
+}
+
+/**
+ * Auto-run scan if results are missing
+ */
+async function ensureScanResults(projectPath, opts = {}) {
+  if (hasScanResults(projectPath)) {
+    return { ran: false, reason: "Scan results already exist" };
+  }
+
+  // Don't auto-run in CI or if explicitly disabled
+  if (opts.ci || opts.noAutoRun || process.env.CI) {
+    return { ran: false, reason: "Auto-run disabled (CI mode or --no-auto-run)" };
+  }
+
+  try {
+    const { runScan } = require("../runScan");
+    
+    if (!opts.quiet && !opts.json) {
+      console.log(`\n  ${opts.colors?.info || ''}${opts.icons?.info || 'ℹ'}${opts.ansi?.reset || ''} No scan results found. Running scan first...\n`);
+    }
+
+    const scanArgs = ["--path", projectPath, "--offline", "--quiet"];
+    if (opts.json) scanArgs.push("--json");
+    
+    const exitCode = await runScan(scanArgs);
+    
+    if (hasScanResults(projectPath)) {
+      return { ran: true, exitCode, success: true };
+    } else {
+      return { ran: true, exitCode, success: false, reason: "Scan completed but no results file created" };
+    }
+  } catch (error) {
+    return { ran: true, success: false, error: error.message };
+  }
+}
+
+/**
+ * Auto-run ship if results are missing (for commands that need ship results)
+ */
+async function ensureShipResults(projectPath, opts = {}) {
+  if (hasShipResults(projectPath)) {
+    return { ran: false, reason: "Ship results already exist" };
+  }
+
+  // Don't auto-run in CI or if explicitly disabled
+  if (opts.ci || opts.noAutoRun || process.env.CI) {
+    return { ran: false, reason: "Auto-run disabled (CI mode or --no-auto-run)" };
+  }
+
+  try {
+    const { runShip } = require("../runShip");
+    
+    if (!opts.quiet && !opts.json) {
+      console.log(`\n  ${opts.colors?.info || ''}${opts.icons?.info || 'ℹ'}${opts.ansi?.reset || ''} No ship results found. Running ship first...\n`);
+    }
+
+    const shipArgs = ["--path", projectPath, "--no-banner", "--offline"];
+    if (opts.quiet) shipArgs.push("--quiet");
+    if (opts.json) shipArgs.push("--json");
+    
+    const exitCode = await runShip(shipArgs);
+    
+    if (hasShipResults(projectPath)) {
+      return { ran: true, exitCode, success: true };
+    } else {
+      return { ran: true, exitCode, success: false, reason: "Ship completed but no results file created" };
+    }
+  } catch (error) {
+    return { ran: true, success: false, error: error.message };
+  }
+}
+
+/**
+ * Auto-run context if truthpack is missing
+ */
+async function ensureTruthpack(projectPath, opts = {}) {
+  if (hasTruthpack(projectPath)) {
+    return { ran: false, reason: "Truthpack already exists" };
+  }
+
+  // Don't auto-run in CI or if explicitly disabled
+  if (opts.ci || opts.noAutoRun || process.env.CI) {
+    return { ran: false, reason: "Auto-run disabled (CI mode or --no-auto-run)" };
+  }
+
+  try {
+    const { runContext } = require("../runContext");
+    
+    if (!opts.quiet && !opts.json) {
+      console.log(`\n  ${opts.colors?.info || ''}${opts.icons?.info || 'ℹ'}${opts.ansi?.reset || ''} No truthpack found. Generating context first...\n`);
+    }
+
+    const contextArgs = ["--path", projectPath];
+    if (opts.quiet) contextArgs.push("--quiet");
+    if (opts.json) contextArgs.push("--json");
+    
+    const exitCode = await runContext(contextArgs);
+    
+    if (hasTruthpack(projectPath)) {
+      return { ran: true, exitCode, success: true };
+    } else {
+      return { ran: true, exitCode, success: false, reason: "Context completed but no truthpack created" };
+    }
+  } catch (error) {
+    return { ran: true, success: false, error: error.message };
+  }
+}
+
+module.exports = {
+  hasScanResults,
+  hasShipResults,
+  hasTruthpack,
+  ensureScanResults,
+  ensureShipResults,
+  ensureTruthpack,
+};