@vibecheckai/cli 3.1.8 → 3.2.0

package/bin/runners/runProve.js

@@ -673,28 +673,44 @@ function printHelp(showBanner = true) {
     console.log(BANNER_FULL);
   }
   console.log(`
-  ${c.bold}Usage:${c.reset} vibecheck prove [options]
+  ${c.bold}Usage:${c.reset} vibecheck prove --url <url> [options]
 
-  ${c.bold}One Command Reality Proof${c.reset} — Make it real or keep fixing until it is.
+  ${c.bold}One Command Reality Proof${c.reset} — Undeniable evidence that your app works.
+  
+  Produces a shareable proof bundle with ${c.bold}video${c.reset} + ${c.bold}network evidence${c.reset} showing
+  real user flows hitting real APIs. Drop it into CI and instantly trust the verdict.
+
+  ${c.bold}What You Get:${c.reset}
+    ${colors.shipGreen}🎬${c.reset} Video recordings of browser sessions
+    ${colors.shipGreen}📡${c.reset} Network traffic capture (HAR files)
+    ${colors.shipGreen}📊${c.reset} Playwright traces (viewable at trace.playwright.dev)
+    ${colors.shipGreen}📄${c.reset} Beautiful HTML proof report
 
   ${c.bold}Pipeline:${c.reset}
     ${colors.step1}1. CTX${c.reset}      Refresh truthpack (ground truth)
-    ${colors.step2}2. REALITY${c.reset}  Runtime UI proof ${c.dim}(if --url provided)${c.reset}
+    ${colors.step2}2. REALITY${c.reset}  Runtime UI proof with video + network capture
     ${colors.step3}3. SHIP${c.reset}     Static + runtime verdict
     ${colors.step4}4. FIX${c.reset}      Auto-fix if BLOCK ${c.dim}(up to N rounds)${c.reset}
     ${colors.step5}5. VERIFY${c.reset}   Re-run to confirm SHIP
 
   ${c.bold}Options:${c.reset}
-    ${colors.accent}--url, -u <url>${c.reset}           Base URL for runtime testing
+    ${colors.accent}--url, -u <url>${c.reset}           Base URL for runtime testing ${c.dim}(required)${c.reset}
     ${colors.accent}--auth <email:pass>${c.reset}      Login credentials for auth verification
     ${colors.accent}--storage-state <path>${c.reset}   Playwright session state file
-    ${colors.accent}--fastify-entry <path>${c.reset}   Fastify entry file for route extraction
+    ${colors.accent}--stability-runs <n>${c.reset}     Multiple runs for flakiness ${c.dim}(default: 2)${c.reset}
     ${colors.accent}--max-fix-rounds <n>${c.reset}     Max auto-fix attempts ${c.dim}(default: 3)${c.reset}
     ${colors.accent}--skip-reality${c.reset}           Skip runtime crawling (static only)
     ${colors.accent}--skip-fix${c.reset}               Don't auto-fix, just diagnose
     ${colors.accent}--headed${c.reset}                 Run browser in headed mode
-    ${colors.accent}--danger${c.reset}                 Allow clicking destructive elements
-    ${colors.accent}--help, -h${c.reset}               Show this help
+    ${colors.accent}--ci${c.reset}                     CI-friendly output (GitHub Actions)
+
+  ${c.bold}Recording Options:${c.reset} ${c.dim}(all enabled by default)${c.reset}
+    ${colors.accent}--no-video${c.reset}               Disable video recording
+    ${colors.accent}--no-trace${c.reset}               Disable Playwright traces
+    ${colors.accent}--no-har${c.reset}                 Disable HAR network capture
+
+  ${c.bold}Evidence Pack:${c.reset}
+    ${colors.accent}--bundle${c.reset}                 Generate shareable evidence pack (zip with videos, traces, screenshots)
 
   ${c.bold}Exit Codes:${c.reset}
     ${colors.shipGreen}0${c.reset}  SHIP  — Proved real, ready to deploy
@@ -702,17 +718,26 @@ function printHelp(showBanner = true) {
     ${colors.blockRed}2${c.reset}  BLOCK — Blockers found, not proved
 
   ${c.bold}Examples:${c.reset}
-    ${c.dim}# Full proof with runtime testing${c.reset}
+    ${c.dim}# Full proof with video + network evidence${c.reset}
     vibecheck prove --url http://localhost:3000
 
-    ${c.dim}# With authentication${c.reset}
+    ${c.dim}# With authentication (two-pass verification)${c.reset}
     vibecheck prove --url http://localhost:3000 --auth user@test.com:pass
 
-    ${c.dim}# Static only (no runtime)${c.reset}
-    vibecheck prove --skip-reality
+    ${c.dim}# CI integration (GitHub Actions)${c.reset}
+    npx vibecheck prove --url \$APP_URL --ci
+
+    ${c.dim}# Quick check (no recordings)${c.reset}
+    vibecheck prove --url http://localhost:3000 --no-video --no-trace
 
-    ${c.dim}# More fix attempts${c.reset}
-    vibecheck prove --url http://localhost:3000 --max-fix-rounds 5
+  ${c.bold}CI Integration:${c.reset}
+    ${c.dim}# Add to .github/workflows/test.yml:${c.reset}
+    - name: Reality Proof
+      run: npx vibecheck prove --url \${{ env.APP_URL }} --ci
+    - uses: actions/upload-artifact@v4
+      with:
+        name: proof-report
+        path: .vibecheck/prove/*/proof-report.html
   `);
 }
 
