npm - @automaze/proof - Versions diffs - 0.20260311.0 - Mend

@automaze/proof 0.20260311.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

package/dist/index.test.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/index.test.js ADDED Viewed

@@ -0,0 +1,261 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { Proof } from "./index";
+import { join } from "path";
+import { mkdtemp, readFile, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { existsSync } from "fs";
+describe("Proof", () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(join(tmpdir(), "proof-test-"));
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    describe("constructor", () => {
+        test("creates run directory path from appName, date, and run", () => {
+            const proof = new Proof({
+                appName: "test-app",
+                proofDir: tempDir,
+                run: "my-run",
+            });
+            expect(proof).toBeDefined();
+        });
+        test("uses HHMM as default run name", () => {
+            const proof = new Proof({
+                appName: "test-app",
+                proofDir: tempDir,
+            });
+            expect(proof).toBeDefined();
+        });
+    });
+    describe("capture (terminal mode)", () => {
+        test("produces .cast and .html files", async () => {
+            const proof = new Proof({
+                appName: "test-app",
+                proofDir: tempDir,
+                run: "test-run",
+            });
+            const recording = await proof.capture({
+                command: `bun test ${join(import.meta.dir, "../test-app/cli/app.test.ts")}`,
+                mode: "terminal",
+                label: "cli",
+                description: "CLI tests",
+            });
+            expect(recording.mode).toBe("terminal");
+            expect(recording.path).toEndWith(".html");
+            expect(recording.duration).toBeGreaterThan(0);
+            expect(existsSync(recording.path)).toBe(true);
+            const castPath = recording.path.replace(".html", ".cast");
+            expect(existsSync(castPath)).toBe(true);
+            const castContent = await readFile(castPath, "utf-8");
+            const lines = castContent.trim().split("\n");
+            const header = JSON.parse(lines[0]);
+            expect(header.version).toBe(2);
+            expect(header.width).toBe(120);
+            expect(header.height).toBe(30);
+            expect(lines.length).toBeGreaterThan(1);
+            const event = JSON.parse(lines[1]);
+            expect(event).toHaveLength(3);
+            expect(typeof event[0]).toBe("number");
+            expect(event[1]).toBe("o");
+            expect(typeof event[2]).toBe("string");
+        });
+        test("HTML player is self-contained", async () => {
+            const proof = new Proof({
+                appName: "test-app",
+                proofDir: tempDir,
+                run: "test-run",
+            });
+            const recording = await proof.capture({
+                command: `bun test ${join(import.meta.dir, "../test-app/cli/app.test.ts")}`,
+                mode: "terminal",
+                label: "cli",
+            });
+            const html = await readFile(recording.path, "utf-8");
+            expect(html).toContain("<!DOCTYPE html>");
+            expect(html).toContain("ansiToHtml");
+            expect(html).toContain("<select");
+            expect(html).toContain("0.1x");
+            expect(html).toContain("4x");
+            expect(html).not.toContain("<script src=");
+            expect(html).not.toContain("<link rel=");
+        });
+        test("works with any command, not just bun test", async () => {
+            const proof = new Proof({
+                appName: "test-app",
+                proofDir: tempDir,
+                run: "test-run",
+            });
+            const recording = await proof.capture({
+                command: "echo hello && echo world",
+                mode: "terminal",
+                label: "echo",
+            });
+            expect(recording.mode).toBe("terminal");
+            const castContent = await readFile(recording.path.replace(".html", ".cast"), "utf-8");
+            expect(castContent).toContain("hello");
+            expect(castContent).toContain("world");
+        });
+        test("throws if command is missing", async () => {
+            const proof = new Proof({
+                appName: "test-app",
+                proofDir: tempDir,
+                run: "test-run",
+            });
+            expect(proof.capture({ mode: "terminal", label: "fail" })).rejects.toThrow("terminal mode requires command");
+        });
+    });
+    describe("capture (browser mode)", () => {
+        test("throws if testFile is missing", async () => {
+            const proof = new Proof({
+                appName: "test-app",
+                proofDir: tempDir,
+                run: "test-run",
+            });
+            expect(proof.capture({ mode: "browser", label: "fail" })).rejects.toThrow("browser mode requires testFile");
+        });
+    });
+    describe("manifest", () => {
+        test("creates proof.json with entries on capture", async () => {
+            const proof = new Proof({
+                appName: "test-app",
+                proofDir: tempDir,
+                run: "test-run",
+            });
+            await proof.capture({
+                command: `bun test ${join(import.meta.dir, "../test-app/cli/app.test.ts")}`,
+                mode: "terminal",
+                label: "first",
+                description: "First capture",
+            });
+            const today = new Date();
+            const dateStr = `${today.getFullYear()}${String(today.getMonth() + 1).padStart(2, "0")}${String(today.getDate()).padStart(2, "0")}`;
+            const manifestPath = join(tempDir, "test-app", dateStr, "test-run", "proof.json");
+            expect(existsSync(manifestPath)).toBe(true);
+            const manifest = JSON.parse(await readFile(manifestPath, "utf-8"));
+            expect(manifest.version).toBe(1);
+            expect(manifest.appName).toBe("test-app");
+            expect(manifest.run).toBe("test-run");
+            expect(manifest.entries).toHaveLength(1);
+            expect(manifest.entries[0].label).toBe("first");
+            expect(manifest.entries[0].description).toBe("First capture");
+            expect(manifest.entries[0].mode).toBe("terminal");
+            expect(manifest.entries[0].command).toContain("bun test");
+        });
+        test("appends entries on subsequent captures", async () => {
+            const proof = new Proof({
+                appName: "test-app",
+                proofDir: tempDir,
+                run: "test-run",
+            });
+            const testCmd = `bun test ${join(import.meta.dir, "../test-app/cli/app.test.ts")}`;
+            await proof.capture({
+                command: testCmd,
+                mode: "terminal",
+                label: "first",
+            });
+            await proof.capture({
+                command: testCmd,
+                mode: "terminal",
+                label: "second",
+            });
+            const today = new Date();
+            const dateStr = `${today.getFullYear()}${String(today.getMonth() + 1).padStart(2, "0")}${String(today.getDate()).padStart(2, "0")}`;
+            const manifestPath = join(tempDir, "test-app", dateStr, "test-run", "proof.json");
+            const manifest = JSON.parse(await readFile(manifestPath, "utf-8"));
+            expect(manifest.entries).toHaveLength(2);
+            expect(manifest.entries[0].label).toBe("first");
+            expect(manifest.entries[1].label).toBe("second");
+        });
+    });
+    describe("report", () => {
+        test("generates report.md from manifest", async () => {
+            const proof = new Proof({
+                appName: "test-app",
+                proofDir: tempDir,
+                run: "test-run",
+            });
+            await proof.capture({
+                command: `bun test ${join(import.meta.dir, "../test-app/cli/app.test.ts")}`,
+                mode: "terminal",
+                label: "cli-tests",
+                description: "CLI test suite",
+            });
+            const reportPath = await proof.report();
+            expect(reportPath).toEndWith("report.md");
+            expect(existsSync(reportPath)).toBe(true);
+            const report = await readFile(reportPath, "utf-8");
+            expect(report).toContain("# Proof Report");
+            expect(report).toContain("test-app");
+            expect(report).toContain("test-run");
+            expect(report).toContain("CLI test suite");
+            expect(report).toContain("cli-tests");
+            expect(report).toContain("@automaze/proof");
+        });
+        test("generates html report", async () => {
+            const proof = new Proof({
+                appName: "test-app",
+                proofDir: tempDir,
+                run: "test-run",
+            });
+            await proof.capture({
+                command: `bun test ${join(import.meta.dir, "../test-app/cli/app.test.ts")}`,
+                mode: "terminal",
+                label: "cli-tests",
+                description: "CLI test suite",
+            });
+            const reportPath = await proof.report({ format: "html" });
+            expect(reportPath).toEndWith("report.html");
+            expect(existsSync(reportPath)).toBe(true);
+            const html = await readFile(reportPath, "utf-8");
+            expect(html).toContain("<!DOCTYPE html>");
+            expect(html).toContain("Proof Report");
+            expect(html).toContain("test-app");
+            expect(html).toContain("CLI test suite");
+            expect(html).toContain("<iframe");
+        });
+        test("generates archive report with inlined content", async () => {
+            const proof = new Proof({
+                appName: "test-app",
+                proofDir: tempDir,
+                run: "test-run",
+            });
+            await proof.capture({
+                command: "echo hello",
+                mode: "terminal",
+                label: "echo",
+            });
+            const reportPath = await proof.report({ format: "archive" });
+            expect(reportPath).toEndWith("archive.html");
+            expect(existsSync(reportPath)).toBe(true);
+            const html = await readFile(reportPath, "utf-8");
+            expect(html).toContain("<!DOCTYPE html>");
+            expect(html).toContain("srcdoc=");
+        });
+        test("generates multiple formats as array", async () => {
+            const proof = new Proof({
+                appName: "test-app",
+                proofDir: tempDir,
+                run: "test-run",
+            });
+            await proof.capture({
+                command: "echo hello",
+                mode: "terminal",
+                label: "echo",
+            });
+            const paths = await proof.report({ format: ["md", "html"] });
+            expect(paths).toHaveLength(2);
+            expect(paths[0]).toEndWith("report.md");
+            expect(paths[1]).toEndWith("report.html");
+        });
+        test("throws if no captures have been made", async () => {
+            const proof = new Proof({
+                appName: "test-app",
+                proofDir: tempDir,
+                run: "empty-run",
+            });
+            expect(proof.report()).rejects.toThrow("No proof.json found");
+        });
+    });
+});

