@vibecheckai/cli 2.8.2 → 3.0.0

package/bin/runners/runPromptFirewall.js

@@ -0,0 +1,211 @@
+/**
+ * Prompt Firewall Runner
+ * 
+ * Processes prompts through the advanced firewall with:
+ * - Task breakdown
+ * - Verification
+ * - Version control integration
+ * - Immediate fixes
+ * - Future planning
+ */
+
+const path = require("path");
+const readline = require("readline");
+const { withErrorHandling } = require("./lib/error-handler");
+
+// ANSI colors
+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",
+};
+
+async function runPromptFirewall(args) {
+  return withErrorHandling(async () => {
+    const projectPath = args.path || process.cwd();
+    const json = args.json || false;
+    const prompt = args.prompt || args._[0];
+    const autoFix = args["auto-fix"] === true;
+    const includeVersionControl = args["version-control"] !== false;
+    const generatePlan = args.plan !== false;
+
+    if (!prompt) {
+      console.error(`${c.red}Error: Prompt is required${c.reset}`);
+      console.error(`Usage: vibecheck prompt-firewall "your prompt here"`);
+      console.error(`   or: vibecheck prompt-firewall --prompt "your prompt here"`);
+      const { EXIT_CODES } = require('./lib/error-handler');
+      process.exit(EXIT_CODES.INVALID_INPUT);
+    }
+
+    // Try to load prompt firewall
+    let createPromptFirewall;
+    try {
+      const modulePath = path.resolve(__dirname, "../../packages/ai-vibechecks/dist/firewall/advanced-prompt-firewall.js");
+      createPromptFirewall = require(modulePath).createPromptFirewall;
+    } catch {
+      try {
+        const tsModulePath = path.resolve(__dirname, "../../packages/ai-vibechecks/src/firewall/advanced-prompt-firewall.ts");
+        require("ts-node/register");
+        createPromptFirewall = require(tsModulePath).createPromptFirewall;
+      } catch {
+        console.error(`${c.red}Error: Prompt firewall not available.${c.reset}`);
+        console.error(`Please run: pnpm build in packages/ai-vibechecks`);
+        const { EXIT_CODES } = require('./lib/error-handler');
+        process.exit(EXIT_CODES.INTERNAL_ERROR);
+      }
+    }
+
+    if (!json) {
+      console.log(`${c.cyan}${c.bold}━━━ Prompt Firewall Analysis ━━━${c.reset}\n`);
+      console.log(`Prompt: ${c.dim}${prompt}${c.reset}\n`);
+      console.log(`Project: ${path.relative(process.cwd(), projectPath)}\n`);
+    }
+
+    // Create firewall instance
+    const firewall = createPromptFirewall(projectPath);
+
+    // Process prompt
+    const result = await firewall.process(prompt, {
+      autoBreakdown: true,
+      autoVerify: true,
+      autoFix: autoFix,
+      includeVersionControl: includeVersionControl,
+      generatePlan: generatePlan,
+    });
+
+    // Output results
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+      return result.verification.passed ? 0 : 1;
+    }
+
+    // Print formatted report
+    printFirewallReport(result);
+
+    // Ask to apply fixes if available
+    if (result.immediateFixes.length > 0 && !autoFix) {
+      const shouldApply = await askToApplyFixes(result.immediateFixes.length);
+      if (shouldApply) {
+        console.log(`\n${c.cyan}Applying fixes...${c.reset}\n`);
+        for (const fix of result.immediateFixes) {
+          const applyResult = await firewall.applyFix(fix);
+          if (applyResult.success) {
+            console.log(`${c.green}✅${c.reset} ${applyResult.message}`);
+          } else {
+            console.log(`${c.red}❌${c.reset} ${applyResult.message}`);
+          }
+        }
+      }
+    }
+
+    return result.verification.passed ? 0 : 1;
+  });
+}
+
+function printFirewallReport(result) {
+  // Verification status
+  const statusColor = result.verification.passed ? c.green : c.red;
+  const statusIcon = result.verification.passed ? "✅" : "❌";
+
+  console.log(`${statusColor}${c.bold}${statusIcon} VERIFICATION: ${result.verification.passed ? "PASSED" : "FAILED"}${c.reset}`);
+  console.log(`   Score: ${result.verification.score}/100`);
+  console.log();
+
+  // Verification checks
+  console.log(`${c.cyan}${c.bold}🔍 VERIFICATION CHECKS:${c.reset}`);
+  for (const check of result.verification.checks) {
+    const icon = check.status === "pass" ? "✅" :
+                 check.status === "fail" ? "❌" : "⚠️";
+    const checkColor = check.status === "pass" ? c.green :
+                       check.status === "fail" ? c.red : c.yellow;
+    console.log(`   ${icon} ${check.name}: ${checkColor}${check.status.toUpperCase()}${c.reset}`);
+    console.log(`      ${c.dim}${check.message}${c.reset}`);
+    if (check.evidence) {
+      console.log(`      Evidence: ${c.dim}${check.evidence}${c.reset}`);
+    }
+  }
+  console.log();
+
+  // Task breakdown
+  if (result.taskBreakdown.length > 0) {
+    console.log(`${c.cyan}${c.bold}📋 TASK BREAKDOWN:${c.reset}`);
+    for (const task of result.taskBreakdown) {
+      const priorityColor = task.priority === "critical" ? c.red :
+                            task.priority === "high" ? c.yellow :
+                            task.priority === "medium" ? c.blue : c.dim;
+      console.log(`   ${priorityColor}[${task.priority.toUpperCase()}]${c.reset} ${task.title}`);
+      console.log(`      ${c.dim}${task.description}${c.reset}`);
+      console.log(`      Estimated time: ${task.estimatedTime.toFixed(0)} minutes`);
+      if (task.dependencies.length > 0) {
+        console.log(`      Depends on: ${task.dependencies.join(", ")}`);
+      }
+    }
+    console.log();
+  }
+
+  // Version control info
+  if (result.versionControl && result.versionControl.branch !== "unknown") {
+    console.log(`${c.cyan}${c.bold}🔀 VERSION CONTROL:${c.reset}`);
+    console.log(`   Branch: ${result.versionControl.branch}`);
+    console.log(`   Commit: ${result.versionControl.commit.substring(0, 8)}`);
+    console.log(`   Changes: ${result.versionControl.changes.length} file(s)`);
+    if (result.versionControl.conflicts.length > 0) {
+      console.log(`   ${c.red}Conflicts: ${result.versionControl.conflicts.length}${c.reset}`);
+    }
+    console.log();
+  }
+
+  // Immediate fixes
+  if (result.immediateFixes.length > 0) {
+    console.log(`${c.yellow}${c.bold}🔧 IMMEDIATE FIXES AVAILABLE:${c.reset}`);
+    for (const fix of result.immediateFixes) {
+      console.log(`   • ${fix.description}`);
+      console.log(`     File: ${fix.file}`);
+      console.log(`     Confidence: ${(fix.confidence * 100).toFixed(0)}%`);
+    }
+    console.log();
+  }
+
+  // Future plan
+  if (result.futurePlan && result.futurePlan.tasks.length > 0) {
+    console.log(`${c.cyan}${c.bold}📅 FUTURE PLAN:${c.reset}`);
+    console.log(`   Phase: ${result.futurePlan.phase}`);
+    console.log(`   Tasks: ${result.futurePlan.tasks.length}`);
+    console.log(`   Milestones: ${result.futurePlan.milestones.length}`);
+    if (result.futurePlan.risks.length > 0) {
+      console.log(`   ${c.yellow}Risks: ${result.futurePlan.risks.length}${c.reset}`);
+    }
+    console.log();
+  }
+
+  // Recommendations
+  if (result.recommendations.length > 0) {
+    console.log(`${c.cyan}${c.bold}💡 RECOMMENDATIONS:${c.reset}`);
+    for (const rec of result.recommendations) {
+      console.log(`   • ${rec}`);
+    }
+    console.log();
+  }
+}
+
+function askToApplyFixes(fixCount) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    rl.question(`${c.yellow}Apply ${fixCount} immediate fix(es)? (y/n): ${c.reset}`, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+
+module.exports = { runPromptFirewall };

package/bin/runners/runProof.js

@@ -0,0 +1,2 @@
+async function runProof(args) { console.log("Proof command not yet implemented"); return 0; }
+module.exports = { runProof };

package/bin/runners/runProve.js

@@ -0,0 +1,392 @@
+/**
+ * vibecheck prove - One Command Reality Proof
+ *
+ * Orchestrates the complete "make it real" loop:
+ * 1. ctx - Refresh truthpack
+ * 2. reality --verify-auth - Runtime proof
+ * 3. ship - Static + runtime verdict
+ * 4. If BLOCK: fix --autopilot --apply
+ * 5. Re-run reality + ship to confirm SHIP
+ *
+ * One command = one outcome: either it's real, or it keeps fixing until it is.
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { buildTruthpack, writeTruthpack, detectFastifyEntry } = require("./lib/truth");
+const { shipCore } = require("./runShip");
+
+let runReality;
+try {
+  runReality = require("./runReality").runReality;
+} catch {
+  runReality = null;
+}
+
+let runFixCore;
+try {
+  runFixCore = require("./runFix").runFixCore;
+} catch {
+  runFixCore = null;
+}
+
+const c = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  cyan: "\x1b[36m",
+  blue: "\x1b[34m",
+};
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function stamp() {
+  const d = new Date();
+  const z = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${z(d.getMonth() + 1)}${z(d.getDate())}_${z(d.getHours())}${z(d.getMinutes())}${z(d.getSeconds())}`;
+}
+
+async function runProve({
+  repoRoot,
+  url,
+  auth,
+  storageState,
+  fastifyEntry,
+  maxFixRounds = 3,
+  maxMissions = 8,
+  maxSteps = 10,
+  skipReality = false,
+  skipFix = false,
+  headed = false,
+  danger = false,
+  maxPages = 18,
+  maxDepth = 2,
+  timeoutMs = 15000
+} = {}) {
+  const root = repoRoot || process.cwd();
+  const startTime = Date.now();
+
+  console.log(`
+${c.cyan}${c.bold}╔════════════════════════════════════════════════════════════╗
+║  🔬 vibecheck prove                                          ║
+║  One command to make it real                                 ║
+╚════════════════════════════════════════════════════════════╝${c.reset}
+`);
+
+  const outDir = path.join(root, ".vibecheck", "prove", stamp());
+  ensureDir(outDir);
+
+  const timeline = [];
+  let finalVerdict = "UNKNOWN";
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // STEP 1: CTX - Refresh truthpack
+  // ═══════════════════════════════════════════════════════════════════════════
+  console.log(`${c.cyan}▶ Step 1: Refreshing context (truthpack)...${c.reset}`);
+  
+  try {
+    const fastEntry = fastifyEntry || (await detectFastifyEntry(root));
+    const truthpack = await buildTruthpack({ repoRoot: root, fastifyEntry: fastEntry });
+    writeTruthpack(root, truthpack);
+    
+    timeline.push({
+      step: 1,
+      action: "ctx",
+      status: "ok",
+      routes: truthpack.routes?.server?.length || 0,
+      envVars: truthpack.env?.vars?.length || 0
+    });
+    
+    console.log(`  ${c.green}✓${c.reset} Truthpack refreshed (${truthpack.routes?.server?.length || 0} routes, ${truthpack.env?.vars?.length || 0} env vars)`);
+  } catch (err) {
+    timeline.push({ step: 1, action: "ctx", status: "error", error: err.message });
+    console.log(`  ${c.yellow}⚠️ Context refresh failed: ${err.message}${c.reset}`);
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // STEP 2: REALITY - Runtime UI proof (if URL provided)
+  // ═══════════════════════════════════════════════════════════════════════════
+  if (url && !skipReality && runReality) {
+    console.log(`\n${c.cyan}▶ Step 2: Running reality check (${url})...${c.reset}`);
+    
+    try {
+      await runReality({
+        repoRoot: root,
+        url,
+        auth,
+        storageState,
+        verifyAuth: !!auth || !!storageState,
+        headed,
+        maxPages,
+        maxDepth,
+        danger,
+        timeoutMs
+      });
+      
+      // Read reality report for timeline
+      const realityPath = path.join(root, ".vibecheck", "reality", "last_reality.json");
+      if (fs.existsSync(realityPath)) {
+        const reality = JSON.parse(fs.readFileSync(realityPath, "utf8"));
+        const blocks = (reality.findings || []).filter(f => f.severity === "BLOCK").length;
+        const warns = (reality.findings || []).filter(f => f.severity === "WARN").length;
+        
+        timeline.push({
+          step: 2,
+          action: "reality",
+          status: blocks ? "BLOCK" : warns ? "WARN" : "CLEAN",
+          findings: { BLOCK: blocks, WARN: warns },
+          pagesVisited: reality.passes?.anon?.pagesVisited?.length || 0,
+          coverage: reality.coverage?.percent || null
+        });
+        
+        console.log(`  ${c.green}✓${c.reset} Reality check complete (${blocks} BLOCK, ${warns} WARN)`);
+        if (reality.coverage) {
+          console.log(`  ${c.dim}Coverage: ${reality.coverage.percent}% of UI paths${c.reset}`);
+        }
+      }
+    } catch (err) {
+      timeline.push({ step: 2, action: "reality", status: "error", error: err.message });
+      console.log(`  ${c.yellow}⚠️ Reality check failed: ${err.message}${c.reset}`);
+    }
+  } else if (!url) {
+    console.log(`\n${c.dim}▶ Step 2: Skipping reality (no --url provided)${c.reset}`);
+    timeline.push({ step: 2, action: "reality", status: "skipped", reason: "no URL" });
+  } else if (skipReality) {
+    console.log(`\n${c.dim}▶ Step 2: Skipping reality (--skip-reality)${c.reset}`);
+    timeline.push({ step: 2, action: "reality", status: "skipped", reason: "--skip-reality" });
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // STEP 3: SHIP - Get initial verdict
+  // ═══════════════════════════════════════════════════════════════════════════
+  console.log(`\n${c.cyan}▶ Step 3: Running ship check...${c.reset}`);
+  
+  let shipResult = await shipCore({ repoRoot: root, fastifyEntry, noWrite: false });
+  
+  timeline.push({
+    step: 3,
+    action: "ship",
+    verdict: shipResult.verdict,
+    findingsCount: shipResult.report?.findings?.length || 0
+  });
+  
+  const verdictColor = shipResult.verdict === "SHIP" ? c.green : shipResult.verdict === "WARN" ? c.yellow : c.red;
+  console.log(`  ${verdictColor}${shipResult.verdict}${c.reset} (${shipResult.report?.findings?.length || 0} findings)`);
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // STEP 4: FIX LOOP - If BLOCK, attempt autopilot fix
+  // ═══════════════════════════════════════════════════════════════════════════
+  let fixRound = 0;
+  
+  while (shipResult.verdict === "BLOCK" && !skipFix && fixRound < maxFixRounds) {
+    fixRound++;
+    console.log(`\n${c.cyan}▶ Step 4.${fixRound}: Fix round ${fixRound}/${maxFixRounds}...${c.reset}`);
+    
+    try {
+      // Import fix dependencies lazily
+      const { planMissions } = require("./lib/missions/plan");
+      const { templateForMissionType } = require("./lib/missions/templates");
+      const { expandEvidence } = require("./lib/missions/evidence");
+      const { buildRealityFirewall } = require("./lib/firewall-prompt");
+      const { generatePatchJson } = require("./lib/llm");
+      const { applyUnifiedDiff } = require("./lib/patch");
+      const { backupFiles, restoreBackup } = require("./lib/backup");
+      const { validatePatchResponse } = require("./lib/validate-patch");
+      
+      const findings = shipResult.report?.findings || [];
+      const missions = planMissions(findings, { maxMissions, blocksOnlyFirst: true });
+      
+      if (!missions.length) {
+        console.log(`  ${c.yellow}No fixable missions found.${c.reset}`);
+        timeline.push({ step: `4.${fixRound}`, action: "fix", status: "no_missions" });
+        break;
+      }
+      
+      console.log(`  Planning ${missions.length} missions...`);
+      
+      let fixedAny = false;
+      
+      for (const mission of missions.slice(0, 3)) {
+        const targetFindings = findings.filter(f => mission.targetFindingIds.includes(f.id));
+        const template = templateForMissionType(mission.type);
+        
+        const expanded = await expandEvidence({
+          repoRoot: root,
+          truthpack: shipResult.truthpack,
+          mission,
+          targetFindings
+        });
+        
+        const prompt = buildRealityFirewall({
+          truthpackSummary: {
+            serverRoutes: shipResult.truthpack?.routes?.server?.length || 0,
+            clientRefs: shipResult.truthpack?.routes?.clientRefs?.length || 0,
+            envVars: shipResult.truthpack?.env?.vars?.length || 0
+          },
+          mission,
+          template,
+          findings: targetFindings,
+          fileSnippets: expanded.snippets,
+          allowedFiles: expanded.allowedFiles
+        });
+        
+        console.log(`  ${c.dim}Mission: ${mission.title}${c.reset}`);
+        
+        try {
+          const patchResponse = await generatePatchJson(prompt);
+          
+          if (!patchResponse || patchResponse.status !== "ok" || !patchResponse.edits?.length) {
+            console.log(`    ${c.yellow}⚠️ No patch generated${c.reset}`);
+            continue;
+          }
+          
+          const validation = validatePatchResponse(patchResponse, {
+            allowedFiles: expanded.allowedFiles,
+            beforeTruthpack: shipResult.truthpack
+          });
+          
+          if (!validation.valid) {
+            console.log(`    ${c.yellow}⚠️ Patch validation failed: ${validation.reason}${c.reset}`);
+            continue;
+          }
+          
+          // Backup before applying
+          const touchedFiles = patchResponse.edits.map(e => e.path).filter(Boolean);
+          const backupRoot = path.join(outDir, `backup_${fixRound}_${mission.id}`);
+          backupFiles(root, touchedFiles, backupRoot);
+          
+          // Apply patches
+          let appliedAny = false;
+          for (const edit of patchResponse.edits) {
+            if (!edit.diff || !edit.path) continue;
+            
+            try {
+              await applyUnifiedDiff(root, edit.diff);
+              appliedAny = true;
+              console.log(`    ${c.green}✓${c.reset} Applied: ${edit.path}`);
+            } catch (e) {
+              console.log(`    ${c.red}✗${c.reset} Failed: ${edit.path} - ${e.message}`);
+            }
+          }
+          
+          if (appliedAny) {
+            fixedAny = true;
+          }
+        } catch (e) {
+          console.log(`    ${c.yellow}⚠️ LLM error: ${e.message}${c.reset}`);
+        }
+      }
+      
+      timeline.push({
+        step: `4.${fixRound}`,
+        action: "fix",
+        status: fixedAny ? "applied" : "no_changes",
+        missionsAttempted: Math.min(missions.length, 3)
+      });
+      
+      if (!fixedAny) {
+        console.log(`  ${c.yellow}No fixes applied this round.${c.reset}`);
+        break;
+      }
+      
+      // Re-run ship to check progress
+      console.log(`  Re-checking ship verdict...`);
+      shipResult = await shipCore({ repoRoot: root, fastifyEntry, noWrite: false });
+      
+      const newVerdictColor = shipResult.verdict === "SHIP" ? c.green : shipResult.verdict === "WARN" ? c.yellow : c.red;
+      console.log(`  ${newVerdictColor}${shipResult.verdict}${c.reset} (${shipResult.report?.findings?.length || 0} findings)`);
+      
+    } catch (err) {
+      console.log(`  ${c.red}Fix error: ${err.message}${c.reset}`);
+      timeline.push({ step: `4.${fixRound}`, action: "fix", status: "error", error: err.message });
+      break;
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // STEP 5: FINAL VERIFICATION - Re-run reality + ship
+  // ═══════════════════════════════════════════════════════════════════════════
+  if (url && !skipReality && runReality && fixRound > 0) {
+    console.log(`\n${c.cyan}▶ Step 5: Final verification...${c.reset}`);
+    
+    try {
+      await runReality({
+        repoRoot: root,
+        url,
+        auth,
+        storageState,
+        verifyAuth: !!auth || !!storageState,
+        headed,
+        maxPages,
+        maxDepth,
+        danger,
+        timeoutMs
+      });
+      
+      shipResult = await shipCore({ repoRoot: root, fastifyEntry, noWrite: false });
+      
+      timeline.push({
+        step: 5,
+        action: "verify",
+        verdict: shipResult.verdict,
+        findingsCount: shipResult.report?.findings?.length || 0
+      });
+      
+      const finalColor = shipResult.verdict === "SHIP" ? c.green : shipResult.verdict === "WARN" ? c.yellow : c.red;
+      console.log(`  Final verdict: ${finalColor}${shipResult.verdict}${c.reset}`);
+    } catch (err) {
+      console.log(`  ${c.yellow}⚠️ Final verification failed: ${err.message}${c.reset}`);
+    }
+  }
+
+  finalVerdict = shipResult.verdict;
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SUMMARY
+  // ═══════════════════════════════════════════════════════════════════════════
+  const duration = Math.round((Date.now() - startTime) / 1000);
+  
+  const report = {
+    meta: {
+      startedAt: new Date(startTime).toISOString(),
+      finishedAt: new Date().toISOString(),
+      durationSeconds: duration,
+      url: url || null,
+      fixRounds: fixRound
+    },
+    timeline,
+    finalVerdict,
+    finalFindings: shipResult.report?.findings?.length || 0
+  };
+  
+  fs.writeFileSync(path.join(outDir, "prove_report.json"), JSON.stringify(report, null, 2), "utf8");
+  
+  // Also save a stable pointer
+  const latestPath = path.join(root, ".vibecheck", "prove", "last_prove.json");
+  ensureDir(path.dirname(latestPath));
+  fs.writeFileSync(latestPath, JSON.stringify(report, null, 2), "utf8");
+
+  console.log(`
+${c.cyan}${c.bold}════════════════════════════════════════════════════════════${c.reset}
+${c.bold}PROVE COMPLETE${c.reset}
+
+  Duration: ${duration}s
+  Fix rounds: ${fixRound}
+  Final verdict: ${finalVerdict === "SHIP" ? c.green : finalVerdict === "WARN" ? c.yellow : c.red}${finalVerdict}${c.reset}
+  Findings: ${shipResult.report?.findings?.length || 0}
+  
+  Report: .vibecheck/prove/${path.basename(outDir)}/prove_report.json
+${c.cyan}════════════════════════════════════════════════════════════${c.reset}
+`);
+
+  process.exitCode = finalVerdict === "SHIP" ? 0 : finalVerdict === "WARN" ? 1 : 2;
+}
+
+module.exports = { runProve };