@vibecheckai/cli 2.8.2 → 3.0.0

package/bin/runners/lib/share-pack.js

@@ -0,0 +1,239 @@
+// bin/runners/lib/share-pack.js
+const fs = require("fs");
+const path = require("path");
+const { redactObject } = require("./redact");
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function listMissionDirs(repoRoot) {
+  const base = path.join(repoRoot, ".vibecheck", "missions");
+  if (!fs.existsSync(base)) return [];
+  const dirs = fs.readdirSync(base)
+    .map(name => ({ name, abs: path.join(base, name) }))
+    .filter(x => fs.existsSync(x.abs) && fs.statSync(x.abs).isDirectory())
+    .sort((a,b) => (a.name < b.name ? 1 : -1));
+  return dirs;
+}
+
+function findLatestMissionDir(repoRoot) {
+  const dirs = listMissionDirs(repoRoot);
+  return dirs.length ? dirs[0].abs : null;
+}
+
+function parseStepFiles(dirAbs) {
+  const files = fs.readdirSync(dirAbs).sort();
+  const steps = {};
+
+  for (const f of files) {
+    const m = f.match(/^step_(\d+)_([^_]+)_([a-z_]+)\.(json|txt)$/);
+    if (!m) continue;
+
+    const stepNo = Number(m[1]);
+    const missionId = m[2];
+    const kind = m[3];
+    const abs = path.join(dirAbs, f);
+
+    steps[stepNo] = steps[stepNo] || { stepNo, missionId, files: {} };
+    steps[stepNo].files[kind] = abs;
+  }
+
+  return Object.values(steps).sort((a,b) => a.stepNo - b.stepNo);
+}
+
+function countSeverities(findings) {
+  const out = { BLOCK: 0, WARN: 0, INFO: 0 };
+  for (const f of findings || []) {
+    if (f.severity === "BLOCK") out.BLOCK++;
+    else if (f.severity === "WARN") out.WARN++;
+    else out.INFO++;
+  }
+  return out;
+}
+
+function extractProgressTimeline(steps) {
+  const timeline = [];
+  for (const s of steps) {
+    const beforePath = s.files["before_ship"];
+    const afterPath = s.files["after_ship"];
+    if (!beforePath || !afterPath) continue;
+
+    const before = JSON.parse(fs.readFileSync(beforePath, "utf8"));
+    const after = JSON.parse(fs.readFileSync(afterPath, "utf8"));
+
+    timeline.push({
+      step: s.stepNo,
+      missionId: s.missionId,
+      before: {
+        verdict: before?.meta?.verdict,
+        counts: countSeverities(before?.findings)
+      },
+      after: {
+        verdict: after?.meta?.verdict,
+        counts: countSeverities(after?.findings)
+      }
+    });
+  }
+  return timeline;
+}
+
+function safeFindingDigest(findings, limit = 20) {
+  return (findings || []).slice(0, limit).map(f => ({
+    id: f.id,
+    severity: f.severity,
+    category: f.category,
+    title: f.title,
+    confidence: f.confidence,
+    evidence: (f.evidence || []).slice(0, 2).map(ev => ({
+      file: ev.file,
+      lines: ev.lines,
+      snippetHash: ev.snippetHash,
+      reason: ev.reason
+    })),
+    fixHints: (f.fixHints || []).slice(0, 4)
+  }));
+}
+
+function buildMarkdown({ header, missions, timeline, startFindings, endFindings }) {
+  const startCounts = countSeverities(startFindings);
+  const endCounts = countSeverities(endFindings);
+
+  const lines = [];
+  lines.push(`# vibecheck Mission Pack`);
+  lines.push(``);
+  lines.push(`**Generated:** ${header.generatedAt}`);
+  lines.push(`**Repo:** ${header.repoName || "(local)"}`);
+  lines.push(`**Start Verdict:** ${header.startVerdict}  —  **End Verdict:** ${header.endVerdict}`);
+  lines.push(``);
+  lines.push(`## Summary`);
+  lines.push(`- Start: BLOCK=${startCounts.BLOCK}, WARN=${startCounts.WARN}`);
+  lines.push(`- End:   BLOCK=${endCounts.BLOCK}, WARN=${endCounts.WARN}`);
+  lines.push(`- Missions planned: ${missions.length}`);
+  lines.push(``);
+
+  lines.push(`## Verdict Timeline`);
+  lines.push(`| Step | Mission | Before | After |`);
+  lines.push(`|---:|---|---|---|`);
+  for (const t of timeline) {
+    const b = `${t.before.verdict} (B${t.before.counts.BLOCK}/W${t.before.counts.WARN})`;
+    const a = `${t.after.verdict} (B${t.after.counts.BLOCK}/W${t.after.counts.WARN})`;
+    lines.push(`| ${t.step} | ${t.missionId} | ${b} | ${a} |`);
+  }
+  lines.push(``);
+
+  lines.push(`## Key Findings (Start)`);
+  for (const f of safeFindingDigest(startFindings, 12)) {
+    lines.push(`- **${f.severity}** ${f.id} — ${f.title}`);
+    if (f.evidence?.[0]) {
+      const ev = f.evidence[0];
+      lines.push(`  - Evidence: \`${ev.file}:${ev.lines}\` (${ev.reason})`);
+      lines.push(`  - SnipHash: \`${ev.snippetHash}\``);
+    }
+  }
+  lines.push(``);
+
+  lines.push(`## Remaining Findings (End)`);
+  const endDigest = safeFindingDigest(endFindings, 12);
+  if (!endDigest.length) {
+    lines.push(`✅ None.`);
+  } else {
+    for (const f of endDigest) {
+      lines.push(`- **${f.severity}** ${f.id} — ${f.title}`);
+      if (f.evidence?.[0]) {
+        const ev = f.evidence[0];
+        lines.push(`  - Evidence: \`${ev.file}:${ev.lines}\` (${ev.reason})`);
+        lines.push(`  - SnipHash: \`${ev.snippetHash}\``);
+      }
+    }
+  }
+  lines.push(``);
+
+  lines.push(`## Notes`);
+  lines.push(`This bundle is sanitized: no secrets, no raw code snippets, only hashes + file/line pointers for verification.`);
+  lines.push(``);
+
+  return lines.join("\n");
+}
+
+function buildPrComment(md) {
+  const max = 9000;
+  if (md.length <= max) return md;
+  return md.slice(0, max) + "\n\n…(truncated)";
+}
+
+function buildSharePack({ repoRoot, missionDirAbs, outputDirAbs }) {
+  const root = repoRoot || process.cwd();
+  const missionDir = missionDirAbs || findLatestMissionDir(root);
+  if (!missionDir) throw new Error("No mission packs found in .vibecheck/missions");
+
+  const outputDir = outputDirAbs || path.join(missionDir, "share");
+  ensureDir(outputDir);
+
+  const missionsPath = path.join(missionDir, "missions.json");
+  const missionsObj = fs.existsSync(missionsPath)
+    ? JSON.parse(fs.readFileSync(missionsPath, "utf8"))
+    : { missions: [] };
+
+  const steps = parseStepFiles(missionDir);
+  const timeline = extractProgressTimeline(steps);
+
+  let startReport = null;
+  let endReport = null;
+
+  const firstStep = steps.find(s => s.files["before_ship"]);
+  const lastStep = [...steps].reverse().find(s => s.files["after_ship"]);
+
+  if (firstStep) startReport = JSON.parse(fs.readFileSync(firstStep.files["before_ship"], "utf8"));
+  if (lastStep) endReport = JSON.parse(fs.readFileSync(lastStep.files["after_ship"], "utf8"));
+
+  const fallbackLastShip = path.join(root, ".vibecheck", "last_ship.json");
+  if (!startReport && fs.existsSync(fallbackLastShip)) startReport = JSON.parse(fs.readFileSync(fallbackLastShip, "utf8"));
+  if (!endReport && fs.existsSync(fallbackLastShip)) endReport = JSON.parse(fs.readFileSync(fallbackLastShip, "utf8"));
+
+  const header = {
+    generatedAt: new Date().toISOString(),
+    repoName: path.basename(root),
+    missionPack: path.relative(root, missionDir).replace(/\\/g, "/"),
+    startVerdict: startReport?.meta?.verdict || "unknown",
+    endVerdict: endReport?.meta?.verdict || "unknown"
+  };
+
+  const shareJson = redactObject({
+    header,
+    missions: missionsObj.missions || [],
+    timeline,
+    startFindings: safeFindingDigest(startReport?.findings || [], 25),
+    endFindings: safeFindingDigest(endReport?.findings || [], 25)
+  });
+
+  const shareJsonPath = path.join(outputDir, "share.json");
+  fs.writeFileSync(shareJsonPath, JSON.stringify(shareJson, null, 2), "utf8");
+
+  const md = buildMarkdown({
+    header,
+    missions: missionsObj.missions || [],
+    timeline,
+    startFindings: startReport?.findings || [],
+    endFindings: endReport?.findings || []
+  });
+
+  const mdPath = path.join(outputDir, "share.md");
+  fs.writeFileSync(mdPath, md, "utf8");
+
+  const prBody = buildPrComment(md);
+  const prPath = path.join(outputDir, "pr_comment.md");
+  fs.writeFileSync(prPath, prBody, "utf8");
+
+  return {
+    missionDir,
+    outputDir,
+    files: {
+      shareJson: shareJsonPath,
+      shareMd: mdPath,
+      prComment: prPath
+    }
+  };
+}
+
+module.exports = { buildSharePack, findLatestMissionDir };