package/dist/modes/terminal.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import type { CaptureOptions, Recording } from "../types";
+export declare function captureTerminal(options: CaptureOptions, runDir: string, filePrefix: string, command: string, config: {
+    cols?: number;
+    rows?: number;
+}): Promise<Recording>;

package/dist/modes/terminal.js ADDED Viewed

@@ -0,0 +1,287 @@
+import { spawn } from "child_process";
+import { writeFile } from "fs/promises";
+import { join } from "path";
+export async function captureTerminal(options, runDir, filePrefix, command, config) {
+    const label = options.label ?? "terminal";
+    const castPath = join(runDir, `${filePrefix}.cast`);
+    const htmlPath = join(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 = spawn("/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\n`,
+            });
+            resolve();
+        });
+    });
+    const duration = Date.now() - startTime;
+    const realDurationSec = duration / 1000;
+    // Pick default speed so playback lasts at least ~2s
+    const initialSpeed = realDurationSec < 0.2 ? 0.1 :
+        realDurationSec < 0.5 ? 0.25 :
+            realDurationSec < 1 ? 0.5 :
+                realDurationSec < 2 ? 0.5 :
+                    1;
+    // Write asciicast v2 file
+    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("\n") + "\n", "utf-8");
+    // Write self-contained HTML player
+    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>`;
+}

package/dist/modes/visual.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import type { CaptureOptions, Recording } from "../types";
+export declare function captureVisual(options: CaptureOptions & {
+    testFile: string;
+}, runDir: string, filePrefix: string, config: {
+    viewport?: {
+        width: number;
+        height: number;
+    };
+}): Promise<Recording>;
+export declare function getCursorHighlightScript(): string;