@automaze/proof 0.20260311.0

package/dist/cli.js

@@ -0,0 +1,934 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { join as join5, basename as basename2 } from "path";
+import { tmpdir } from "os";
+import { existsSync as existsSync3 } from "fs";
+
+// src/detect.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { join } from "path";
+var BROWSER_CONFIG_PATTERNS = [
+  "playwright.config.ts",
+  "playwright.config.js",
+  "playwright.config.mjs"
+];
+async function detectMode(projectDir) {
+  for (const config of BROWSER_CONFIG_PATTERNS) {
+    if (existsSync(join(projectDir, config))) {
+      return "browser";
+    }
+  }
+  const pkgPath = join(projectDir, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+      const allDeps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+        ...pkg.peerDependencies
+      };
+      if (allDeps["@playwright/test"] || allDeps["playwright"]) {
+        return "browser";
+      }
+    } catch {}
+  }
+  return "terminal";
+}
+
+// src/modes/visual.ts
+import { readdir, rm, copyFile, mkdir } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2, dirname } from "path";
+import { spawn as spawn2 } from "child_process";
+
+// src/duration.ts
+import { spawn } from "child_process";
+async function getVideoDuration(filePath) {
+  try {
+    const output = await new Promise((resolve, reject) => {
+      const proc = spawn("ffprobe", [
+        "-v",
+        "quiet",
+        "-print_format",
+        "json",
+        "-show_format",
+        filePath
+      ], { stdio: ["ignore", "pipe", "pipe"] });
+      let stdout = "";
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.on("close", (code) => code === 0 ? resolve(stdout) : reject(new Error("ffprobe failed")));
+      proc.on("error", reject);
+    });
+    const parsed = JSON.parse(output);
+    const seconds = parseFloat(parsed.format?.duration ?? "0");
+    return Math.round(seconds * 1000);
+  } catch {
+    return 0;
+  }
+}
+
+// src/modes/visual.ts
+async function captureVisual(options, runDir, filePrefix, config) {
+  const label = options.label ?? "recording";
+  const testFile = options.testFile;
+  const testDir = dirname(testFile);
+  const configCandidates = [
+    join2(testDir, "playwright.config.ts"),
+    join2(testDir, "playwright.config.js"),
+    join2(testDir, "playwright.config.mjs")
+  ];
+  const existingConfig = configCandidates.find((c) => existsSync2(c));
+  const testResultsDir = join2(runDir, "pw-results");
+  await mkdir(testResultsDir, { recursive: true });
+  const testArgs = [
+    "playwright",
+    "test",
+    testFile,
+    "--reporter=list",
+    "--output",
+    testResultsDir
+  ];
+  if (options.testName) {
+    testArgs.push("-g", options.testName);
+  }
+  if (existingConfig) {
+    testArgs.push("--config", existingConfig);
+  }
+  const env = {
+    ...process.env,
+    PWDEBUG: "0",
+    PLAYWRIGHT_VIDEO: "on"
+  };
+  let exitCode = null;
+  let stderr = "";
+  await new Promise((resolve) => {
+    const proc = spawn2("npx", testArgs, {
+      stdio: "pipe",
+      env,
+      cwd: testDir
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.on("close", (code) => {
+      exitCode = code;
+      resolve();
+    });
+    proc.on("error", (err) => {
+      throw new Error(`Failed to run Playwright: ${err.message}. Is @playwright/test installed?`);
+    });
+  });
+  const videoFile = await findVideo(testResultsDir);
+  if (!videoFile) {
+    const hint = stderr.trim() ? `
+Playwright output:
+${stderr.trim().split(`
+`).slice(-5).join(`
+`)}` : "";
+    throw new Error(`No video file found after Playwright test run. Check that video: 'on' is set in playwright config.${hint}`);
+  }
+  const ext = videoFile.endsWith(".webm") ? ".webm" : ".mp4";
+  const finalPath = join2(runDir, `${filePrefix}${ext}`);
+  await copyFile(videoFile, finalPath);
+  await rm(testResultsDir, { recursive: true, force: true });
+  const duration = await getVideoDuration(finalPath);
+  return {
+    path: finalPath,
+    mode: "browser",
+    duration,
+    label
+  };
+}
+async function findVideo(resultsDir) {
+  if (!existsSync2(resultsDir))
+    return null;
+  const entries = await readdir(resultsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory() && (entry.name.endsWith(".webm") || entry.name.endsWith(".mp4"))) {
+      return join2(resultsDir, entry.name);
+    }
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const subDir = join2(resultsDir, entry.name);
+    const files = await readdir(subDir);
+    const video = files.find((f) => f.endsWith(".webm") || f.endsWith(".mp4"));
+    if (video)
+      return join2(subDir, video);
+  }
+  return null;
+}
+
+// src/modes/terminal.ts
+import { spawn as spawn3 } from "child_process";
+import { writeFile } from "fs/promises";
+import { join as join3 } from "path";
+async function captureTerminal(options, runDir, filePrefix, command, config) {
+  const label = options.label ?? "terminal";
+  const castPath = join3(runDir, `${filePrefix}.cast`);
+  const htmlPath = join3(runDir, `${filePrefix}.html`);
+  const cols = config.cols ?? 120;
+  const rows = config.rows ?? 30;
+  const events = [];
+  const startTime = Date.now();
+  let exitCode = null;
+  await new Promise((resolve) => {
+    const proc = spawn3("/bin/sh", ["-c", command], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        COLUMNS: String(cols),
+        LINES: String(rows),
+        FORCE_COLOR: "1",
+        TERM: "xterm-256color",
+        NO_COLOR: undefined
+      }
+    });
+    proc.stdout.on("data", (chunk) => {
+      events.push({
+        time: (Date.now() - startTime) / 1000,
+        data: chunk.toString()
+      });
+    });
+    proc.stderr.on("data", (chunk) => {
+      events.push({
+        time: (Date.now() - startTime) / 1000,
+        data: chunk.toString()
+      });
+    });
+    proc.on("close", (code) => {
+      exitCode = code;
+      resolve();
+    });
+    proc.on("error", (err) => {
+      events.push({
+        time: (Date.now() - startTime) / 1000,
+        data: `\x1B[31mError: ${err.message}\x1B[0m
+`
+      });
+      resolve();
+    });
+  });
+  const duration = Date.now() - startTime;
+  const realDurationSec = duration / 1000;
+  const initialSpeed = realDurationSec < 0.2 ? 0.1 : realDurationSec < 0.5 ? 0.25 : realDurationSec < 1 ? 0.5 : realDurationSec < 2 ? 0.5 : 1;
+  const header = JSON.stringify({
+    version: 2,
+    width: cols,
+    height: rows,
+    timestamp: Math.floor(startTime / 1000),
+    env: { SHELL: "/bin/sh", TERM: "xterm-256color" }
+  });
+  const castLines = [header];
+  for (const evt of events) {
+    castLines.push(JSON.stringify([evt.time, "o", evt.data]));
+  }
+  await writeFile(castPath, castLines.join(`
+`) + `
+`, "utf-8");
+  const castDataJson = JSON.stringify(events);
+  const html = buildPlayerHtml(label, cols, rows, castDataJson, realDurationSec, initialSpeed);
+  await writeFile(htmlPath, html, "utf-8");
+  return {
+    path: htmlPath,
+    mode: "terminal",
+    duration,
+    label
+  };
+}
+function buildPlayerHtml(label, cols, rows, castDataJson, durationSec, initialSpeed) {
+  const speeds = [0.1, 0.25, 0.5, 1, 1.25, 1.5, 1.75, 2, 4];
+  const speedOptions = speeds.map((s) => `<option value="${s}"${s === initialSpeed ? " selected" : ""}>${s}x</option>`).join("");
+  return `<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>${label} — proof terminal recording</title>
+<style>
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  html, body { margin: 0; height: 100%; }
+  body { background: transparent; -webkit-font-smoothing: antialiased; font-family: system-ui, sans-serif; }
+  .player {
+    background: #0d1117;
+    overflow: hidden;
+    width: 100%;
+    height: 100%;
+  }
+  #terminal {
+    height: calc(100% - 40px);
+    padding: 14px;
+    font-family: ui-monospace, monospace;
+    font-size: 12px;
+    line-height: 1.4;
+    color: #fff;
+    white-space: pre-wrap;
+    word-wrap: break-word;
+    overflow-y: auto;
+    opacity: .9;
+  }
+  .controls {
+    padding: 6px 10px;
+    border-top: 1px solid #30363d;
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    height: 40px;
+  }
+  .btn {
+    background: none;
+    border: 1px solid #30363d;
+    color: #e6edf3;
+    padding: 4px 12px;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 13px;
+    font-family: system-ui;
+  }
+  .btn:hover { background: #21262d; }
+  .speed-select {
+    background: #0d1117;
+    border: 1px solid #30363d;
+    color: #e6edf3;
+    padding: 4px 8px;
+    border-radius: 4px;
+    font-size: 13px;
+    font-family: system-ui;
+    cursor: pointer;
+  }
+  .speed-select:hover { background: #21262d; }
+  .progress {
+    flex: 1;
+    height: 4px;
+    background: #21262d;
+    border-radius: 2px;
+    overflow: hidden;
+    cursor: pointer;
+  }
+  .progress-bar {
+    height: 100%;
+    background: #58a6ff;
+    width: 0%;
+    transition: width 0.1s linear;
+  }
+  .time { color: #8b949e; font-size: 12px; font-family: monospace; min-width: 40px; text-align: right; line-height: 27px; }
+</style>
+</head>
+<body>
+<div class="player">
+  <div id="terminal"></div>
+  <div class="controls">
+    <button class="btn" id="playBtn" onclick="toggle()">Play</button>
+    <select class="speed-select" id="speedSelect" onchange="changeSpeed(this.value)">${speedOptions}</select>
+    <div class="progress" onclick="seek(event)"><div class="progress-bar" id="bar"></div></div>
+    <span class="time" id="time">0.0s / ${durationSec < 1 ? (durationSec * 1000).toFixed(0) + "ms" : durationSec.toFixed(1) + "s"}</span>
+  </div>
+</div>
+<script>
+const events = ${castDataJson};
+const totalDuration = ${durationSec.toFixed(3)};
+const realDuration = ${durationSec.toFixed(3)};
+const term = document.getElementById('terminal');
+const bar = document.getElementById('bar');
+const timeEl = document.getElementById('time');
+const playBtn = document.getElementById('playBtn');
+
+let playing = false;
+let currentIdx = 0;
+let startTs = 0;
+let pausedAt = 0;
+let speed = ${initialSpeed};
+let raf = null;
+
+// Convert ANSI to styled HTML spans
+function ansiToHtml(str) {
+  const colors = ['#0d1117','#ff7b72','#3fb950','#d29922','#58a6ff','#bc8cff','#39d2e0','#e6edf3'];
+  const brights = ['#484f58','#ffa198','#56d364','#e3b341','#79c0ff','#d2a8ff','#56d4dd','#f0f6fc'];
+  let out = '';
+  let i = 0;
+  while (i < str.length) {
+    if (str[i] === '\\x1b' || str.charCodeAt(i) === 0x1b) {
+      const m = str.slice(i).match(/^(?:\\x1b|\\u001b|\\033|\\x1B)\\[([0-9;]*)m/);
+      if (m) {
+        const codes = m[1].split(';').map(Number);
+        let style = '';
+        for (const c of codes) {
+          if (c === 0) style += 'color:#e6edf3;font-weight:normal;font-style:normal;text-decoration:none;';
+          else if (c === 1) style += 'font-weight:bold;';
+          else if (c === 2) style += 'opacity:0.6;';
+          else if (c === 3) style += 'font-style:italic;';
+          else if (c === 4) style += 'text-decoration:underline;';
+          else if (c >= 30 && c <= 37) style += 'color:' + colors[c - 30] + ';';
+          else if (c >= 90 && c <= 97) style += 'color:' + brights[c - 90] + ';';
+        }
+        if (style) out += '</span><span style="' + style + '">';
+        i += m[0].length;
+        continue;
+      }
+    }
+    const ch = str[i];
+    if (ch === '<') out += '&lt;';
+    else if (ch === '>') out += '&gt;';
+    else if (ch === '&') out += '&amp;';
+    else out += ch;
+    i++;
+  }
+  return out;
+}
+
+function renderUpTo(elapsed) {
+  let html = '<span>';
+  for (let j = 0; j < events.length; j++) {
+    if (events[j].time > elapsed) { currentIdx = j; break; }
+    html += ansiToHtml(events[j].data);
+    if (j === events.length - 1) currentIdx = events.length;
+  }
+  html += '</span>';
+  term.innerHTML = html;
+  term.scrollTop = term.scrollHeight;
+  const pct = totalDuration > 0 ? Math.min(100, (elapsed / totalDuration) * 100) : 100;
+  bar.style.width = pct + '%';
+  timeEl.textContent = elapsed.toFixed(1) + 's';
+}
+
+function tick() {
+  if (!playing) return;
+  const elapsed = ((Date.now() - startTs) / 1000) * speed;
+  if (elapsed >= totalDuration) {
+    renderUpTo(totalDuration);
+    playing = false;
+    playBtn.textContent = 'Replay';
+    return;
+  }
+  renderUpTo(elapsed);
+  raf = requestAnimationFrame(tick);
+}
+
+function toggle() {
+  if (playing) {
+    playing = false;
+    pausedAt = ((Date.now() - startTs) / 1000) * speed;
+    playBtn.textContent = 'Play';
+    if (raf) cancelAnimationFrame(raf);
+  } else {
+    if (currentIdx >= events.length) {
+      pausedAt = 0;
+      term.innerHTML = '';
+      currentIdx = 0;
+    }
+    playing = true;
+    playBtn.textContent = 'Pause';
+    startTs = Date.now() - (pausedAt / speed) * 1000;
+    tick();
+  }
+}
+
+function changeSpeed(val) {
+  if (playing) pausedAt = ((Date.now() - startTs) / 1000) * speed;
+  speed = parseFloat(val);
+  if (playing) {
+    startTs = Date.now() - (pausedAt / speed) * 1000;
+  }
+}
+
+function seek(e) {
+  const rect = e.currentTarget.getBoundingClientRect();
+  const pct = (e.clientX - rect.left) / rect.width;
+  pausedAt = pct * totalDuration;
+  renderUpTo(pausedAt);
+  if (playing) {
+    startTs = Date.now() - (pausedAt / speed) * 1000;
+  }
+}
+
+// Render first frame
+renderUpTo(0);
+</script>
+</body>
+</html>`;
+}
+
+// src/report.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join as join4, basename } from "path";
+async function generateReport(manifest, runDir, format) {
+  switch (format) {
+    case "md":
+      return generateMd(manifest, runDir);
+    case "html":
+      return generateHtml(manifest, runDir, false);
+    case "archive":
+      return generateHtml(manifest, runDir, true);
+  }
+}
+function formatTime(iso) {
+  return new Date(iso).toLocaleTimeString("en-US", { hour12: false });
+}
+function formatDate(iso) {
+  return new Date(iso).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+}
+function formatDuration(ms) {
+  if (ms < 1000)
+    return `${ms}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+function modeIcon(mode) {
+  return mode === "browser" ? "\uD83C\uDF10" : "\uD83D\uDDA5";
+}
+function generateMd(manifest, runDir) {
+  const lines = [];
+  const totalDuration = manifest.entries.reduce((sum, e) => sum + e.duration, 0);
+  lines.push(`# Proof Report`);
+  lines.push(``);
+  lines.push(`**App:** ${manifest.appName}`);
+  lines.push(`**Run:** ${manifest.run}`);
+  lines.push(`**Date:** ${formatDate(manifest.createdAt)}`);
+  lines.push(`**Entries:** ${manifest.entries.length}`);
+  if (manifest.description) {
+    lines.push(``);
+    lines.push(manifest.description);
+  }
+  lines.push(``);
+  lines.push(`| # | Label | Mode | Duration | Artifact |`);
+  lines.push(`|---|-------|------|----------|----------|`);
+  manifest.entries.forEach((entry, i) => {
+    const label = entry.label ?? entry.mode;
+    lines.push(`| ${i + 1} | ${modeIcon(entry.mode)} ${label} | ${entry.mode} | ${formatDuration(entry.duration)} | [${entry.artifact}](./${entry.artifact}) |`);
+  });
+  lines.push(``);
+  lines.push(`---`);
+  lines.push(``);
+  for (const entry of manifest.entries) {
+    lines.push(`### ${modeIcon(entry.mode)} ${entry.label ?? entry.mode}`);
+    lines.push(``);
+    lines.push(`${entry.description}`);
+    lines.push(``);
+    lines.push(`- **Time:** ${formatTime(entry.timestamp)}`);
+    lines.push(`- **Duration:** ${formatDuration(entry.duration)}`);
+    if (entry.command)
+      lines.push(`- **Command:** \`${entry.command}\``);
+    if (entry.testFile)
+      lines.push(`- **Test file:** \`${basename(entry.testFile)}\``);
+    if (entry.testName)
+      lines.push(`- **Test name:** ${entry.testName}`);
+    lines.push(`- **Artifact:** [${entry.artifact}](./${entry.artifact})`);
+    lines.push(``);
+  }
+  lines.push(`---`);
+  lines.push(`*Generated by [@automaze/proof](https://www.npmjs.com/package/@automaze/proof)*`);
+  const md = lines.join(`
+`);
+  const outPath = join4(runDir, "report.md");
+  return writeFile2(outPath, md, "utf-8").then(() => outPath);
+}
+async function generateHtml(manifest, runDir, inline) {
+  const totalDuration = manifest.entries.reduce((sum, e) => sum + e.duration, 0);
+  const terminalCount = manifest.entries.filter((e) => e.mode === "terminal").length;
+  const browserCount = manifest.entries.filter((e) => e.mode === "browser").length;
+  const sections = [];
+  for (const entry of manifest.entries) {
+    const mediaHtml = await buildMediaEmbed(entry, runDir, inline);
+    const label = entry.label ?? entry.mode;
+    const isTerminal = entry.mode === "terminal";
+    const badgeClass = isTerminal ? "text-green-800 bg-emerald-100/80" : "text-blue-800 bg-sky-100";
+    const modeLabel = isTerminal ? "Terminal" : "Browser";
+    let sourceHtml = "";
+    if (entry.command) {
+      sourceHtml = `
+          <p class="font-medium text-sm mt-4 mb-1">Command:</p>
+          <div class="font-mono text-xs border px-1 rounded bg-neutral-50 border-neutral-200 subpixel-antialiased w-fit">${esc(entry.command)}</div>`;
+    } else if (entry.testFile) {
+      sourceHtml = `
+          <p class="font-medium text-sm mt-4 mb-1">Test:</p>
+          <div class="font-mono text-xs border px-1 rounded bg-neutral-50 border-neutral-200 subpixel-antialiased w-fit">${esc(basename(entry.testFile))}</div>`;
+    }
+    sections.push(`
+      <section class="mt-12 grid-cols-12 gap-x-6 border-t border-neutral-200 pt-12 md:grid">
+        <div class="col-span-5">
+          <h2 class="text-2xl mb-2">${esc(label)}</h2>
+          <div class="flex items-center space-x-4 subpixel-antialiased">
+            <span class="rounded ${badgeClass} px-2 py-0.5 text-sm">${modeLabel}</span>
+            <time class="font-mono text-[13px]">${formatTime(entry.timestamp)} (${formatDuration(entry.duration)})</time>
+          </div>
+          <p class="opacity-80 my-4">${esc(entry.description)}</p>
+        </div>
+        <div class="col-span-7">
+          ${mediaHtml}
+          ${sourceHtml}
+        </div>
+      </section>`);
+  }
+  const descriptionHtml = manifest.description ? `<p class="max-w-2xl leading-relaxed opacity-80">${esc(manifest.description)}</p>` : "";
+  const badgesHtml = [
+    terminalCount > 0 ? `<span class="whitespace-nowrap rounded font-medium text-green-800 bg-emerald-100/80 px-2 py-0.5 text-sm">${terminalCount} Terminal</span>` : "",
+    browserCount > 0 ? `<span class="whitespace-nowrap rounded font-medium text-blue-800 bg-sky-100 px-2 py-0.5 text-sm">${browserCount} Browser</span>` : ""
+  ].filter(Boolean).join(`
+        `);
+  const tailwindScript = inline ? `<script src="https://cdn.jsdelivr.net/npm/@tailwindcss/browser@4"></script>` : `<script src="https://cdn.jsdelivr.net/npm/@tailwindcss/browser@4"></script>`;
+  const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
+<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no, viewport-fit=cover">
+<meta http-equiv="cleartype" content="on">
+<title>Proof Report - ${esc(manifest.run)}</title>
+${tailwindScript}
+</head>
+<body>
+
+<div class="container mx-auto px-6 my-14 w-full max-w-5xl antialiased">
+  <header>
+    <div class="flex items-center space-x-4 mb-6">
+      <h1 class="text-4xl leading-none font-medium">Proof report</h1>
+      <span class="mt-2 rounded bg-neutral-100 px-2 py-1 font-mono text-sm leading-none">${esc(manifest.run)}</span>
+    </div>
+
+    ${descriptionHtml}
+
+    <div class="mt-6 md:flex md:items-center md:space-x-4 leading-none">
+      <span class="block mb-2 md:inline md:m-0">${formatDate(manifest.createdAt)} &middot; ${formatTime(manifest.createdAt)} (${formatDuration(totalDuration)})</span>
+      ${badgesHtml}
+    </div>
+
+    <p class="my-6">Generated by <a href="https://www.npmjs.com/package/@automaze/proof" class="font-medium text-blue-600">@automaze/proof</a></p>
+  </header>
+
+  <main>
+    ${sections.join(`
+`)}
+  </main>
+
+  <footer></footer>
+</div>
+
+</body>
+</html>`;
+  const ext = inline ? "archive.html" : "report.html";
+  const outPath = join4(runDir, ext);
+  await writeFile2(outPath, html, "utf-8");
+  return outPath;
+}
+async function buildMediaEmbed(entry, runDir, inline) {
+  const artifactPath = join4(runDir, entry.artifact);
+  if (entry.mode === "browser") {
+    if (inline) {
+      const videoData = await readFile2(artifactPath);
+      const ext = entry.artifact.endsWith(".mp4") ? "mp4" : "webm";
+      const b64 = videoData.toString("base64");
+      return `<video class="bg-black w-full shadow-xs rounded-md aspect-3/2" controls muted loop src="data:video/${ext};base64,${b64}"></video>`;
+    }
+    return `<video class="bg-neutral-200 w-full rounded-md aspect-3/2" controls muted loop src="./${esc(entry.artifact)}"></video>`;
+  }
+  if (entry.mode === "terminal") {
+    if (inline) {
+      const playerHtml = await readFile2(artifactPath, "utf-8");
+      return `<iframe class="w-full aspect-3/2 rounded-lg bg-black" allowtransparency="true" srcdoc="${escAttr(playerHtml)}"></iframe>`;
+    }
+    return `<iframe class="w-full aspect-3/2 rounded-lg bg-black" allowtransparency="true" src="./${esc(entry.artifact)}"></iframe>`;
+  }
+  return `<a href="./${esc(entry.artifact)}">${esc(entry.artifact)}</a>`;
+}
+function esc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function escAttr(s) {
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// src/index.ts
+class Proof {
+  config;
+  runDir;
+  runName;
+  initTime;
+  constructor(config) {
+    this.config = config;
+    this.initTime = new Date;
+    const root = config.proofDir ?? process.env.PROOF_DIR ?? join5(tmpdir(), "proof");
+    const dateStr = this.formatDate(this.initTime);
+    this.runName = config.run ?? this.formatTime(this.initTime);
+    this.runDir = join5(root, config.appName, dateStr, this.runName);
+  }
+  formatDate(d) {
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}`;
+  }
+  formatTime(d) {
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${pad(d.getHours())}${pad(d.getMinutes())}`;
+  }
+  formatTimestamp(d) {
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+  }
+  async ensureRunDir() {
+    await mkdir2(this.runDir, { recursive: true });
+    return this.runDir;
+  }
+  async resolveMode(optMode) {
+    const envMode = process.env.PROOF_MODE;
+    const mode = optMode ?? envMode ?? "auto";
+    if (mode !== "auto")
+      return mode;
+    return detectMode(process.cwd());
+  }
+  async appendToManifest(entry) {
+    const manifestPath = join5(this.runDir, "proof.json");
+    let manifest;
+    if (existsSync3(manifestPath)) {
+      const raw = await readFile3(manifestPath, "utf-8");
+      manifest = JSON.parse(raw);
+      manifest.entries.push(entry);
+    } else {
+      manifest = {
+        version: 1,
+        appName: this.config.appName,
+        description: this.config.description,
+        run: this.runName,
+        createdAt: this.initTime.toISOString(),
+        entries: [entry]
+      };
+    }
+    await writeFile3(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  }
+  async capture(options) {
+    const runDir = await this.ensureRunDir();
+    const mode = await this.resolveMode(options.mode);
+    const ts = this.formatTimestamp(new Date);
+    const label = options.label ?? mode;
+    const filePrefix = `${label}-${ts}`;
+    let recording;
+    switch (mode) {
+      case "browser": {
+        if (!options.testFile) {
+          throw new Error("browser mode requires testFile");
+        }
+        recording = await captureVisual(options, runDir, filePrefix, {
+          viewport: this.config.browser?.viewport
+        });
+        break;
+      }
+      case "terminal": {
+        if (!options.command) {
+          throw new Error("terminal mode requires command");
+        }
+        recording = await captureTerminal(options, runDir, filePrefix, options.command, this.config.terminal ?? {});
+        break;
+      }
+    }
+    const source = options.testFile ? basename2(options.testFile) : options.command ?? mode;
+    const fallbackDescriptions = {
+      browser: `Playwright browser test recording of ${source}${options.testName ? ` — test: "${options.testName}"` : ""}`,
+      terminal: `Terminal capture: ${source}`
+    };
+    const entry = {
+      timestamp: new Date().toISOString(),
+      mode,
+      label,
+      command: options.command,
+      testFile: options.testFile,
+      testName: options.testName,
+      duration: recording.duration,
+      artifact: basename2(recording.path),
+      description: options.description ?? fallbackDescriptions[mode]
+    };
+    await this.appendToManifest(entry);
+    return recording;
+  }
+  async report(options) {
+    const manifestPath = join5(this.runDir, "proof.json");
+    if (!existsSync3(manifestPath)) {
+      throw new Error("No proof.json found — run capture() first");
+    }
+    const manifest = JSON.parse(await readFile3(manifestPath, "utf-8"));
+    const formatInput = options?.format ?? "md";
+    const formats = Array.isArray(formatInput) ? formatInput : [formatInput];
+    const paths = [];
+    for (const format of formats) {
+      const path = await generateReport(manifest, this.runDir, format);
+      paths.push(path);
+    }
+    return Array.isArray(formatInput) ? paths : paths[0];
+  }
+}
+
+// src/cli.ts
+import { readFile as readFile4 } from "fs/promises";
+import { resolve } from "path";
+var __dirname = "/Users/ran/Projects/proof/src";
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h") || args.length === 0) {
+    printUsage();
+    process.exit(0);
+  }
+  if (args.includes("--version") || args.includes("-v")) {
+    const pkg = JSON.parse(await readFile4(resolve(__dirname, "../package.json"), "utf-8"));
+    console.log(pkg.version);
+    process.exit(0);
+  }
+  if (args[0] === "--json" || args[0] === "-") {
+    const input = await readStdin();
+    const config = JSON.parse(input);
+    await runFromConfig(config);
+    return;
+  }
+  const action = args[0];
+  if (action !== "capture" && action !== "report") {
+    console.error(`Unknown action: ${action}. Use "capture" or "report".`);
+    process.exit(1);
+  }
+  const parsed = parseArgs(args.slice(1));
+  if (!parsed.appName) {
+    console.error("--app is required");
+    process.exit(1);
+  }
+  if (action === "capture") {
+    if (!parsed.command && !parsed.testFile) {
+      console.error("--command or --test-file is required for capture");
+      process.exit(1);
+    }
+    const config = {
+      action: "capture",
+      appName: parsed.appName,
+      proofDir: parsed.proofDir,
+      run: parsed.run,
+      command: parsed.command,
+      testFile: parsed.testFile,
+      testName: parsed.testName,
+      label: parsed.label,
+      mode: parsed.mode,
+      description: parsed.description
+    };
+    await runFromConfig(config);
+  } else {
+    const config = {
+      action: "report",
+      appName: parsed.appName,
+      proofDir: parsed.proofDir,
+      run: parsed.run
+    };
+    await runFromConfig(config);
+  }
+}
+async function runFromConfig(config) {
+  const proof = new Proof({
+    appName: config.appName,
+    proofDir: config.proofDir,
+    run: config.run,
+    browser: config.browser,
+    terminal: config.terminal
+  });
+  if (config.action === "report") {
+    const reportPath = await proof.report();
+    const result = { action: "report", path: reportPath };
+    console.log(JSON.stringify(result));
+    return;
+  }
+  const captures = config.captures ?? [
+    {
+      command: config.command,
+      testFile: config.testFile,
+      testName: config.testName,
+      label: config.label,
+      mode: config.mode,
+      description: config.description
+    }
+  ];
+  const results = [];
+  for (const cap of captures) {
+    const recording = await proof.capture({
+      command: cap.command,
+      testFile: cap.testFile,
+      testName: cap.testName,
+      label: cap.label,
+      mode: cap.mode,
+      description: cap.description
+    });
+    results.push({
+      path: recording.path,
+      mode: recording.mode,
+      duration: recording.duration,
+      label: recording.label
+    });
+  }
+  const output = {
+    action: "capture",
+    appName: config.appName,
+    run: config.run,
+    recordings: results
+  };
+  console.log(JSON.stringify(output));
+}
+function parseArgs(args) {
+  const result = {};
+  const map = {
+    "--app": "appName",
+    "--dir": "proofDir",
+    "--run": "run",
+    "--command": "command",
+    "--test-file": "testFile",
+    "--test-name": "testName",
+    "--label": "label",
+    "--mode": "mode",
+    "--description": "description"
+  };
+  for (let i = 0;i < args.length; i++) {
+    const key = map[args[i]];
+    if (key && i + 1 < args.length) {
+      result[key] = args[++i];
+    }
+  }
+  return result;
+}
+function readStdin() {
+  return new Promise((resolve2) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve2(data));
+    process.stdin.resume();
+  });
+}
+function printUsage() {
+  console.log(`@automaze/proof — capture evidence of test execution
+
+Usage:
+  proof capture --app <name> --command <cmd> [options]
+  proof capture --app <name> --test-file <file> --mode browser [options]
+  proof report  --app <name> [options]
+  proof --json  < config.json
+
+Options:
+  --app <name>          App name (required)
+  --dir <path>          Proof directory (default: $TMPDIR/proof)
+  --run <name>          Run name (default: HHMM)
+  --command <cmd>       Command to run (required for terminal mode)
+  --test-file <file>    Playwright test file (required for browser mode)
+  --test-name <name>    Specific test name filter
+  --label <label>       Artifact filename prefix
+  --mode <mode>         browser | terminal | auto
+  --description <text>  Human-readable description
+
+JSON mode:
+  echo '{"action":"capture","appName":"my-app","captures":[...]}' | proof --json
+
+Output:
+  JSON to stdout with recording paths and metadata.`);
+}
+main().catch((err) => {
+  console.error(JSON.stringify({ error: err.message }));
+  process.exit(1);
+});