package/bin/runners/lib/snippets.js

@@ -0,0 +1,67 @@
+// bin/runners/lib/snippets.js
+const fs = require("fs");
+const path = require("path");
+
+function parseLineRange(s) {
+  const m = String(s || "").match(/^(\d+)-(\d+)$/);
+  if (!m) return { start: 1, end: 1 };
+  return { start: Number(m[1]), end: Number(m[2]) };
+}
+
+function getSnippet(repoRoot, ev, pad = 6) {
+  const fileAbs = path.join(repoRoot, ev.file);
+  if (!fs.existsSync(fileAbs)) return null;
+
+  const lines = fs.readFileSync(fileAbs, "utf8").split(/\r?\n/);
+  const { start, end } = parseLineRange(ev.lines);
+  const s = Math.max(1, start - pad);
+  const e = Math.min(lines.length, end + pad);
+
+  return {
+    file: ev.file,
+    range: `${s}-${e}`,
+    reason: ev.reason,
+    text: lines.slice(s - 1, e).join("\n")
+  };
+}
+
+function collectEvidenceSnippets(repoRoot, findings, maxSnips = 12) {
+  const out = [];
+  for (const f of findings) {
+    for (const ev of (f.evidence || [])) {
+      const snip = getSnippet(repoRoot, ev);
+      if (snip) out.push(snip);
+      if (out.length >= maxSnips) return out;
+    }
+  }
+  return out;
+}
+
+function collectRegexSnippets(repoRoot, files, regex, { pad = 4, limit = 8 } = {}) {
+  const out = [];
+  const rx = regex instanceof RegExp ? regex : new RegExp(String(regex), "i");
+
+  for (const fileRel of files || []) {
+    const abs = path.join(repoRoot, fileRel);
+    if (!fs.existsSync(abs)) continue;
+
+    const lines = fs.readFileSync(abs, "utf8").split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+      if (!rx.test(lines[i])) continue;
+
+      const s = Math.max(1, (i + 1) - pad);
+      const e = Math.min(lines.length, (i + 1) + pad);
+      out.push({
+        file: fileRel,
+        range: `${s}-${e}`,
+        reason: `regex:${rx.toString()}`,
+        text: lines.slice(s - 1, e).join("\n")
+      });
+
+      if (out.length >= limit) return out;
+    }
+  }
+  return out;
+}
+
+module.exports = { collectEvidenceSnippets, collectRegexSnippets };