@bugabinga/pi-ext-diff-review 0.1.0

package/format.ts

@@ -0,0 +1,74 @@
+import type { CollectedDiff, Finding, ReviewRoundEntry } from "./types.js";
+
+export function formatReviewMarkdown(round: ReviewRoundEntry): string {
+	const lines: string[] = [`# Diff Review Round ${round.round}`, ""];
+	if (round.diffSummary.skippedFiles.length > 0) lines.push("## Skipped Files", ...round.diffSummary.skippedFiles.map((file) => `- ${file}`), "");
+	if (round.findings.length === 0) {
+		lines.push("No findings recorded.", "", "Use this review result to decide whether any follow-up is needed. Do not edit files yet.");
+		return lines.join("\n");
+	}
+
+	lines.push("## Findings");
+	for (const [index, finding] of round.findings.entries()) lines.push(formatFinding(finding, index + 1));
+	if (round.notes?.trim()) lines.push("", "## Notes", round.notes.trim());
+	lines.push("", "Use this review to propose and discuss a fix plan first. Do not edit files yet.");
+	return lines.join("\n");
+}
+
+export function makeReviewRound(round: number, diff: CollectedDiff, findings: Finding[], notes?: string): ReviewRoundEntry {
+	return {
+		version: 1,
+		kind: "round",
+		round,
+		source: diff.source,
+		findings,
+		...(notes?.trim() && { notes: notes.trim() }),
+		diffSummary: {
+			filesChanged: diff.files.length,
+			additions: diff.additions,
+			deletions: diff.deletions,
+			skippedFiles: diff.skippedFiles,
+		},
+		createdAt: new Date().toISOString(),
+	};
+}
+
+function formatFinding(finding: Finding, index: number): string {
+	const range = finding.startLine === finding.endLine ? `${finding.startLine}` : `${finding.startLine}-${finding.endLine}`;
+	const location = `${finding.file}:${range}`;
+	const lineSemantics =
+		finding.side === "additions"
+			? "file line number on new/additions side (current file)"
+			: "file line number on old/deletions side (preimage; may not exist in working tree)";
+	const context = [finding.anchor.before, finding.anchor.selected, finding.anchor.after].filter(Boolean).join("\n");
+	const lines = [
+		`### Finding ${index}: [${finding.severity}][${finding.category}] ${location} ${finding.side}`,
+		"",
+		`- Location: \`${location}\``,
+		`- Side: \`${finding.side}\``,
+		`- Line semantics: ${lineSemantics}`,
+		`- Comment: ${finding.comment}`,
+	];
+	if (finding.notes?.trim()) lines.push(`- Notes: ${finding.notes.trim()}`);
+	lines.push("", "Selected code:", fencedText(finding.anchor.selected));
+	if (context.trim()) lines.push("", "Nearby context:", fencedText(context));
+	return lines.join("\n");
+}
+
+function fencedText(text: string): string {
+	const fence = longestBacktickRun(text) >= 3 ? "`".repeat(longestBacktickRun(text) + 1) : "```";
+	return `${fence}text\n${text}\n${fence}`;
+}
+
+function longestBacktickRun(text: string): number {
+	let longest = 0;
+	let current = 0;
+	for (const char of text) {
+		if (char === "`") current++;
+		else {
+			longest = Math.max(longest, current);
+			current = 0;
+		}
+	}
+	return Math.max(longest, current);
+}

package/git.ts