@@ -738,6 +763,7 @@ 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();
+  const executionStart = Date.now();
   
   // Handle array args from CLI
   if (Array.isArray(argsOrOpts)) {
@@ -767,6 +793,14 @@ async function runProve(argsOrOpts = {}, context = {}) {
       skipFix: cleanArgs.includes("--skip-fix"),
       headed: cleanArgs.includes("--headed"),
       danger: cleanArgs.includes("--danger"),
+      // Recording options - enabled by default for "undeniable proof"
+      noVideo: cleanArgs.includes("--no-video"),
+      noTrace: cleanArgs.includes("--no-trace"),
+      noHar: cleanArgs.includes("--no-har"),
+      stabilityRuns: parseInt(getArg(["--stability-runs"]) || "2", 10),
+      flakyThreshold: parseFloat(getArg(["--flaky-threshold"]) || "0.66"),
+      maxPages: parseInt(getArg(["--max-pages"]) || "18", 10),
+      evidencePack: cleanArgs.includes("--evidence-pack") || cleanArgs.includes("--bundle"),
       output: getArg(["--output", "-o"]),
     };
   }
@@ -787,9 +821,16 @@ async function runProve(argsOrOpts = {}, context = {}) {
     maxPages = 18,
     maxDepth = 2,
     timeoutMs = 15000,
+    // Recording enabled by default for undeniable proof
+    noVideo = false,
+    noTrace = false,
+    noHar = false,
+    stabilityRuns = 2,
+    flakyThreshold = 0.66,
     json = false,
     output = null,
-    ci = false
+    ci = false,
+    evidencePack = false
   } = argsOrOpts;
   
   const root = repoRoot || process.cwd();
