@vibecheckai/cli 3.1.2 → 3.1.4

package/bin/runners/runCheckpoint.js

@@ -0,0 +1,502 @@
+/**
+ * vibecheck checkpoint - Compare Baseline vs Current
+ * 
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * Compares baseline scan results with current state to track progress:
+ * - Fixed issues
+ * - Remaining issues
+ * - Regressions (new issues)
+ * - Hallucination scoring (PRO)
+ * ═══════════════════════════════════════════════════════════════════════════════
+ */
+
+const fs = require("fs");
+const path = require("path");
+const entitlements = require("./lib/entitlements-v2");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TERMINAL STYLING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+};
+
+const icons = {
+  check: '✓',
+  cross: '✗',
+  arrow: '→',
+  warning: '⚠',
+  info: 'ℹ',
+  star: '★',
+  rocket: '🚀',
+  target: '🎯',
+  chart: '📊',
+  brain: '🧠',
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CHECKPOINT CORE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function loadResults(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+function getFindingId(finding) {
+  // Create a stable ID for a finding based on its properties
+  return `${finding.id || finding.type || 'unknown'}-${finding.file || ''}-${finding.line || 0}`;
+}
+
+function compareFindingSets(baseline, current) {
+  const baselineSet = new Set(baseline.map(getFindingId));
+  const currentSet = new Set(current.map(getFindingId));
+  const baselineMap = new Map(baseline.map(f => [getFindingId(f), f]));
+  const currentMap = new Map(current.map(f => [getFindingId(f), f]));
+  
+  const fixed = [];
+  const remaining = [];
+  const regressions = [];
+  
+  // Find fixed (in baseline but not in current)
+  for (const id of baselineSet) {
+    if (!currentSet.has(id)) {
+      fixed.push(baselineMap.get(id));
+    }
+  }
+  
+  // Find remaining (in both)
+  for (const id of baselineSet) {
+    if (currentSet.has(id)) {
+      remaining.push(currentMap.get(id));
+    }
+  }
+  
+  // Find regressions (in current but not in baseline)
+  for (const id of currentSet) {
+    if (!baselineSet.has(id)) {
+      regressions.push(currentMap.get(id));
+    }
+  }
+  
+  return { fixed, remaining, regressions };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// HALLUCINATION DETECTION (PRO)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function detectHallucinations(baseline, current, projectPath) {
+  const hallucinations = {
+    nonexistentRoutes: [],
+    nonexistentEnvVars: [],
+    nonexistentImports: [],
+    nonexistentFunctions: [],
+    contractDriftViolations: [],
+    score: 0,
+  };
+  
+  // Load truthpack if available
+  const truthpackPath = path.join(projectPath, '.vibecheck', 'truthpack.json');
+  let truthpack = null;
+  if (fs.existsSync(truthpackPath)) {
+    try {
+      truthpack = JSON.parse(fs.readFileSync(truthpackPath, 'utf8'));
+    } catch (e) {
+      // Ignore
+    }
+  }
+  
+  // Check for edits introducing nonexistent routes
+  if (truthpack?.routes?.server) {
+    const validRoutes = new Set(truthpack.routes.server.map(r => r.path || r.route));
+    
+    for (const finding of current) {
+      if (finding.type === 'route-reference' || finding.category === 'routes') {
+        const referencedRoute = finding.route || finding.path;
+        if (referencedRoute && !validRoutes.has(referencedRoute)) {
+          hallucinations.nonexistentRoutes.push({
+            finding,
+            referencedRoute,
+            reason: 'Route does not exist in truthpack',
+          });
+        }
+      }
+    }
+  }
+  
+  // Check for env vars
+  if (truthpack?.env?.vars) {
+    const validEnvVars = new Set(truthpack.env.vars.map(v => v.name || v));
+    
+    for (const finding of current) {
+      if (finding.type === 'env-reference' || finding.category === 'env') {
+        const referencedVar = finding.envVar || finding.name;
+        if (referencedVar && !validEnvVars.has(referencedVar)) {
+          hallucinations.nonexistentEnvVars.push({
+            finding,
+            referencedVar,
+            reason: 'Environment variable not declared',
+          });
+        }
+      }
+    }
+  }
+  
+  // Load contracts and check for drift violations
+  const contractsPath = path.join(projectPath, '.vibecheck', 'contracts');
+  if (fs.existsSync(contractsPath)) {
+    // Check route contract
+    const routeContractPath = path.join(contractsPath, 'routes.contract.json');
+    if (fs.existsSync(routeContractPath)) {
+      try {
+        const routeContract = JSON.parse(fs.readFileSync(routeContractPath, 'utf8'));
+        const contractedRoutes = new Set(routeContract.routes?.map(r => r.path) || []);
+        
+        // Check if current introduces routes not in contract
+        if (truthpack?.routes?.server) {
+          for (const route of truthpack.routes.server) {
+            const routePath = route.path || route.route;
+            if (routePath && !contractedRoutes.has(routePath)) {
+              hallucinations.contractDriftViolations.push({
+                type: 'route-drift',
+                route: routePath,
+                reason: 'Route exists but not in contract',
+              });
+            }
+          }
+        }
+      } catch (e) {
+        // Ignore
+      }
+    }
+  }
+  
+  // Calculate hallucination score (0-100, lower is better)
+  const totalHallucinations = 
+    hallucinations.nonexistentRoutes.length +
+    hallucinations.nonexistentEnvVars.length +
+    hallucinations.nonexistentImports.length +
+    hallucinations.nonexistentFunctions.length +
+    hallucinations.contractDriftViolations.length;
+  
+  hallucinations.score = Math.min(100, totalHallucinations * 10);
+  
+  return hallucinations;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CLI
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function parseArgs(args) {
+  const opts = {
+    help: false,
+    json: false,
+    baseline: null,
+    current: null,
+    hallucination: false,
+    save: false,
+    path: process.cwd(),
+  };
+  
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h') opts.help = true;
+    else if (arg === '--json') opts.json = true;
+    else if (arg === '--baseline' || arg === '-b') opts.baseline = args[++i];
+    else if (arg === '--current' || arg === '-c') opts.current = args[++i];
+    else if (arg === '--hallucination' || arg === '--hall') opts.hallucination = true;
+    else if (arg === '--save' || arg === '-s') opts.save = true;
+    else if (arg === '--path' || arg === '-p') opts.path = args[++i];
+    else if (!arg.startsWith('-')) opts.path = arg;
+  }
+  
+  return opts;
+}
+
+function printHelp() {
+  console.log(`
+${c.bold}${icons.target} vibecheck checkpoint${c.reset} - Compare Baseline vs Current
+
+${c.dim}Track progress by comparing scan results over time.${c.reset}
+
+${c.bold}USAGE${c.reset}
+  vibecheck checkpoint [options]
+
+${c.bold}OPTIONS${c.reset}
+  -b, --baseline <file>   Path to baseline results file
+  -c, --current <file>    Path to current results file (default: latest)
+  --hallucination         Include hallucination scoring ${c.magenta}[PRO]${c.reset}
+  -s, --save              Save checkpoint to .vibecheck/checkpoints/
+  --json                  Output as JSON
+  -p, --path <dir>        Project path (default: current directory)
+  -h, --help              Show this help
+
+${c.bold}EXAMPLES${c.reset}
+  vibecheck checkpoint                              # Compare latest vs baseline
+  vibecheck checkpoint --baseline scan-v1.json      # Use specific baseline
+  vibecheck checkpoint --hallucination              # Include AI hallucination check
+  vibecheck checkpoint --save                       # Save checkpoint report
+
+${c.bold}OUTPUT${c.reset}
+  • Fixed issues - Issues resolved since baseline
+  • Remaining issues - Issues still present
+  • Regressions - New issues introduced
+  • Hallucination score - AI-generated code issues ${c.magenta}[PRO]${c.reset}
+
+${c.bold}TIER${c.reset}
+  ${c.cyan}FREE${c.reset}  Basic comparison (fixed, remaining, regressions)
+  ${c.magenta}PRO${c.reset}   + Hallucination scoring
+`);
+}
+
+async function runCheckpoint(args) {
+  const opts = parseArgs(args);
+  
+  if (opts.help) {
+    printHelp();
+    return 0;
+  }
+  
+  const projectPath = path.resolve(opts.path);
+  const vibecheckDir = path.join(projectPath, '.vibecheck');
+  const resultsDir = path.join(vibecheckDir, 'results');
+  const checkpointsDir = path.join(vibecheckDir, 'checkpoints');
+  
+  // Check hallucination entitlement
+  if (opts.hallucination) {
+    const access = await entitlements.enforce("checkpoint.hallucination", { silent: true });
+    if (!access.allowed) {
+      console.log(`\n${c.yellow}${icons.warning}${c.reset} Hallucination scoring requires ${c.magenta}PRO${c.reset} plan.`);
+      console.log(`${c.dim}Running basic checkpoint instead...${c.reset}\n`);
+      opts.hallucination = false;
+    }
+  }
+  
+  // Load baseline
+  let baseline = null;
+  if (opts.baseline) {
+    baseline = loadResults(opts.baseline);
+  } else {
+    // Try to load from default location
+    const baselinePath = path.join(resultsDir, 'baseline.json');
+    baseline = loadResults(baselinePath);
+  }
+  
+  if (!baseline) {
+    console.log(`\n${c.yellow}${icons.warning}${c.reset} No baseline found.`);
+    console.log(`${c.dim}Run 'vibecheck scan' first to create a baseline.${c.reset}`);
+    console.log(`${c.dim}Or specify --baseline <file> to use a specific file.${c.reset}\n`);
+    
+    if (!opts.json) {
+      console.log(`${c.bold}TIP:${c.reset} Create a baseline with:`);
+      console.log(`  ${c.cyan}vibecheck scan${c.reset}`);
+      console.log(`  ${c.cyan}cp .vibecheck/results/latest.json .vibecheck/results/baseline.json${c.reset}\n`);
+    }
+    
+    return 1;
+  }
+  
+  // Load current
+  let current = null;
+  if (opts.current) {
+    current = loadResults(opts.current);
+  } else {
+    // Try to load latest
+    const latestPath = path.join(resultsDir, 'latest.json');
+    current = loadResults(latestPath);
+  }
+  
+  if (!current) {
+    console.log(`\n${c.yellow}${icons.warning}${c.reset} No current results found.`);
+    console.log(`${c.dim}Run 'vibecheck scan' to generate current results.${c.reset}\n`);
+    return 1;
+  }
+  
+  // Extract findings arrays
+  const baselineFindings = baseline.findings || baseline.results?.findings || [];
+  const currentFindings = current.findings || current.results?.findings || [];
+  
+  // Compare
+  const comparison = compareFindingSets(baselineFindings, currentFindings);
+  
+  // Hallucination detection (PRO)
+  let hallucinations = null;
+  if (opts.hallucination) {
+    hallucinations = detectHallucinations(baselineFindings, currentFindings, projectPath);
+  }
+  
+  // Build checkpoint result
+  const checkpoint = {
+    timestamp: new Date().toISOString(),
+    baseline: {
+      path: opts.baseline || path.join(resultsDir, 'baseline.json'),
+      totalFindings: baselineFindings.length,
+      generatedAt: baseline.generatedAt || baseline.timestamp,
+    },
+    current: {
+      path: opts.current || path.join(resultsDir, 'latest.json'),
+      totalFindings: currentFindings.length,
+      generatedAt: current.generatedAt || current.timestamp,
+    },
+    summary: {
+      fixed: comparison.fixed.length,
+      remaining: comparison.remaining.length,
+      regressions: comparison.regressions.length,
+      progressPercent: baselineFindings.length > 0 
+        ? Math.round((comparison.fixed.length / baselineFindings.length) * 100)
+        : 0,
+    },
+    fixed: comparison.fixed,
+    remaining: comparison.remaining,
+    regressions: comparison.regressions,
+    hallucinations: hallucinations,
+  };
+  
+  // Save if requested
+  if (opts.save) {
+    if (!fs.existsSync(checkpointsDir)) {
+      fs.mkdirSync(checkpointsDir, { recursive: true });
+    }
+    const checkpointFile = path.join(
+      checkpointsDir, 
+      `checkpoint-${new Date().toISOString().split('T')[0]}.json`
+    );
+    fs.writeFileSync(checkpointFile, JSON.stringify(checkpoint, null, 2));
+  }
+  
+  // JSON output
+  if (opts.json) {
+    console.log(JSON.stringify(checkpoint, null, 2));
+    return checkpoint.summary.regressions > 0 ? 1 : 0;
+  }
+  
+  // Human-readable output
+  console.log(`
+${c.bold}╔══════════════════════════════════════════════════════════════════════════════╗
+║                                                                              ║
+║  ${icons.target} ${c.cyan}VIBECHECK CHECKPOINT${c.reset}${c.bold}                                                   ║
+║                                                                              ║
+╚══════════════════════════════════════════════════════════════════════════════╝${c.reset}
+`);
+  
+  // Summary card
+  console.log(`${c.bold}${icons.chart} PROGRESS SUMMARY${c.reset}`);
+  console.log(`${'─'.repeat(60)}`);
+  console.log(`  Baseline:   ${baselineFindings.length} findings`);
+  console.log(`  Current:    ${currentFindings.length} findings`);
+  console.log(`  Progress:   ${c.bold}${checkpoint.summary.progressPercent}%${c.reset}`);
+  console.log();
+  
+  // Stats
+  console.log(`  ${c.green}${icons.check} Fixed:${c.reset}       ${comparison.fixed.length}`);
+  console.log(`  ${c.yellow}${icons.warning} Remaining:${c.reset}   ${comparison.remaining.length}`);
+  console.log(`  ${c.red}${icons.cross} Regressions:${c.reset} ${comparison.regressions.length}`);
+  console.log();
+  
+  // Fixed issues
+  if (comparison.fixed.length > 0) {
+    console.log(`${c.bold}${c.green}${icons.check} FIXED ISSUES${c.reset} (${comparison.fixed.length})`);
+    console.log(`${'─'.repeat(60)}`);
+    for (const f of comparison.fixed.slice(0, 10)) {
+      console.log(`  ${c.green}${icons.check}${c.reset} ${f.title || f.id || f.type}`);
+      if (f.file) console.log(`    ${c.dim}${f.file}${f.line ? `:${f.line}` : ''}${c.reset}`);
+    }
+    if (comparison.fixed.length > 10) {
+      console.log(`  ${c.dim}... and ${comparison.fixed.length - 10} more${c.reset}`);
+    }
+    console.log();
+  }
+  
+  // Regressions (new issues)
+  if (comparison.regressions.length > 0) {
+    console.log(`${c.bold}${c.red}${icons.cross} REGRESSIONS${c.reset} (${comparison.regressions.length})`);
+    console.log(`${'─'.repeat(60)}`);
+    for (const f of comparison.regressions.slice(0, 10)) {
+      console.log(`  ${c.red}${icons.cross}${c.reset} ${f.title || f.id || f.type}`);
+      if (f.file) console.log(`    ${c.dim}${f.file}${f.line ? `:${f.line}` : ''}${c.reset}`);
+    }
+    if (comparison.regressions.length > 10) {
+      console.log(`  ${c.dim}... and ${comparison.regressions.length - 10} more${c.reset}`);
+    }
+    console.log();
+  }
+  
+  // Hallucination report (PRO)
+  if (hallucinations) {
+    console.log(`${c.bold}${icons.brain} HALLUCINATION ANALYSIS${c.reset} ${c.magenta}[PRO]${c.reset}`);
+    console.log(`${'─'.repeat(60)}`);
+    console.log(`  Score: ${hallucinations.score <= 20 ? c.green : hallucinations.score <= 50 ? c.yellow : c.red}${hallucinations.score}/100${c.reset} ${c.dim}(lower is better)${c.reset}`);
+    
+    if (hallucinations.nonexistentRoutes.length > 0) {
+      console.log(`\n  ${c.red}Nonexistent routes referenced:${c.reset} ${hallucinations.nonexistentRoutes.length}`);
+      for (const h of hallucinations.nonexistentRoutes.slice(0, 5)) {
+        console.log(`    ${c.red}${icons.cross}${c.reset} ${h.referencedRoute}`);
+      }
+    }
+    
+    if (hallucinations.nonexistentEnvVars.length > 0) {
+      console.log(`\n  ${c.red}Undeclared env vars used:${c.reset} ${hallucinations.nonexistentEnvVars.length}`);
+      for (const h of hallucinations.nonexistentEnvVars.slice(0, 5)) {
+        console.log(`    ${c.red}${icons.cross}${c.reset} ${h.referencedVar}`);
+      }
+    }
+    
+    if (hallucinations.contractDriftViolations.length > 0) {
+      console.log(`\n  ${c.yellow}Contract drift violations:${c.reset} ${hallucinations.contractDriftViolations.length}`);
+      for (const h of hallucinations.contractDriftViolations.slice(0, 5)) {
+        console.log(`    ${c.yellow}${icons.warning}${c.reset} ${h.route || h.type}`);
+      }
+    }
+    
+    if (hallucinations.score === 0) {
+      console.log(`  ${c.green}${icons.check} No hallucinations detected${c.reset}`);
+    }
+    console.log();
+  }
+  
+  // Verdict
+  console.log(`${c.bold}${'━'.repeat(60)}${c.reset}`);
+  if (comparison.regressions.length === 0 && comparison.fixed.length > 0) {
+    console.log(`${c.green}${c.bold}${icons.rocket} GREAT PROGRESS!${c.reset} ${comparison.fixed.length} issues fixed, no regressions.`);
+  } else if (comparison.regressions.length === 0) {
+    console.log(`${c.green}${icons.check} No regressions detected.${c.reset}`);
+  } else {
+    console.log(`${c.red}${icons.warning} ${comparison.regressions.length} regression(s) detected. Review before shipping.${c.reset}`);
+  }
+  console.log();
+  
+  // Next steps
+  console.log(`${c.bold}NEXT STEPS${c.reset}`);
+  if (comparison.regressions.length > 0) {
+    console.log(`  1. Fix regressions: ${c.cyan}vibecheck scan --autofix${c.reset}`);
+    console.log(`  2. Re-run checkpoint: ${c.cyan}vibecheck checkpoint${c.reset}`);
+  } else if (comparison.remaining.length > 0) {
+    console.log(`  1. Fix remaining issues: ${c.cyan}vibecheck scan --autofix${c.reset}`);
+    console.log(`  2. Verify with: ${c.cyan}vibecheck ship${c.reset}`);
+  } else {
+    console.log(`  ${c.green}${icons.check} Ready to ship: ${c.cyan}vibecheck ship${c.reset}`);
+  }
+  console.log();
+  
+  // Return code: 1 if regressions, 0 otherwise
+  return comparison.regressions.length > 0 ? 1 : 0;
+}
+
+module.exports = { runCheckpoint };

package/bin/runners/runContracts.js

@@ -0,0 +1,105 @@
+/**
+ * vibecheck contracts - CI Gate for Contract Drift / Invariants
+ * 
+ * Replaces: ctx guard
+ * Purpose: Validate code against contracts (SHIP/WARN/BLOCK)
+ */
+
+"use strict";
+
+const { runCtxGuard } = require("./runCtxGuard");
+
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+};
+
+function parseArgs(args) {
+  const opts = {
+    repoRoot: process.cwd(),
+    fastifyEntry: null,
+    json: false,
+    failOnWarn: false,
+    failOnMissing: false,
+    strict: false,
+    help: false
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--json") opts.json = true;
+    else if (arg === "--strict") opts.strict = 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;
+  }
+
+  // --strict implies --fail-on-warn
+  if (opts.strict) opts.failOnWarn = true;
+
+  return opts;
+}
+
+function printHelp() {
+  console.log(`
+${c.cyan}${c.bold}🛡️ vibecheck contracts${c.reset} - CI Gate for Contract Drift
+
+Validates current code against contracts. Use in CI to block drift.
+
+${c.bold}USAGE${c.reset}
+  vibecheck contracts                 ${c.dim}# Validate against contracts${c.reset}
+  vibecheck contracts --strict       ${c.dim}# Fail on warnings${c.reset}
+  vibecheck contracts --json         ${c.dim}# Output JSON for CI${c.reset}
+
+${c.bold}OPTIONS${c.reset}
+  --strict              Fail on warnings (exit 1 on WARN)
+  --json                Output JSON result to .vibecheck/contracts-result.json
+  --fail-on-warn        Exit 1 on warnings (same as --strict)
+  --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 = SHIP (or WARN without --strict)
+  1 = WARN (with --strict)
+  2 = BLOCK
+
+${c.bold}EXAMPLES${c.reset}
+  vibecheck contracts                    ${c.dim}# Local validation${c.reset}
+  vibecheck contracts --strict --json   ${c.dim}# CI mode${c.reset}
+
+${c.dim}Note: This command replaces 'vibecheck ctx guard'.${c.reset}
+`);
+}
+
+async function runContracts(args) {
+  const opts = parseArgs(args);
+  
+  if (opts.help) {
+    printHelp();
+    return 0;
+  }
+
+  // Delegate to runCtxGuard
+  return await runCtxGuard(opts);
+}
+
+module.exports = { runContracts };

package/bin/runners/runExport.js

@@ -0,0 +1,93 @@
+/**
+ * vibecheck export - Lightweight Collaboration Outputs
+ * 
+ * Subcommands:
+ *   export pr = current pr
+ *   export badge = current badge
+ *   export bundle = current share
+ * 
+ * Replaces: pr, badge, share
+ */
+
+"use strict";
+
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+};
+
+function printHelp() {
+  console.log(`
+${c.cyan}${c.bold}📤 vibecheck export${c.reset} - Generate Collaboration Outputs
+
+Lightweight outputs from latest results for sharing and collaboration.
+
+${c.bold}SUBCOMMANDS${c.reset}
+  ${c.cyan}pr${c.reset}                  ${c.dim}Generate GitHub PR comment (replaces 'pr')${c.reset}
+  ${c.cyan}badge${c.reset}               ${c.dim}Generate ship badge for README (replaces 'badge')${c.reset}
+  ${c.cyan}bundle${c.reset}              ${c.dim}Generate share pack for PR/docs (replaces 'share')${c.reset}
+
+${c.bold}EXAMPLES${c.reset}
+  vibecheck export pr
+  vibecheck export badge --style gradient
+  vibecheck export bundle
+
+${c.dim}Note: Old commands still work as aliases:
+  vibecheck pr → vibecheck export pr
+  vibecheck badge → vibecheck export badge
+  vibecheck share → vibecheck export bundle${c.reset}
+`);
+}
+
+async function runExport(args) {
+  if (!args || args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    printHelp();
+    return 0;
+  }
+
+  const subcommand = args[0];
+  const subArgs = args.slice(1);
+
+  switch (subcommand) {
+    case "pr":
+      // Delegate to runPR
+      try {
+        const { runPR } = require("./runPR");
+        return await runPR(subArgs);
+      } catch (e) {
+        console.error(`${c.red}Error:${c.reset} Export PR unavailable: ${e.message}`);
+        return 1;
+      }
+
+    case "badge":
+      // Delegate to runBadge
+      try {
+        const { runBadge } = require("./runBadge");
+        return await runBadge(subArgs);
+      } catch (e) {
+        console.error(`${c.red}Error:${c.reset} Export badge unavailable: ${e.message}`);
+        return 1;
+      }
+
+    case "bundle":
+      // Delegate to runShare
+      try {
+        const { runShare } = require("./runShare");
+        return await runShare(subArgs);
+      } catch (e) {
+        console.error(`${c.red}Error:${c.reset} Export bundle unavailable: ${e.message}`);
+        return 1;
+      }
+
+    default:
+      console.error(`${c.red}Unknown subcommand:${c.reset} ${subcommand}`);
+      console.log(`\n${c.dim}Run 'vibecheck export --help' for available subcommands.${c.reset}\n`);
+      return 1;
+  }
+}
+
+module.exports = { runExport };