@@ -0,0 +1,299 @@
+import { execFile, spawn } from "node:child_process";
+import { join, relative } from "node:path";
+import { promisify } from "node:util";
+import { MAX_DIFF_BYTES, MAX_FILE_DIFF_BYTES } from "./constants.js";
+import { sourceFromArgs, type DiffReviewArgs } from "./args.js";
+import type { CollectedDiff, DiffFileSummary, DiffFileStatus, DiffIndex, IndexedFileDiff } from "./types.js";
+
+const execFileAsync = promisify(execFile);
+const DEFAULT_GIT_BUFFER_BYTES = 10 * 1024 * 1024;
+const STDERR_BUFFER_BYTES = 64 * 1024;
+const HUNK_HEADER = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
+const DIFF_GIT_HEADER = /^diff --git a\/(.*) b\/(.*)$/;
+
+export async function collectDiff(cwd: string, args: DiffReviewArgs): Promise<CollectedDiff> {
+	const repoRoot = (await git(cwd, ["rev-parse", "--show-toplevel"])).trim();
+	const repoArgs = rebasePathArgs(args, repoRoot, cwd);
+	const source = sourceFromArgs(repoArgs);
+	const pieces = await collectRenderableDiff(repoRoot, repoArgs);
+	const parsed = parseUnifiedDiff(pieces.diffText);
+	const skippedFiles = [...parsed.skippedFiles, ...pieces.skippedFiles];
+	if (!pieces.diffText.trim() && skippedFiles.length > 0) throw new Error(`No renderable diff; skipped oversized/binary files: ${skippedFiles.join(", ")}`);
+	return { repoRoot, source, diffText: pieces.diffText, ...parsed, skippedFiles };
+}
+
+function rebasePathArgs(args: DiffReviewArgs, repoRoot: string, cwd: string): DiffReviewArgs {
+	if (!args.files) return args;
+	const prefix = relative(repoRoot, cwd).replace(/\\/g, "/");
+	return { ...args, files: args.files.map((file) => prefix ? join(prefix, file).replace(/\\/g, "/") : file) };
+}
+
+async function collectRenderableDiff(cwd: string, args: DiffReviewArgs) {
+	const files = await changedFiles(cwd, args);
+	const chunks: string[] = [];
+	const skippedFiles: string[] = [];
+	let totalBytes = 0;
+
+	for (const file of files) {
+		try {
+			const chunk = await gitDiff(cwd, diffArgs(args, [file]), MAX_FILE_DIFF_BYTES);
+			const bytes = Buffer.byteLength(chunk, "utf8");
+			if (totalBytes + bytes > MAX_DIFF_BYTES) {
+				skippedFiles.push(`${file} (review diff limit)`);
+				continue;
+			}
+			totalBytes += bytes;
+			chunks.push(chunk);
+		} catch (err) {
+			if (err instanceof DiffTooLargeError) skippedFiles.push(`${file} (${Math.round(MAX_FILE_DIFF_BYTES / 1024 / 1024)} MiB per-file limit)`);
+			else throw err;
+		}
+	}
+
+	return { diffText: chunks.join(""), skippedFiles };
+}
+
+async function changedFiles(cwd: string, args: DiffReviewArgs) {
+	const output = await git(cwd, nameOnlyArgs(args), { maxBuffer: DEFAULT_GIT_BUFFER_BYTES });
+	return output.split("\0").filter(Boolean);
+}
+
+function diffArgs(args: DiffReviewArgs, files = args.files): string[] {
+	const out = baseDiffArgs(args);
+	out.push("--");
+	if (files) out.push(...files);
+	return out;
+}
+
+function nameOnlyArgs(args: DiffReviewArgs): string[] {
+	const out = [...baseDiffArgs(args), "--name-only", "-z", "--"];
+	if (args.files) out.push(...args.files);
+	return out;
+}
+
+function baseDiffArgs(args: DiffReviewArgs): string[] {
+	const out = ["diff", "--no-ext-diff", "--find-renames", "--src-prefix=a/", "--dst-prefix=b/", "--unified=3"];
+	if (args.staged) out.push("--cached");
+	if (args.base) out.push(`${args.base}...HEAD`);
+	return out;
+}
+
+async function git(cwd: string, args: string[], options: { maxBuffer?: number } = {}): Promise<string> {
+	try {
+		const { stdout } = await execFileAsync("git", args, { cwd, maxBuffer: options.maxBuffer ?? DEFAULT_GIT_BUFFER_BYTES });
+		return String(stdout);
+	} catch (err) {
+		throw new Error(gitError(err));
+	}
+}
+
+function gitDiff(cwd: string, args: string[], maxBytes: number): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+		const stdout: Buffer[] = [];
+		const stderr: Buffer[] = [];
+		let stdoutBytes = 0;
+		let stderrBytes = 0;
+		let settled = false;
+
+		const resolveOnce = (text: string) => {
+			if (settled) return;
+			settled = true;
+			resolve(text);
+		};
+		const rejectOnce = (error: Error) => {
+			if (settled) return;
+			settled = true;
+			reject(error);
+		};
+
+		child.stdout.on("data", (chunk: Buffer) => {
+			stdoutBytes += chunk.length;
+			if (stdoutBytes > maxBytes) {
+				child.kill("SIGTERM");
+				rejectOnce(new DiffTooLargeError(maxBytes));
+				return;
+			}
+			stdout.push(chunk);
+		});
+		child.stderr.on("data", (chunk: Buffer) => {
+			if (stderrBytes >= STDERR_BUFFER_BYTES) return;
+			const remaining = STDERR_BUFFER_BYTES - stderrBytes;
+			stderr.push(chunk.subarray(0, remaining));
+			stderrBytes += Math.min(chunk.length, remaining);
+		});
+		child.once("error", rejectOnce);
+		child.once("close", (code) => {
+			if (settled) return;
+			if (code === 0) resolveOnce(Buffer.concat(stdout).toString("utf8"));
+			else rejectOnce(new Error(Buffer.concat(stderr).toString("utf8").trim() || `git diff exited with code ${code ?? "unknown"}`));
+		});
+	});
+}
+
+function gitError(err: unknown) {
+	const e = err as { stderr?: string | Buffer; message?: string };
+	return String(e.stderr ?? "").trim() || e.message || "git failed";
+}
+
+function parseUnifiedDiff(diffText: string): Omit<CollectedDiff, "repoRoot" | "source" | "diffText"> {
+	const state: DiffParserState = {
+		diffIndex: new Map(),
+		files: [],
+		skippedFiles: [],
+		oldLine: 0,
+		newLine: 0,
+		inHunk: false,
+	};
+
+	for (const line of diffText.split(/\r?\n/)) parseDiffLine(state, line);
+	finishFile(state);
+
+	return {
+		files: state.files,
+		diffIndex: state.diffIndex,
+		skippedFiles: state.skippedFiles,
+		additions: sumChanges(state.files, "additions"),
+		deletions: sumChanges(state.files, "deletions"),
+	};
+}
+
+type DiffParserState = {
+	current?: IndexedFileDiff;
+	diffIndex: DiffIndex;
+	files: DiffFileSummary[];
+	skippedFiles: string[];
+	oldLine: number;
+	newLine: number;
+	inHunk: boolean;
+};
+
+function parseDiffLine(state: DiffParserState, line: string) {
+	if (line.startsWith("diff --git ")) return startFile(state, line);
+	if (!state.current) return;
+	if (updateFileMetadata(state.current, line)) return;
+	if (updateHeaderPath(state.current, line)) return;
+	if (startHunk(state, line)) return;
+	if (!state.inHunk) return;
+	applyHunkLine(state, line);
+}
+
+function startFile(state: DiffParserState, line: string) {
+	finishFile(state);
+	const { oldPath, newPath } = parseDiffGitLine(line);
+	state.current = { file: newPath, prevFile: oldPath, status: "modified", additions: new Map(), deletions: new Map(), oldLines: new Map(), newLines: new Map() };
+	state.oldLine = 0;
+	state.newLine = 0;
+	state.inHunk = false;
+}
+
+function finishFile(state: DiffParserState) {
+	const file = state.current;
+	if (!file) return;
+	if (file.status === "binary") state.skippedFiles.push(file.file);
+	state.diffIndex.set(file.file, file);
+	state.files.push(summary(file));
+	state.current = undefined;
+}
+
+function summary(file: IndexedFileDiff): DiffFileSummary {
+	return {
+		path: file.file,
+		...(file.prevFile && file.prevFile !== file.file && { prevPath: file.prevFile }),
+		status: file.status,
+		additions: file.additions.size,
+		deletions: file.deletions.size,
+	};
+}
+
+function updateFileMetadata(file: IndexedFileDiff, line: string) {
+	const status = statusFromMetadata(line, file.status);
+	if (!status) return false;
+	file.status = status;
+	return true;
+}
+
+function statusFromMetadata(line: string, current: DiffFileStatus): DiffFileStatus | undefined {
+	if (line.startsWith("new file mode ")) return "added";
+	if (line.startsWith("deleted file mode ")) return "deleted";
+	if (line.startsWith("Binary files ")) return "binary";
+	if (line.startsWith("similarity index ") || line.startsWith("rename from ") || line.startsWith("rename to ")) return current === "added" || current === "deleted" ? current : "renamed";
+	return undefined;
+}
+
+function updateHeaderPath(file: IndexedFileDiff, line: string) {
+	if (line.startsWith("--- ")) {
+		const path = parseHeaderPath(line.slice(4));
+		if (path && path !== "/dev/null") file.prevFile = path;
+		return true;
+	}
+	if (line.startsWith("+++ ")) {
+		const path = parseHeaderPath(line.slice(4));
+		if (path && path !== "/dev/null") file.file = path;
+		return true;
+	}
+	return false;
+}
+
+function startHunk(state: DiffParserState, line: string) {
+	const match = HUNK_HEADER.exec(line);
+	if (!match) return false;
+	state.oldLine = Number(match[1]);
+	state.newLine = Number(match[2]);
+	state.inHunk = true;
+	return true;
+}
+
+function applyHunkLine(state: DiffParserState, line: string) {
+	const file = state.current;
+	if (!file || line.startsWith("\\")) return;
+	if (line.startsWith("+")) return addLine(file, state, line);
+	if (line.startsWith("-")) return deleteLine(file, state, line);
+	if (line.startsWith(" ")) return contextLine(state, line);
+}
+
+function addLine(file: IndexedFileDiff, state: DiffParserState, line: string) {
+	const text = line.slice(1);
+	file.additions.set(state.newLine, text);
+	file.newLines.set(state.newLine, text);
+	state.newLine++;
+}
+
+function deleteLine(file: IndexedFileDiff, state: DiffParserState, line: string) {
+	const text = line.slice(1);
+	file.deletions.set(state.oldLine, text);
+	file.oldLines.set(state.oldLine, text);
+	state.oldLine++;
+}
+
+function contextLine(state: DiffParserState, line: string) {
+	if (state.current) {
+		const text = line.slice(1);
+		state.current.oldLines.set(state.oldLine, text);
+		state.current.newLines.set(state.newLine, text);
+	}
+	state.oldLine++;
+	state.newLine++;
+}
+
+function parseDiffGitLine(line: string) {
+	const match = DIFF_GIT_HEADER.exec(line);
+	return { oldPath: match?.[1] ?? "", newPath: match?.[2] ?? match?.[1] ?? "" };
+}
+
+function parseHeaderPath(header: string): string | undefined {
+	const trimmed = header.trim();
+	if (trimmed === "/dev/null") return trimmed;
+	if (trimmed.startsWith("a/") || trimmed.startsWith("b/")) return trimmed.slice(2);
+	return trimmed.split(/\s+/)[0];
+}
+
+function sumChanges(files: DiffFileSummary[], key: "additions" | "deletions") {
+	return files.reduce((sum, file) => sum + file[key], 0);
+}
+
+class DiffTooLargeError extends Error {
+	constructor(readonly maxBytes: number) {
+		super(`diff exceeds ${Math.round(maxBytes / 1024 / 1024)} MiB limit`);
+	}
+}