@@ -882,9 +923,10 @@ async function runProve(argsOrOpts = {}, context = {}) {
     printStepHeader(2, url);
     pipelineStatus[1] = 'running';
     
-    startSpinner('Running reality check...', colors.step2);
+    startSpinner('Running reality check with video + network capture...', colors.step2);
     
     try {
+      // Enable all recording by default for undeniable proof
       await runReality({
         repoRoot: root,
         url,
@@ -895,7 +937,14 @@ async function runProve(argsOrOpts = {}, context = {}) {
         maxPages,
         maxDepth,
         danger,
-        timeoutMs
+        timeoutMs,
+        // Recording enabled by default for "prove" - undeniable evidence
+        recordVideo: !noVideo,
+        recordTrace: !noTrace,
+        recordHar: !noHar,
+        // Multiple stability runs for flakiness reduction
+        stabilityRuns: stabilityRuns,
+        flakyThreshold: 0.66
       });
       
       // Read reality report for timeline
@@ -1119,7 +1168,7 @@ async function runProve(argsOrOpts = {}, context = {}) {
     printStepHeader(5);
     pipelineStatus[4] = 'running';
     
-    startSpinner('Running final verification...', colors.step5);
+    startSpinner('Running final verification with recording...', colors.step5);
     
     try {
       await runReality({
@@ -1132,7 +1181,12 @@ async function runProve(argsOrOpts = {}, context = {}) {
         maxPages,
         maxDepth,
         danger,
-        timeoutMs
+        timeoutMs,
+        // Recording for final proof
+        recordVideo: !noVideo,
+        recordTrace: !noTrace,
+        recordHar: !noHar,
+        stabilityRuns: 1 // Single run for verification
       });
       
       shipResult = await shipCore({ repoRoot: root, fastifyEntry, noWrite: false });
@@ -1162,26 +1216,61 @@ async function runProve(argsOrOpts = {}, context = {}) {
   finalVerdict = shipResult.verdict;
 
   // ═══════════════════════════════════════════════════════════════════════════
-  // SUMMARY
+  // SUMMARY & HTML PROOF REPORT
   // ═══════════════════════════════════════════════════════════════════════════
   const duration = Date.now() - executionStart;
   const durationStr = formatDuration(duration);
   
+  // Load reality report for evidence
+  let realityReport = null;
+  const realityPath = path.join(root, ".vibecheck", "reality", "last_reality.json");
+  try { realityReport = JSON.parse(fs.readFileSync(realityPath, "utf8")); } catch {}
+  
   const report = {
     meta: {
       startedAt: new Date(executionStart).toISOString(),
       finishedAt: new Date().toISOString(),
       durationMs: duration,
       url: url || null,
-      fixRounds: fixRound
+      fixRounds: fixRound,
+      stabilityRuns: stabilityRuns,
+      recordingEnabled: { video: !noVideo, trace: !noTrace, har: !noHar }
     },
     timeline,
     finalVerdict,
-    finalFindings: shipResult.report?.findings?.length || 0
+    finalFindings: shipResult.report?.findings?.length || 0,
+    // Include reality evidence
+    coverage: realityReport?.coverage || null,
+    artifacts: realityReport?.artifacts || null,
+    findings: realityReport?.findings || shipResult.report?.findings || []
   };
   
   fs.writeFileSync(path.join(outDir, "prove_report.json"), JSON.stringify(report, null, 2), "utf8");
   
+  // Generate HTML proof report
+  let htmlReportPath = null;
+  try {
+    const { generateHtmlProofReport } = require("./lib/html-proof-report");
+    const htmlContent = generateHtmlProofReport({
+      verdict: finalVerdict,
+      projectName: projectName,
+      url: url,
+      startedAt: new Date(executionStart).toISOString(),
+      finishedAt: new Date().toISOString(),
+      durationMs: duration,
+      findings: report.findings,
+      coverage: report.coverage,
+      passes: realityReport?.passes || {},
+      artifacts: report.artifacts,
+      meta: report.meta,
+      stabilityRuns: stabilityRuns
+    });
+    htmlReportPath = path.join(outDir, "proof-report.html");
+    fs.writeFileSync(htmlReportPath, htmlContent, "utf8");
+  } catch (e) {
+    // HTML report generation failed - non-fatal
+  }
+  
   // Also save a stable pointer
   const latestPath = path.join(root, ".vibecheck", "prove", "last_prove.json");
   ensureDir(path.dirname(latestPath));
@@ -1191,6 +1280,50 @@ async function runProve(argsOrOpts = {}, context = {}) {
   saveArtifact(runId, "prove-report", report);
   saveArtifact(runId, "timeline", timeline);
   
+  // Generate evidence pack if requested
+  let evidencePackPath = null;
+  if (evidencePack) {
+    try {
+      // Lazy load evidence pack module
+      const evidencePackModule = require("../../packages/cli/src/evidence/evidence-pack");
+      const { generateEvidencePack, generateHtmlViewer } = evidencePackModule.default || evidencePackModule;
+      
+      if (!json && !ci) {
+        console.log();
+        console.log(`  ${colors.accent}${ICONS.doc}${c.reset} Generating evidence pack...`);
+      }
+      
+      const result = await generateEvidencePack({
+        projectPath: root,
+        sourceReport: latestPath,
+        sourceType: 'prove',
+        includeVideos: !noVideo,
+        includeTraces: !noTrace,
+        includeHar: !noHar,
+        includeScreenshots: true
+      });
+      
+      evidencePackPath = result.packPath;
+      
+      // Generate HTML viewer
+      const htmlViewerModule = require("../../packages/cli/src/evidence/html-viewer");
+      const htmlViewer = htmlViewerModule.default || htmlViewerModule;
+      await htmlViewer.generateHtmlViewer({
+        packPath: evidencePackPath,
+        embedMedia: false,
+        title: `Evidence Pack - ${projectName}`
+      });
+      
+      if (!json && !ci) {
+        console.log(`  ${colors.success}${ICONS.check}${c.reset} Evidence pack generated: ${colors.accent}${path.relative(root, evidencePackPath)}${c.reset}`);
+      }
+    } catch (e) {
+      if (!json && !ci) {
+        console.log(`  ${colors.warning}${ICONS.warning}${c.reset} Evidence pack generation failed: ${e.message}`);
+      }
+    }
+  }
+  
   // JSON output mode
   if (json) {
     const output = createJsonOutput({
@@ -1228,10 +1361,41 @@ async function runProve(argsOrOpts = {}, context = {}) {
     printTimelineSummary(timeline);
     
     // Report links
-    printSection('REPORTS', ICONS.doc);
+    printSection('PROOF ARTIFACTS', 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}`);
+    
+    // Highlight the HTML proof report
+    if (htmlReportPath) {
+      console.log(`  ${colors.shipGreen}${ICONS.sparkle}${c.reset} ${c.bold}HTML Proof Report:${c.reset}`);
+      console.log(`     ${colors.accent}${path.relative(root, htmlReportPath)}${c.reset}`);
+      console.log(`     ${c.dim}↳ Open in browser to see video evidence${c.reset}`);
+      console.log();
+    }
+    
+    // Show video/trace artifacts if available
+    if (report.artifacts) {
+      if (report.artifacts.videos?.anon || report.artifacts.videos?.auth) {
+        console.log(`  ${c.dim}🎬 Videos:${c.reset} ${report.artifacts.videos?.directory || 'N/A'}`);
+      }
+      if (report.artifacts.traces?.anon || report.artifacts.traces?.auth) {
+        console.log(`  ${c.dim}📊 Traces:${c.reset} ${report.artifacts.traces?.directory || 'N/A'}`);
+        console.log(`     ${c.dim}↳ Upload to trace.playwright.dev for debugging${c.reset}`);
+      }
+      if (report.artifacts.har?.directory) {
+        console.log(`  ${c.dim}📡 HAR:${c.reset} ${report.artifacts.har?.directory || 'N/A'}`);
+      }
+      console.log();
+    }
+    
+    console.log(`  ${c.dim}JSON Report:${c.reset} ${path.relative(root, path.join(outDir, 'prove_report.json'))}`);
+    console.log();
+    
+    // CI Integration tip
+    printSection('CI INTEGRATION', ICONS.lightning);
+    console.log();
+    console.log(`  ${c.dim}Add to your CI pipeline:${c.reset}`);
+    console.log(`  ${colors.accent}npx vibecheck prove --url \$APP_URL --ci${c.reset}`);
+    console.log(`  ${c.dim}Exit codes: 0=SHIP, 1=WARN, 2=BLOCK${c.reset}`);
     console.log();
     
     // Next steps if not proved
@@ -1247,10 +1411,31 @@ async function runProve(argsOrOpts = {}, context = {}) {
       console.log();
     }
   } else if (ci) {
-    // CI mode - minimal output
+    // CI mode - structured output for easy parsing
+    console.log(`::group::vibecheck prove summary`);
     console.log(`VERDICT=${finalVerdict}`);
     console.log(`DURATION=${duration}ms`);
     console.log(`FIX_ROUNDS=${fixRound}`);
+    console.log(`BLOCKERS=${report.findings.filter(f => f.severity === 'BLOCK').length}`);
+    console.log(`WARNINGS=${report.findings.filter(f => f.severity === 'WARN').length}`);
+    console.log(`COVERAGE=${report.coverage?.percent || 0}%`);
+    if (htmlReportPath) {
+      console.log(`HTML_REPORT=${path.relative(root, htmlReportPath)}`);
+    }
+    console.log(`JSON_REPORT=${path.relative(root, path.join(outDir, 'prove_report.json'))}`);
+    if (evidencePackPath) {
+      console.log(`EVIDENCE_PACK=${path.relative(root, evidencePackPath)}`);
+    }
+    console.log(`::endgroup::`);
+    
+    // GitHub Actions annotations
+    if (finalVerdict === 'BLOCK') {
+      console.log(`::error title=Reality Check Failed::${report.findings.filter(f => f.severity === 'BLOCK').length} blockers found`);
+    } else if (finalVerdict === 'WARN') {
+      console.log(`::warning title=Reality Check Passed with Warnings::${report.findings.filter(f => f.severity === 'WARN').length} warnings found`);
+    } else {
+      console.log(`::notice title=Reality Check Passed::App verified with video + network evidence`);
+    }
   }
 
   return verdictToExitCode(finalVerdict);