@vibecheckai/cli 3.0.10 → 3.1.0

package/bin/runners/runProve.js

@@ -22,6 +22,14 @@ const path = require("path");
 const { buildTruthpack, writeTruthpack, detectFastifyEntry } = require("./lib/truth");
 const { shipCore } = require("./runShip");
 const { findContractDrift, loadContracts, hasContracts, getDriftSummary } = require("./lib/drift");
+const { 
+  generateRunId, 
+  createJsonOutput, 
+  writeJsonOutput, 
+  exitCodeToVerdict,
+  verdictToExitCode,
+  saveArtifact 
+} = require("./lib/cli-output");
 
 let runReality;
 try {
@@ -723,7 +731,11 @@ function stamp() {
 // MAIN PROVE FUNCTION
 // ═══════════════════════════════════════════════════════════════════════════════
 
-async function runProve(argsOrOpts = {}) {
+async function runProve(argsOrOpts = {}, context = {}) {
+  // Extract runId from context or generate new one
+  const runId = context.runId || generateRunId();
+  const startTime = context.startTime || new Date().toISOString();
+  
   // Handle array args from CLI
   if (Array.isArray(argsOrOpts)) {
     if (argsOrOpts.includes("--help") || argsOrOpts.includes("-h")) {
@@ -747,6 +759,9 @@ async function runProve(argsOrOpts = {}) {
       skipFix: argsOrOpts.includes("--skip-fix"),
       headed: argsOrOpts.includes("--headed"),
       danger: argsOrOpts.includes("--danger"),
+      json: argsOrOpts.includes("--json"),
+      output: getArg(["--output", "-o"]),
+      ci: argsOrOpts.includes("--ci"),
     };
   }
 
@@ -765,33 +780,38 @@ async function runProve(argsOrOpts = {}) {
     danger = false,
     maxPages = 18,
     maxDepth = 2,
-    timeoutMs = 15000
+    timeoutMs = 15000,
+    json = false,
+    output = null,
+    ci = false
   } = argsOrOpts;
   
   const root = repoRoot || process.cwd();
   const projectName = path.basename(root);
-  const startTime = Date.now();
 
-  // Print banner
-  printBanner();
-  
-  console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
-  console.log(`  ${c.dim}Path:${c.reset}     ${root}`);
-  if (url) {
-    console.log(`  ${c.dim}URL:${c.reset}      ${colors.accent}${url}${c.reset}`);
-  }
-  console.log(`  ${c.dim}Fix Rounds:${c.reset} ${maxFixRounds} max`);
-  
-  // Show pipeline overview
+  // Initialize pipeline status
   const pipelineStatus = ['pending', 'pending', 'pending', 'pending', 'pending'];
-  printPipelineOverview(pipelineStatus);
-
   const outDir = path.join(root, ".vibecheck", "prove", stamp());
   ensureDir(outDir);
-
+  
   const timeline = [];
   let finalVerdict = "UNKNOWN";
 
+  // Print banner (unless JSON or CI mode)
+  if (!json && !ci) {
+    printBanner();
+    
+    console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
+    console.log(`  ${c.dim}Path:${c.reset}     ${root}`);
+    if (url) {
+      console.log(`  ${c.dim}URL:${c.reset}      ${colors.accent}${url}${c.reset}`);
+    }
+    console.log(`  ${c.dim}Fix Rounds:${c.reset} ${maxFixRounds} max`);
+    
+    // Show pipeline overview
+    printPipelineOverview(pipelineStatus);
+  }
+
   // ═══════════════════════════════════════════════════════════════════════════
   // STEP 1: CTX - Refresh truthpack
   // ═══════════════════════════════════════════════════════════════════════════
@@ -1138,12 +1158,12 @@ async function runProve(argsOrOpts = {}) {
   // ═══════════════════════════════════════════════════════════════════════════
   // SUMMARY
   // ═══════════════════════════════════════════════════════════════════════════
-  const duration = Date.now() - startTime;
+  const duration = Date.now() - executionStart;
   const durationStr = formatDuration(duration);
   
   const report = {
     meta: {
-      startedAt: new Date(startTime).toISOString(),
+      startedAt: new Date(executionStart).toISOString(),
       finishedAt: new Date().toISOString(),
       durationMs: duration,
       url: url || null,
@@ -1161,34 +1181,73 @@ async function runProve(argsOrOpts = {}) {
   ensureDir(path.dirname(latestPath));
   fs.writeFileSync(latestPath, JSON.stringify(report, null, 2), "utf8");
 
-  // Final verdict display
-  printFinalVerdict(finalVerdict, durationStr, fixRound, shipResult.report?.findings?.length || 0);
-  
-  // Timeline summary
-  printTimelineSummary(timeline);
+  // Save artifacts
+  saveArtifact(runId, "prove-report", report);
+  saveArtifact(runId, "timeline", timeline);
   
-  // Report links
-  printSection('REPORTS', ICONS.doc);
-  console.log();
-  console.log(`  ${colors.accent}${outDir}/prove_report.json${c.reset}`);
-  console.log(`  ${c.dim}${path.join(root, '.vibecheck', 'prove', 'last_prove.json')}${c.reset}`);
-  console.log();
+  // JSON output mode
+  if (json) {
+    const output = createJsonOutput({
+      runId,
+      command: "prove",
+      startTime: executionStart,
+      exitCode: verdictToExitCode(finalVerdict),
+      verdict: finalVerdict,
+      result: {
+        meta: report.meta,
+        timeline,
+        finalVerdict,
+        fixRounds: fixRound,
+        duration: duration
+      },
+      tier: "pro",
+      version: require("../../package.json").version,
+      artifacts: [
+        {
+          type: "report",
+          path: path.join(outDir, "prove_report.json"),
+          description: "Prove report with timeline"
+        }
+      ]
+    });
+    
+    writeJsonOutput(output, output);
+  }
   
-  // Next steps if not proved
-  if (finalVerdict !== 'SHIP') {
-    printSection('NEXT STEPS', ICONS.lightning);
+  // Final verdict display (unless JSON or CI mode)
+  if (!json && !ci) {
+    printFinalVerdict(finalVerdict, durationStr, fixRound, shipResult.report?.findings?.length || 0);
+    
+    // Timeline summary
+    printTimelineSummary(timeline);
+    
+    // Report links
+    printSection('REPORTS', ICONS.doc);
     console.log();
-    if (skipFix) {
-      console.log(`  ${colors.accent}vibecheck prove --url ${url || '<url>'}${c.reset}  ${c.dim}Enable auto-fix${c.reset}`);
-    } else if (fixRound >= maxFixRounds) {
-      console.log(`  ${colors.accent}vibecheck prove --max-fix-rounds ${maxFixRounds + 2}${c.reset}  ${c.dim}Try more fix rounds${c.reset}`);
-    }
-    console.log(`  ${colors.accent}vibecheck ship --fix${c.reset}  ${c.dim}Manual fix mode${c.reset}`);
+    console.log(`  ${colors.accent}${outDir}/prove_report.json${c.reset}`);
+    console.log(`  ${c.dim}${path.join(root, '.vibecheck', 'prove', 'last_prove.json')}${c.reset}`);
     console.log();
+    
+    // Next steps if not proved
+    if (finalVerdict !== 'SHIP') {
+      printSection('NEXT STEPS', ICONS.lightning);
+      console.log();
+      if (skipFix) {
+        console.log(`  ${colors.accent}vibecheck prove --url ${url || '<url>'}${c.reset}  ${c.dim}Enable auto-fix${c.reset}`);
+      } else if (fixRound >= maxFixRounds) {
+        console.log(`  ${colors.accent}vibecheck prove --max-fix-rounds ${maxFixRounds + 2}${c.reset}  ${c.dim}Try more fix rounds${c.reset}`);
+      }
+      console.log(`  ${colors.accent}vibecheck ship --fix${c.reset}  ${c.dim}Manual fix mode${c.reset}`);
+      console.log();
+    }
+  } else if (ci) {
+    // CI mode - minimal output
+    console.log(`VERDICT=${finalVerdict}`);
+    console.log(`DURATION=${duration}ms`);
+    console.log(`FIX_ROUNDS=${fixRound}`);
   }
 
-  process.exitCode = finalVerdict === "SHIP" ? 0 : finalVerdict === "WARN" ? 1 : 2;
-  return process.exitCode;
+  return verdictToExitCode(finalVerdict);
 }
 
 module.exports = { runProve };

package/bin/runners/runShip.js

@@ -13,6 +13,14 @@ const { withErrorHandling } = require("./lib/error-handler");
 const { ensureOutputDir, detectProjectFeatures } = require("./utils");
 const { enforceLimit, enforceFeature, trackUsage, getCurrentTier } = require("./lib/entitlements");
 const { emitShipCheck } = require("./lib/audit-bridge");
+const { 
+  generateRunId, 
+  createJsonOutput, 
+  writeJsonOutput, 
+  exitCodeToVerdict,
+  verdictToExitCode,
+  saveArtifact 
+} = require("./lib/cli-output");
 
 // Route Truth v1 - Fake endpoint detection
 const { buildTruthpack, writeTruthpack, detectFastifyEntry } = require("./lib/truth");
@@ -27,6 +35,8 @@ const {
 } = require("./lib/analyzers");
 const { findingsFromReality } = require("./lib/reality-findings");
 const { findContractDrift, loadContracts, hasContracts, getDriftSummary } = require("./lib/drift");
+const upsell = require("./lib/upsell");
+const entitlements = require("./lib/entitlements-v2");
 
 // ═══════════════════════════════════════════════════════════════════════════════
 // ADVANCED TERMINAL - ANSI CODES & UTILITIES
@@ -846,9 +856,13 @@ function parseArgs(args) {
 // MAIN SHIP FUNCTION
 // ═══════════════════════════════════════════════════════════════════════════════
 
-async function runShip(args) {
+async function runShip(args, context = {}) {
+  // Extract runId from context or generate new one
+  const runId = context.runId || generateRunId();
+  const startTime = context.startTime || new Date().toISOString();
+  
   const opts = parseArgs(args);
-  const startTime = Date.now();
+  const executionStart = Date.now();
 
   // Show help if requested
   if (opts.help) {
@@ -990,23 +1004,53 @@ async function runShip(args) {
 
     // JSON output mode
     if (opts.json) {
-      const output = {
-        schemaVersion: '1.0.0',
-        timestamp: new Date().toISOString(),
+      const output = createJsonOutput({
+        runId,
+        command: "ship",
+        startTime,
+        exitCode: verdictToExitCode(verdict),
         verdict,
-        score: results.score,
-        canShip: results.canShip,
-        summary: {
-          blockers: blockers.length,
-          warnings: warnings.length,
-          total: allFindings.length,
+        result: {
+          verdict,
+          score: results.score,
+          grade: results.grade,
+          canShip: results.canShip,
+          summary: {
+            blockers: blockers.length,
+            warnings: warnings.length,
+            total: allFindings.length,
+          },
+          findings: allFindings,
+          proofGraph: proofGraph.summary,
+          duration: Date.now() - executionStart,
         },
-        findings: allFindings,
-        proofGraph: proofGraph.summary,
-        duration,
-      };
-      console.log(JSON.stringify(output, null, 2));
-      return verdict === 'SHIP' ? 0 : verdict === 'WARN' ? 1 : 2;
+        tier: getCurrentTier(),
+        version: require("../../package.json").version,
+        artifacts: [
+          {
+            type: "report",
+            path: path.join(outputDir, "report.json"),
+            description: "Ship report with findings"
+          },
+          {
+            type: "proof",
+            path: path.join(outputDir, "proof-graph.json"),
+            description: "Proof graph analysis"
+          }
+        ]
+      });
+      
+      writeJsonOutput(output, opts.output);
+      
+      // Save artifacts
+      const reportPath = saveArtifact(runId, "report", {
+        ...output.result,
+        truthpack,
+        integrity: results.integrity
+      });
+      const proofPath = saveArtifact(runId, "proof-graph", proofGraph);
+      
+      return verdictToExitCode(verdict);
     }
 
     // CI output mode (minimal)
@@ -1015,7 +1059,17 @@ async function runShip(args) {
       console.log(`SCORE=${results.score}`);
       console.log(`BLOCKERS=${blockers.length}`);
       console.log(`WARNINGS=${warnings.length}`);
-      return verdict === 'SHIP' ? 0 : verdict === 'WARN' ? 1 : 2;
+      
+      // Save CI artifacts
+      saveArtifact(runId, "ci-summary", {
+        verdict,
+        score: results.score,
+        blockers: blockers.length,
+        warnings: warnings.length,
+        timestamp: new Date().toISOString()
+      });
+      
+      return verdictToExitCode(verdict);
     }
 
     // Fix mode
@@ -1076,6 +1130,20 @@ async function runShip(args) {
       }
       console.log(`  ${colors.accent}vibecheck ship --assist${c.reset}  ${c.dim}Get AI help for complex issues${c.reset}`);
       console.log();
+      
+      // Earned upsell: Badge withheld when verdict != SHIP
+      const currentTier = context?.authInfo?.access?.tier || "free";
+      if (entitlements.tierMeetsMinimum(currentTier, "starter")) {
+        // User has badge access but verdict prevents it
+        console.log(upsell.formatEarnedUpsell({
+          cmd: "ship",
+          verdict,
+          topIssues: blockers.slice(0, 3),
+          withheldArtifact: "badge",
+          currentTier,
+          suggestedCmd: currentTier === "free" ? "vibecheck fix --plan-only" : "vibecheck fix",
+        }));
+      }
     }
 
     // Emit audit event
@@ -1093,7 +1161,18 @@ async function runShip(args) {
     } catch {}
 
     // Exit code: 0=SHIP, 1=WARN, 2=BLOCK
-    return verdict === 'SHIP' ? 0 : verdict === 'WARN' ? 1 : 2;
+    const exitCode = verdictToExitCode(verdict);
+    
+    // Save final results
+    saveArtifact(runId, "summary", {
+      verdict,
+      score: results.score,
+      canShip: results.canShip,
+      exitCode,
+      timestamp: new Date().toISOString()
+    });
+    
+    return exitCode;
 
   } catch (error) {
     if (!opts.json) stopSpinner(`Ship check failed: ${error.message}`, false);

package/bin/runners/runVerify.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+/**
+ * runVerify.js - CLI Verify Command
+ * Verifies AI-generated agent output against vibecheck-v1 protocol
+ * 
+ * Usage:
+ *   vibecheck verify [options]
+ *   vibecheck verify --input response.json
+ *   vibecheck verify --stdin
+ *   vibecheck verify --mode ship --strict
+ */
+
+"use strict";
+
+const fs = require('fs');
+const path = require('path');
+const { parseArgs } = require('util');
+
+const HELP = `
+vibecheck verify - Verify AI-generated agent output
+
+Usage:
+  vibecheck verify [options]
+
+Options:
+  --input, -i <file>    Input file containing agent response JSON
+  --stdin               Read agent response from stdin
+  --root, -r <dir>      Project root directory (default: cwd)
+  --mode, -m <mode>     Verification mode: explore|build|ship (default: build)
+  --strict              Enable strict mode (fail on warnings)
+  --json                Output results as JSON
+  --help, -h            Show this help message
+
+Examples:
+  vibecheck verify --input agent-response.json
+  echo '{"format":"vibecheck-v1",...}' | vibecheck verify --stdin
+  vibecheck verify --input response.json --mode ship --strict
+`;
+
+async function main() {
+  const { values, positionals } = parseArgs({
+    options: {
+      input: { type: 'string', short: 'i' },
+      stdin: { type: 'boolean', default: false },
+      root: { type: 'string', short: 'r' },
+      mode: { type: 'string', short: 'm', default: 'build' },
+      strict: { type: 'boolean', default: false },
+      json: { type: 'boolean', default: false },
+      help: { type: 'boolean', short: 'h' },
+    },
+    allowPositionals: true,
+    strict: false,
+  });
+
+  if (values.help) {
+    console.log(HELP);
+    process.exit(0);
+  }
+
+  const projectRoot = values.root ? path.resolve(values.root) : process.cwd();
+  const mode = values.mode || 'build';
+  const strict = values.strict || false;
+  const outputJson = values.json || false;
+
+  // Validate mode
+  if (!['explore', 'build', 'ship'].includes(mode)) {
+    console.error(`Error: Invalid mode "${mode}". Must be one of: explore, build, ship`);
+    process.exit(2);
+  }
+
+  // Get input
+  let rawInput = '';
+
+  if (values.stdin) {
+    rawInput = await readStdin();
+  } else if (values.input) {
+    const inputPath = path.resolve(values.input);
+    if (!fs.existsSync(inputPath)) {
+      console.error(`Error: Input file not found: ${inputPath}`);
+      process.exit(2);
+    }
+    rawInput = fs.readFileSync(inputPath, 'utf-8');
+  } else if (positionals.length > 0) {
+    // Allow positional argument as input file
+    const inputPath = path.resolve(positionals[0]);
+    if (!fs.existsSync(inputPath)) {
+      console.error(`Error: Input file not found: ${inputPath}`);
+      process.exit(2);
+    }
+    rawInput = fs.readFileSync(inputPath, 'utf-8');
+  } else {
+    console.error('Error: No input provided. Use --input <file> or --stdin');
+    console.log(HELP);
+    process.exit(2);
+  }
+
+  if (!rawInput.trim()) {
+    console.error('Error: Empty input');
+    process.exit(2);
+  }
+
+  // Load the verification module
+  let validateFormat, verifyAgentOutput, formatCheckResults, buildJsonReport;
+  try {
+    // Try loading from the built TypeScript output
+    const verification = require('../../dist/lib/verification/index.js');
+    validateFormat = verification.validateFormat;
+    verifyAgentOutput = verification.verifyAgentOutput;
+    formatCheckResults = verification.formatCheckResults;
+    buildJsonReport = verification.buildJsonReport;
+  } catch (err) {
+    // Fallback: try loading directly (for development)
+    try {
+      const verification = require('../../src/lib/verification/index.ts');
+      validateFormat = verification.validateFormat;
+      verifyAgentOutput = verification.verifyAgentOutput;
+      formatCheckResults = verification.formatCheckResults;
+      buildJsonReport = verification.buildJsonReport;
+    } catch (err2) {
+      console.error('Error loading verification module:', err.message);
+      console.error('Make sure the project is built: pnpm build');
+      process.exit(2);
+    }
+  }
+
+  // Step 1: Validate format
+  if (!outputJson) {
+    console.log('🔍 Validating agent output format...');
+  }
+
+  const formatResult = validateFormat(rawInput);
+
+  if (!formatResult.valid) {
+    if (outputJson) {
+      console.log(JSON.stringify({
+        status: 'fail',
+        phase: 'format-validation',
+        error: formatResult.error,
+        retryPrompt: formatResult.retryPrompt,
+      }, null, 2));
+    } else {
+      console.error('❌ Format validation failed:', formatResult.error);
+      console.error('\n📝 Retry prompt:');
+      console.error(formatResult.retryPrompt);
+    }
+    process.exit(2);
+  }
+
+  // Check if it's an error response
+  if ('error' in formatResult && formatResult.error) {
+    if (outputJson) {
+      console.log(JSON.stringify({
+        status: 'error',
+        phase: 'agent-error',
+        error: formatResult.error.error,
+      }, null, 2));
+    } else {
+      console.log('⚠️  Agent returned an error response:');
+      console.log(formatResult.error.error);
+    }
+    process.exit(1);
+  }
+
+  const agentOutput = formatResult.output;
+
+  if (!outputJson) {
+    console.log('✅ Format valid');
+    console.log(`   Files in diff: ${countFilesInDiff(agentOutput.diff)}`);
+    console.log(`   Commands: ${agentOutput.commands?.length || 0}`);
+    console.log(`   Tests: ${agentOutput.tests?.length || 0}`);
+    console.log('');
+  }
+
+  // Step 2: Run verification pipeline
+  if (!outputJson) {
+    console.log('🔬 Running verification pipeline...');
+  }
+
+  const context = {
+    projectRoot,
+    mode,
+    runTests: mode === 'ship',
+    strictMode: strict,
+    maxFilesChanged: mode === 'ship' ? 10 : mode === 'build' ? 20 : 50,
+  };
+
+  let result;
+  try {
+    result = await verifyAgentOutput(agentOutput, context);
+  } catch (err) {
+    if (outputJson) {
+      console.log(JSON.stringify({
+        status: 'fail',
+        phase: 'verification',
+        error: err.message,
+      }, null, 2));
+    } else {
+      console.error('❌ Verification error:', err.message);
+    }
+    process.exit(2);
+  }
+
+  // Output results
+  if (outputJson) {
+    console.log(JSON.stringify(buildJsonReport(result), null, 2));
+  } else {
+    console.log('');
+    console.log(formatCheckResults(result.checks));
+    console.log('');
+
+    if (result.status === 'pass') {
+      console.log('✅ VERIFICATION PASSED');
+    } else if (result.status === 'warn') {
+      console.log('⚠️  VERIFICATION PASSED WITH WARNINGS');
+    } else {
+      console.log('❌ VERIFICATION FAILED');
+      if (result.failureContext) {
+        console.log('\n📝 Failure context for retry:');
+        console.log(result.failureContext);
+      }
+    }
+  }
+
+  // Exit codes: 0 = pass, 1 = warn (if strict), 2 = fail
+  if (result.status === 'fail') {
+    process.exit(2);
+  } else if (result.status === 'warn' && strict) {
+    process.exit(1);
+  } else {
+    process.exit(0);
+  }
+}
+
+/**
+ * Read all input from stdin
+ */
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', chunk => { data += chunk; });
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', reject);
+
+    // Timeout after 5 seconds if no input
+    setTimeout(() => {
+      if (data === '') {
+        reject(new Error('No input received from stdin'));
+      }
+    }, 5000);
+  });
+}
+
+/**
+ * Count files in a diff string
+ */
+function countFilesInDiff(diff) {
+  if (!diff) return 0;
+  const matches = diff.match(/^diff --git/gm);
+  return matches ? matches.length : 0;
+}
+
+// Export for CLI registry
+module.exports = { main };
+
+// Run if executed directly
+if (require.main === module) {
+  main().catch(err => {
+    console.error('Fatal error:', err.message);
+    process.exit(2);
+  });
+}