package/index.ts

@@ -0,0 +1,157 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { CANCEL_COMMAND, REVIEW_COMMAND, STATUS_ID } from "./constants.js";
+import { parseArgs, type DiffReviewArgs } from "./args.js";
+import { ensureBrowserBundle } from "./bundle.js";
+import { collectDiff } from "./git.js";
+import { openBrowser } from "./open-browser.js";
+import { formatReviewMarkdown, makeReviewRound } from "./format.js";
+import { appendLiveReview, appendReviewRound, openFindings, restoreReviewState } from "./session-state.js";
+import { startReviewServer, type ReviewServer } from "./server.js";
+import type { ReviewLiveEntry, ReviewState } from "./types.js";
+
+export default function diffReviewExtension(pi: ExtensionAPI) {
+	let state: ReviewState = { round: 0, findings: [], rounds: [] };
+	let active: ReviewServer | undefined;
+	let restoring: Promise<void> | undefined;
+
+	pi.on("session_start", async (_event, ctx) => {
+		state = restoreReviewState(ctx);
+		const open = openFindings(state).length;
+		if (open > 0 && ctx.hasUI) ctx.ui.setStatus(STATUS_ID, `${open} open review finding${open === 1 ? "" : "s"}`);
+		if (state.live && ctx.hasUI) restoring = restoreLiveReview(ctx, state.live).finally(() => { restoring = undefined; });
+	});
+
+	pi.on("session_shutdown", async () => {
+		active?.close("shutdown");
+		active = undefined;
+		restoring = undefined;
+	});
+
+	pi.registerCommand(REVIEW_COMMAND, {
+		description: "Open browser UI to review current git diff and send findings back to Pi",
+		handler: async (rawArgs, ctx) => {
+			if (!ctx.hasUI) return ctx.ui.notify("/diff-review requires interactive mode", "error");
+			if (restoring) await restoring;
+			state = restoreReviewState(ctx);
+			if (active) {
+				ctx.ui.notify(`diff-review already active. Refresh existing browser tab. URL: ${active.url}`, "info");
+				ctx.ui.setStatus(STATUS_ID, `active ${active.url}`);
+				return;
+			}
+			if (state.live) {
+				restoring = restoreLiveReview(ctx, state.live).finally(() => { restoring = undefined; });
+				await restoring;
+				if (active) {
+					ctx.ui.notify(`diff-review restored. Refresh existing browser tab. URL: ${active.url}`, "info");
+					return;
+				}
+			}
+
+			await ctx.waitForIdle();
+
+			let args: DiffReviewArgs;
+			try {
+				args = parseArgs(rawArgs);
+			} catch (err) {
+				ctx.ui.notify((err as Error).message, "error");
+				return;
+			}
+
+			try {
+				await ensureBrowserBundle((message) => ctx.ui.setStatus(STATUS_ID, message));
+
+				ctx.ui.setStatus(STATUS_ID, "collecting diff");
+				const diff = await collectDiff(ctx.cwd, args);
+				if (!diff.diffText.trim()) {
+					ctx.ui.setStatus(STATUS_ID, undefined);
+					ctx.ui.notify("No diff to review", "info");
+					return;
+				}
+
+				const live = makeLiveEntry(state.round + 1, args);
+				appendLiveReview(ctx, live);
+				state = restoreReviewState(ctx);
+				const server = await launchReviewServer(pi, ctx, live, state, false);
+				active = server;
+				ctx.ui.setStatus(STATUS_ID, `live ${server.url}`);
+				ctx.ui.notify(`Diff review live: ${server.url}`, "info");
+
+				const opened = await openBrowser(server.url);
+				if (!opened.ok) ctx.ui.notify(`Could not open browser automatically. Open manually: ${server.url}`, "warning");
+			} catch (err) {
+				active?.close("command");
+				active = undefined;
+				ctx.ui.setStatus(STATUS_ID, undefined);
+				ctx.ui.notify(`diff-review failed: ${(err as Error).message}`, "error");
+			}
+		},
+	});
+
+	pi.registerCommand(CANCEL_COMMAND, {
+		description: "Cancel active /diff-review browser session",
+		handler: async (_args, ctx) => {
+			if (!active) return ctx.ui.notify("No active diff-review", "info");
+			active.close("command");
+			active = undefined;
+			if (state.live) appendLiveReview(ctx, { ...state.live, status: "closed", reason: "command" });
+			state = restoreReviewState(ctx);
+			ctx.ui.setStatus(STATUS_ID, undefined);
+			ctx.ui.notify("diff-review cancelled", "info");
+		},
+	});
+
+	async function restoreLiveReview(ctx: ExtensionContext, live: ReviewLiveEntry) {
+		if (active) return;
+		try {
+			ctx.ui.setStatus(STATUS_ID, "restoring browser review");
+			await ensureBrowserBundle((message) => ctx.ui.setStatus(STATUS_ID, message));
+			active = await launchReviewServer(pi, ctx, live, state, true);
+			ctx.ui.setStatus(STATUS_ID, `restored ${active.url}`);
+			ctx.ui.notify(`diff-review restored. Refresh existing tab or run /${REVIEW_COMMAND} to reopen.`, "info");
+		} catch (err) {
+			ctx.ui.notify(`diff-review reconnect failed: ${(err as Error).message}`, "warning");
+		}
+	}
+
+	async function launchReviewServer(pi: ExtensionAPI, ctx: ExtensionContext, live: ReviewLiveEntry, currentState: ReviewState, restored: boolean) {
+		const args = live.args;
+		const diff = await collectDiff(ctx.cwd, args);
+		const server = await startReviewServer({
+			diff,
+			state: currentState,
+			round: live.round,
+			token: live.token,
+			refreshDiff: () => collectDiff(ctx.cwd, args),
+			onSubmit: (result, latestDiff) => {
+				const entry = makeReviewRound(live.round, latestDiff, result.findings, result.notes);
+				appendReviewRound(ctx, entry);
+				state = restoreReviewState(ctx);
+				const markdown = formatReviewMarkdown(entry);
+				ctx.ui.notify(`diff review sent to Pi: ${result.findings.length} finding${result.findings.length === 1 ? "" : "s"}`, "info");
+				pi.sendUserMessage([{ type: "text", text: markdown }]);
+			},
+			onHeartbeatLost: () => ctx.ui.notify(restored ? "diff-review browser still disconnected" : "diff-review browser closed", "info"),
+		});
+		server.result.then((result) => {
+			if (active?.id === server.id) active = undefined;
+			ctx.ui.setStatus(STATUS_ID, undefined);
+			if (result.reason !== "shutdown") appendLiveReview(ctx, { ...live, status: "closed", reason: result.reason });
+			ctx.ui.notify(`/diff-review ended (${result.reason})`, result.reason === "timeout" ? "warning" : "info");
+		});
+		return server;
+	}
+}
+
+function makeLiveEntry(round: number, args: DiffReviewArgs): ReviewLiveEntry {
+	return {
+		version: 1,
+		kind: "live",
+		id: randomUUID(),
+		token: randomBytes(32).toString("base64url"),
+		round,
+		args,
+		status: "open",
+		createdAt: new Date().toISOString(),
+	};
+}

