repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by bugabinga

demo: add diff-review browser recording

81b0a7582a5bffffe91e28d9a026cd00a0c7eec0

Oliver Jan Krylow <oliver@bugabinga.net> ·

unsigned

Browse filesCompare with HEAD

Changed files (9)

drivers/diff_review_browser.py

Added
new file mode 100644
1 +title = "Diff Review browser"
3 +readme_id = "diff-review"
4 +readme_items = [
5 + ("Pi bridge", "diff_review_terminal.gif"),
6 + ("Browser UI", "diff_review_browser.gif"),
7 +]
9 +extensions = [
10 + "diff-review",
13 +targets = [
14 + "diff-review",
17 +cols = 100
18 +rows = 28
19 +cwd = "."
20 +browser_script = "extensions/diff-review/scripts/demo-browser.ts"
21 +steps = []

drivers/diff_review_terminal.py

Added
new file mode 100644
1 +title = "Diff Review terminal"
3 +readme_id = "diff-review"
4 +readme_items = [
5 + ("Pi bridge", "diff_review_terminal.gif"),
6 + ("Browser UI", "diff_review_browser.gif"),
7 +]
9 +extensions = [
10 + "diff-review",
13 +targets = [
14 + "diff-review",
17 +cols = 100
18 +rows = 28
19 +cwd = "."
20 +env = {
21 + "PI_DIFF_REVIEW_NO_OPEN": "1",
24 +steps = [
25 + ("wait", 1500),
26 + ("command", "/diff-review --base HEAD~1", 8000),
27 + ("wait", 5000),

extensions/diff-review/README.md

Modified
1 1 # diff-review
3 +<!-- demo:diff-review:start -->
5 +| **Pi bridge** | **Browser UI** |
6 +| --------------------------------------------- | --------------------------------------------- |
7 +| ![Pi bridge](assets/diff_review_terminal.gif) | ![Browser UI](assets/diff_review_browser.gif) |
9 +<!-- demo:diff-review:end -->
3 11 Browser UI for reviewing git diffs and sending findings back to Pi.
5 13 ## Install / load

extensions/diff-review/__tests__/core.test.ts

Modified
7 7 import { parsePatchFiles } from "@pierre/diffs";
8 8 import { parseArgs } from "../args.js";
9 9 import { collectDiff } from "../git.js";
10 +import { openBrowser } from "../open-browser.js";
11 12 const execFileAsync = promisify(execFile);
12 13 const tempDirs: string[] = [];
41 + it("does not spawn browser openers during tests", async () => {
42 + await expect(openBrowser("http://127.0.0.1:1/")).resolves.toEqual({
43 + ok: false,
44 + error: "Browser opener disabled",
45 + });
46 + });
40 48 it("preserves staged rename metadata when collecting per-file diffs", async () => {
41 49 const repo = await tempRepo();
42 50 await writeFile(join(repo, "old.txt"), "one\n");

extensions/diff-review/assets/diff_review_browser.gif

Added
new file mode 100644

Current version contains binary or non-UTF-8 data.

extensions/diff-review/assets/diff_review_terminal.gif

Added
new file mode 100644

Current version contains binary or non-UTF-8 data.

extensions/diff-review/open-browser.ts

Modified
3 3 import { spawn } from "node:child_process";
5 5 export async function openBrowser(
6 6 url: string,
7 7 ): Promise<{ ok: boolean; command?: string; error?: string }> {
8 + if (process.env.NODE_ENV === "test" || process.env.PI_DIFF_REVIEW_NO_OPEN)
9 + return { ok: false, error: "Browser opener disabled" };
8 11 const candidates = openerCandidates(url);
9 12 for (const candidate of candidates) {
10 13 const result = await trySpawn(candidate.command, candidate.args);

extensions/diff-review/scripts/demo-browser.ts

Added
new file mode 100644
1 +import { type ChildProcess, execFile, spawn } from "node:child_process";
2 +import { existsSync } from "node:fs";
3 +import { mkdir, mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
4 +import { tmpdir } from "node:os";
5 +import { dirname, join, resolve } from "node:path";
6 +import { fileURLToPath } from "node:url";
7 +import { promisify } from "node:util";
8 +import { parseArgs } from "../args.js";
9 +import { collectDiff } from "../git.js";
10 +import { startReviewServer } from "../server.js";
12 +const execFileAsync = promisify(execFile);
13 +const EXT_DIR = dirname(dirname(fileURLToPath(import.meta.url)));
14 +const ROOT = dirname(dirname(EXT_DIR));
15 +const WIDTH = 1400;
16 +const HEIGHT = 900;
17 +const FPS = 8;
18 +const FRAME_DELAY_MS = 100;
19 +const CHROME_COMMANDS = [
20 + "google-chrome-stable",
21 + "google-chrome",
22 + "chromium",
23 + "chromium-browser",
24 +];
26 +async function main() {
27 + const out = outputPath();
28 + const chrome = process.env.CHROME ?? (await findCommand(CHROME_COMMANDS));
29 + if (!chrome)
30 + throw new Error("Chrome/Chromium not found; set CHROME=/path/to/chrome");
31 + if (!(await findCommand(["ffmpeg"]))) throw new Error("ffmpeg not found");
33 + await execFileAsync("bun", ["run", "build"], {
34 + cwd: EXT_DIR,
35 + maxBuffer: 20 * 1024 * 1024,
36 + });
38 + const repo = await mkdtemp(join(tmpdir(), "diff-review-demo-repo-"));
39 + const profile = await mkdtemp(join(tmpdir(), "diff-review-demo-chrome-"));
40 + const frames = await mkdtemp(join(tmpdir(), "diff-review-demo-frames-"));
41 + let browser: ChildProcess | undefined;
42 + let server: Awaited<ReturnType<typeof startReviewServer>> | undefined;
44 + try {
45 + await prepareRepo(repo);
46 + server = await startReviewServer({
47 + diff: await collectDiff(repo, parseArgs("")),
48 + state: { round: 0, findings: [], rounds: [] },
49 + round: 1,
50 + timeoutMs: 60_000,
51 + });
53 + const debugPort = 12_000 + Math.floor(Math.random() * 1000);
54 + browser = launchChrome(chrome, profile, debugPort, server.url);
55 + const client = await connectCdp(
56 + (await waitForTab(debugPort)).webSocketDebuggerUrl,
57 + );
58 + try {
59 + await client.call("Runtime.enable");
60 + await client.call("Page.enable");
61 + await waitForUi(client);
62 + await recordFrames(client, frames);
63 + } finally {
64 + client.close();
65 + }
66 + } finally {
67 + server?.close("demo");
68 + browser?.kill("SIGTERM");
69 + await Promise.all([
70 + rm(repo, { recursive: true, force: true }),
71 + rm(profile, { recursive: true, force: true }),
72 + ]);
73 + }
75 + await encodeGif(frames, out);
76 + const count = (await readdir(frames)).filter((name) =>
77 + name.endsWith(".png"),
78 + ).length;
79 + await rm(frames, { recursive: true, force: true });
80 + console.log(`OK browser demo ${out} (${count} frames)`);
83 +function outputPath() {
84 + const idx = process.argv.indexOf("--out");
85 + if (idx >= 0 && process.argv[idx + 1]) return resolve(process.argv[idx + 1]);
86 + return join(ROOT, ".demo", "diff_review_browser.gif");
89 +async function prepareRepo(repo: string) {
90 + await git(repo, ["init", "-q"]);
91 + await git(repo, ["config", "user.email", "demo@example.invalid"]);
92 + await git(repo, ["config", "user.name", "Demo"]);
93 + await mkdir(join(repo, "src"));
94 + await mkdir(join(repo, "test"));
95 + await writeFile(
96 + join(repo, "src/report.ts"),
97 + `export function total(items: number[]) {\n\treturn items.reduce((sum, n) => sum + n, 0);\n}\n\nexport function label(name: string) {\n\treturn name.trim();\n}\n`,
98 + );
99 + await writeFile(
100 + join(repo, "test/report.test.ts"),
101 + `import { total } from '../src/report';\n\nconsole.log(total([1, 2]));\n`,
102 + );
103 + await git(repo, ["add", "."]);
104 + await git(repo, ["commit", "-qm", "init"]);
105 + await writeFile(
106 + join(repo, "src/report.ts"),
107 + `export function total(items: number[]) {\n\treturn items.reduce((sum, n) => sum - n, 0);\n}\n\nexport function label(name: string) {\n\treturn name.trim().toUpperCase();\n}\n`,
108 + );
109 + await writeFile(
110 + join(repo, "test/report.test.ts"),
111 + `import { total } from '../src/report';\n\nconsole.log(total([1, 2, 3]));\n`,
112 + );
115 +async function git(cwd: string, args: string[]) {
116 + await execFileAsync("git", args, { cwd, maxBuffer: 20 * 1024 * 1024 });
119 +function launchChrome(
120 + chrome: string,
121 + profile: string,
122 + debugPort: number,
123 + url: string,
124 +) {
125 + return spawn(
126 + chrome,
128 + "--headless=new",
129 + "--disable-gpu",
130 + "--no-sandbox",
131 + "--disable-dev-shm-usage",
132 + `--remote-debugging-port=${debugPort}`,
133 + `--user-data-dir=${profile}`,
134 + `--window-size=${WIDTH},${HEIGHT}`,
135 + url,
136 + ],
137 + { stdio: "ignore" },
138 + );
141 +async function recordFrames(client: CdpClient, frames: string) {
142 + let frame = 0;
143 + const snap = async (count: number) => {
144 + for (let i = 0; i < count; i++) {
145 + const result = await client.call("Page.captureScreenshot", {
146 + format: "png",
147 + fromSurface: true,
148 + });
149 + const data = result.result?.data;
150 + if (typeof data !== "string") throw new Error("screenshot failed");
151 + await writeFile(
152 + join(frames, `${String(frame++).padStart(4, "0")}.png`),
153 + Buffer.from(data, "base64"),
154 + );
155 + await sleep(FRAME_DELAY_MS);
157 + };
159 + await snap(8);
160 + await client.eval(`
161 + document.querySelector('#theme-mode').value = 'dark';
162 + document.querySelector('#theme-mode').dispatchEvent(new Event('change', { bubbles: true }));
163 + `);
164 + await snap(8);
165 + await client.eval(`
166 + document.querySelector('#search').value = 'total';
167 + document.querySelector('#search').dispatchEvent(new Event('input', { bubbles: true }));
168 + `);
169 + await sleep(300);
170 + await snap(10);
171 + await client.eval(`
172 + document.querySelector('#search').dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
173 + `);
174 + await sleep(300);
175 + await snap(8);
176 + await client.eval(`
177 + const root = document.querySelector('diffs-container')?.shadowRoot;
178 + const line = root?.querySelector('[data-additions] [data-line]');
179 + const rect = line?.getBoundingClientRect();
180 + line?.dispatchEvent(new MouseEvent('click', {
181 + bubbles: true,
182 + composed: true,
183 + clientX: (rect?.left ?? 300) + 24,
184 + clientY: (rect?.top ?? 300) + 10,
185 + }));
186 + `);
187 + await sleep(500);
188 + await snap(8);
189 + await client.eval(`
190 + document.querySelector('#comment').value = 'Demo finding: validate changed total.';
191 + document.querySelector('#comment').dispatchEvent(new Event('input', { bubbles: true }));
192 + `);
193 + await snap(10);
196 +async function encodeGif(frames: string, out: string) {
197 + const palette = join(frames, "palette.png");
198 + await execFileAsync(
199 + "ffmpeg",
201 + "-y",
202 + "-framerate",
203 + String(FPS),
204 + "-i",
205 + join(frames, "%04d.png"),
206 + "-vf",
207 + "scale=1000:-1:flags=lanczos,palettegen",
208 + palette,
209 + ],
210 + { maxBuffer: 20 * 1024 * 1024 },
211 + );
212 + await execFileAsync(
213 + "ffmpeg",
215 + "-y",
216 + "-framerate",
217 + String(FPS),
218 + "-i",
219 + join(frames, "%04d.png"),
220 + "-i",
221 + palette,
222 + "-lavfi",
223 + "scale=1000:-1:flags=lanczos[x];[x][1:v]paletteuse",
224 + out,
225 + ],
226 + { maxBuffer: 20 * 1024 * 1024 },
227 + );
230 +async function waitForUi(client: CdpClient) {
231 + await sleep(1000);
232 + for (let i = 0; i < 80; i++) {
233 + const ok = await client.eval(`
234 + document.querySelector('diffs-container')?.shadowRoot?.querySelector('[data-additions] [data-line]') !== null
235 + `);
236 + if (ok === true) return;
237 + await sleep(100);
239 + throw new Error("diff-review UI not ready");
242 +async function waitForTab(
243 + port: number,
244 +): Promise<{ webSocketDebuggerUrl: string }> {
245 + for (let i = 0; i < 80; i++) {
246 + const tab = await fetch(`http://127.0.0.1:${port}/json/list`)
247 + .then((res) => res.json() as Promise<Array<Record<string, string>>>)
248 + .catch(() => undefined);
249 + const page = tab?.find(
250 + (item) =>
251 + item.type === "page" &&
252 + item.webSocketDebuggerUrl &&
253 + item.url?.startsWith("http://127.0.0.1"),
254 + );
255 + if (page?.webSocketDebuggerUrl) {
256 + return { webSocketDebuggerUrl: page.webSocketDebuggerUrl };
258 + await sleep(250);
260 + throw new Error("Chrome CDP tab not found");
263 +type CdpResponse = {
264 + result?: {
265 + data?: unknown;
266 + result?: { value?: unknown };
267 + exceptionDetails?: { text?: string };
268 + };
269 + error?: { message?: string };
272 +type CdpClient = {
273 + call(method: string, params?: Record<string, unknown>): Promise<CdpResponse>;
274 + eval(expression: string): Promise<unknown>;
275 + close(): void;
278 +async function connectCdp(url: string): Promise<CdpClient> {
279 + let id = 0;
280 + const ws = new WebSocket(url);
281 + const pending = new Map<number, (value: CdpResponse) => void>();
282 + ws.onmessage = (event) => {
283 + const msg = JSON.parse(String(event.data));
284 + if (typeof msg.id !== "number") return;
285 + const resolve = pending.get(msg.id);
286 + if (!resolve) return;
287 + pending.delete(msg.id);
288 + resolve(msg);
289 + };
290 + await new Promise<void>((resolve, reject) => {
291 + ws.onopen = () => resolve();
292 + ws.onerror = reject;
293 + });
294 + return {
295 + call(method: string, params: Record<string, unknown> = {}) {
296 + return new Promise<CdpResponse>((resolve) => {
297 + const callId = ++id;
298 + pending.set(callId, resolve);
299 + ws.send(JSON.stringify({ id: callId, method, params }));
300 + });
301 + },
302 + async eval(expression: string) {
303 + const response = await this.call("Runtime.evaluate", {
304 + expression,
305 + returnByValue: true,
306 + awaitPromise: true,
307 + });
308 + if (response.error)
309 + throw new Error(response.error.message ?? "CDP error");
310 + if (response.result?.exceptionDetails)
311 + throw new Error(response.result.exceptionDetails.text ?? "eval failed");
312 + return response.result?.result?.value;
313 + },
314 + close() {
315 + ws.close();
316 + },
317 + };
320 +async function findCommand(commands: string[]) {
321 + for (const command of commands) {
322 + const found = await execFileAsync("sh", ["-c", `command -v ${command}`])
323 + .then((result) => result.stdout.trim())
324 + .catch(() => "");
325 + if (found && existsSync(found)) return found;
327 + return undefined;
330 +function sleep(ms: number) {
331 + return new Promise((resolve) => setTimeout(resolve, ms));
334 +main().catch((err) => {
335 + console.error(err instanceof Error ? err.message : String(err));
336 + process.exit(1);
337 +});

scripts/demo.py

Modified
6 6 import argparse
7 7 import importlib.util
8 +import os
8 9 import re
9 10 import shutil
10 11 import subprocess
55 56 steps: list[tuple]
56 57 readme_id: str
57 58 readme_items: list[tuple[str, str]] | None
59 + browser_script: str | None
60 + env: dict[str, str]
60 63 def load_module(name: str) -> ModuleType:
117 120 raise SystemExit(f"readme_items entries must be (caption, gif): {item!r}")
122 + browser_script = getattr(module, "browser_script", None)
123 + if browser_script is not None and not isinstance(browser_script, str):
124 + raise SystemExit("browser_script must be string")
126 + env = getattr(module, "env", {})
127 + if not isinstance(env, dict) or not all(
128 + isinstance(k, str) and isinstance(v, str) for k, v in env.items()
129 + ):
130 + raise SystemExit("env must be dict[str, str]")
119 132 driver = Driver(
120 133 name=name,
121 134 title=title,
127 140 steps=steps,
128 141 readme_id=readme_id,
129 142 readme_items=readme_items,
143 + browser_script=browser_script,
144 + env=env,
131 146 validate_driver(driver)
132 147 return driver
170 185 def validate_driver(driver: Driver) -> None:
186 + if driver.browser_script and not (ROOT / driver.browser_script).exists():
187 + raise SystemExit(f"browser_script missing: {driver.browser_script}")
171 188 for name in driver.extensions:
172 189 if not (EXTENSIONS / name / "index.ts").exists():
173 190 raise SystemExit(f"extension missing index.ts: {name}")
267 284 child = pexpect.spawn(
268 285 pi_command(driver),
269 286 cwd=str(driver.cwd),
287 + env={**os.environ, **driver.env},
270 288 encoding="utf-8",
271 289 timeout=90,
272 290 dimensions=(driver.rows, driver.cols),
294 312 def record(driver: Driver, gif_out: Path | None = None) -> tuple[Path, Path, Path]:
295 - ensure_tools()
296 313 OUT.mkdir(exist_ok=True)
297 314 cast = OUT / f"{driver.name}.cast"
298 315 gif = gif_out or OUT / f"{driver.name}.gif"
299 316 txt = OUT / f"{driver.name}.txt"
300 317 gif.parent.mkdir(parents=True, exist_ok=True)
319 + if driver.browser_script:
320 + subprocess.run(
321 + ["bun", str(ROOT / driver.browser_script), "--out", str(gif)],
322 + cwd=ROOT,
323 + check=True,
325 + cast.write_text("browser demo: no asciinema cast\n")
326 + txt.write_text("browser demo\n")
327 + return cast, gif, txt
329 + ensure_tools()
302 330 cmd = [
303 331 "asciinema",
304 332 "rec",
351 379 def readme_block(driver: Driver) -> str:
352 380 if driver.readme_items:
353 - headers = " | ".join(f"**{caption}**" for caption, _gif in driver.readme_items)
354 - separators = " | ".join("---" for _item in driver.readme_items)
355 - images = " | ".join(f"![{caption}](assets/{gif})" for caption, gif in driver.readme_items)
356 - body = f"| {headers} |\n| {separators} |\n| {images} |"
357 - else:
358 - body = f"![{driver.title}](assets/{driver.name}.gif)"
381 + headers = [f"**{caption}**" for caption, _gif in driver.readme_items]
382 + images = [f"![{caption}](assets/{gif})" for caption, gif in driver.readme_items]
383 + widths = [
384 + max(len(header), len(image), 3) for header, image in zip(headers, images, strict=True)
387 + def row(cells: list[str]) -> str:
388 + padded = [cell.ljust(width) for cell, width in zip(cells, widths, strict=True)]
389 + return f"| {' | '.join(padded)} |"
391 + separators = ["-" * width for width in widths]
392 + body = f"{row(headers)}\n{row(separators)}\n{row(images)}"
393 + return (
394 + f"<!-- demo:{driver.readme_id}:start -->\n\n"
395 + f"{body}\n\n"
396 + f"<!-- demo:{driver.readme_id}:end -->"
398 + body = f"![{driver.title}](assets/{driver.name}.gif)"
359 399 return f"<!-- demo:{driver.readme_id}:start -->\n{body}\n<!-- demo:{driver.readme_id}:end -->"