package/open-browser.ts

@@ -0,0 +1,39 @@
+import { spawn } from "node:child_process";
+
+export async function openBrowser(url: string): Promise<{ ok: boolean; command?: string; error?: string }> {
+	const candidates = openerCandidates(url);
+	for (const candidate of candidates) {
+		const result = await trySpawn(candidate.command, candidate.args);
+		if (result.ok) return { ok: true, command: candidate.command };
+	}
+	return { ok: false, error: "No browser opener found" };
+}
+
+function openerCandidates(url: string): Array<{ command: string; args: string[] }> {
+	if (process.env.TERMUX_VERSION) return [{ command: "termux-open-url", args: [url] }];
+	if (process.platform === "darwin") return [{ command: "open", args: [url] }];
+	if (process.platform === "win32") return [{ command: "cmd.exe", args: ["/c", "start", "", url] }];
+	return [
+		{ command: "xdg-open", args: [url] },
+		{ command: "wslview", args: [url] },
+		{ command: "gio", args: ["open", url] },
+	];
+}
+
+function trySpawn(command: string, args: string[]): Promise<{ ok: boolean; error?: string }> {
+	return new Promise((resolve) => {
+		const child = spawn(command, args, { detached: true, stdio: "ignore" });
+		let settled = false;
+		const done = (ok: boolean, error?: string) => {
+			if (settled) return;
+			settled = true;
+			resolve({ ok, error });
+		};
+		child.once("error", (err) => done(false, err.message));
+		child.once("spawn", () => {
+			child.unref();
+			done(true);
+		});
+		setTimeout(() => done(false, "timeout"), 1500).unref();
+	});
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@bugabinga/pi-ext-diff-review",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "index.ts",
+  "scripts": {
+    "build": "bun ./scripts/build-browser.ts",
+    "smoke:browser": "bun ./scripts/smoke-browser.ts",
+    "test:browser": "bun ./scripts/browser-regression.ts"
+  },
+  "dependencies": {
+    "@pierre/diffs": "^1.1.22",
+    "@pierre/trees": "^1.0.0-beta.4"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "license": "MIT",
+  "description": "Browser-based git diff review bridge for Pi.",
+  "keywords": [
+    "pi",
+    "pi-extension"
+  ]
+}