@diegopetrucci/pi-annotate-git-diff 0.1.0

package/glimpseui.d.ts

@@ -0,0 +1,89 @@
+declare module "glimpseui" {
+	import { EventEmitter } from "node:events";
+
+	export type FollowMode = "snap" | "spring";
+	export type CursorAnchor = "top-left" | "top-right" | "right" | "bottom-right" | "bottom-left" | "left";
+
+	export interface GlimpseOpenOptions {
+		width?: number;
+		height?: number;
+		title?: string;
+		x?: number;
+		y?: number;
+		frameless?: boolean;
+		floating?: boolean;
+		transparent?: boolean;
+		clickThrough?: boolean;
+		followCursor?: boolean;
+		followMode?: FollowMode;
+		cursorAnchor?: CursorAnchor;
+		cursorOffset?: {
+			x?: number;
+			y?: number;
+		};
+		hidden?: boolean;
+		autoClose?: boolean;
+		timeout?: number;
+	}
+
+	export interface GlimpseScreenInfo {
+		width: number;
+		height: number;
+		scaleFactor: number;
+		visibleX?: number;
+		visibleY?: number;
+		visibleWidth?: number;
+		visibleHeight?: number;
+		x?: number;
+		y?: number;
+	}
+
+	export interface GlimpseAppearanceInfo {
+		darkMode: boolean;
+		accentColor: string;
+		reduceMotion: boolean;
+		increaseContrast: boolean;
+	}
+
+	export interface GlimpseCursorInfo {
+		x: number;
+		y: number;
+	}
+
+	export interface GlimpseCursorTip {
+		x: number;
+		y: number;
+	}
+
+	export interface GlimpseInfo {
+		screen: GlimpseScreenInfo;
+		screens: GlimpseScreenInfo[];
+		appearance: GlimpseAppearanceInfo;
+		cursor: GlimpseCursorInfo;
+		cursorTip: GlimpseCursorTip | null;
+	}
+
+	export class GlimpseWindow extends EventEmitter {
+		on(event: "ready", listener: (info: GlimpseInfo) => void): this;
+		on(event: "message", listener: (data: unknown) => void): this;
+		on(event: "info", listener: (info: GlimpseInfo) => void): this;
+		on(event: "closed", listener: () => void): this;
+		on(event: "error", listener: (error: Error) => void): this;
+		once(event: "ready", listener: (info: GlimpseInfo) => void): this;
+		once(event: "message", listener: (data: unknown) => void): this;
+		once(event: "info", listener: (info: GlimpseInfo) => void): this;
+		once(event: "closed", listener: () => void): this;
+		once(event: "error", listener: (error: Error) => void): this;
+		send(js: string): void;
+		setHTML(html: string): void;
+		show(options?: { title?: string }): void;
+		close(): void;
+		loadFile(path: string): void;
+		get info(): GlimpseInfo | null;
+		getInfo(): void;
+		followCursor(enabled: boolean, anchor?: CursorAnchor, mode?: FollowMode): void;
+	}
+
+	export function open(html: string, options?: GlimpseOpenOptions): GlimpseWindow;
+	export function prompt<T = unknown>(html: string, options?: GlimpseOpenOptions): Promise<T | null>;
+}

package/index.ts

@@ -0,0 +1,412 @@
+// Standalone /annotate-git-diff extension.
+// Adapted from @ryan_nookpi/pi-extension-diff-review (MIT), itself inspired by
+// badlogic/pi-diff-review. See ./README.md for attribution details.
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { readSystemClipboard, writeSystemClipboard } from "./clipboard.js";
+import { getCommitFiles, getReviewWindowData, isWorkingTreeCommitSha, loadReviewFileContents } from "./git.js";
+import { composeReviewPrompt } from "./prompt.js";
+import { openQuietGlimpse, type QuietGlimpseWindow } from "./quiet-glimpse.js";
+import type {
+	ReviewCancelPayload,
+	ReviewClipboardReadPayload,
+	ReviewClipboardWritePayload,
+	ReviewFile,
+	ReviewFileContents,
+	ReviewHostMessage,
+	ReviewRequestCommitPayload,
+	ReviewRequestFilePayload,
+	ReviewRequestReviewDataPayload,
+	ReviewSubmitPayload,
+	ReviewWindowMessage,
+} from "./types.js";
+import { buildReviewHtml } from "./ui.js";
+import { createRepoChangeWatcher, type RepoChangeWatcher } from "./watch.js";
+
+function hasMessageType(value: unknown, type: ReviewWindowMessage["type"]): boolean {
+	return typeof value === "object" && value != null && "type" in value && value.type === type;
+}
+
+function isSubmitPayload(value: unknown): value is ReviewSubmitPayload {
+	return hasMessageType(value, "submit");
+}
+
+function isCancelPayload(value: unknown): value is ReviewCancelPayload {
+	return hasMessageType(value, "cancel");
+}
+
+function isRequestFilePayload(value: unknown): value is ReviewRequestFilePayload {
+	return hasMessageType(value, "request-file");
+}
+
+function isRequestCommitPayload(value: unknown): value is ReviewRequestCommitPayload {
+	return hasMessageType(value, "request-commit");
+}
+
+function isRequestReviewDataPayload(value: unknown): value is ReviewRequestReviewDataPayload {
+	return hasMessageType(value, "request-review-data");
+}
+
+function isClipboardReadPayload(value: unknown): value is ReviewClipboardReadPayload {
+	return hasMessageType(value, "clipboard-read");
+}
+
+function isClipboardWritePayload(value: unknown): value is ReviewClipboardWritePayload {
+	return hasMessageType(value, "clipboard-write");
+}
+
+function escapeForInlineScript(value: string): string {
+	return value.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+}
+
+function hasReviewFeedback(payload: ReviewSubmitPayload): boolean {
+	return payload.overallComment.trim().length > 0 || payload.comments.some((comment) => comment.body.trim().length > 0);
+}
+
+function appendReviewPrompt(ctx: ExtensionCommandContext, prompt: string): void {
+	const prefix = ctx.ui.getEditorText().trim().length > 0 ? "\n\n" : "";
+	ctx.ui.pasteToEditor(`${prefix}${prompt}`);
+}
+
+export default function (pi: ExtensionAPI) {
+	let activeWindow: QuietGlimpseWindow | null = null;
+	let activeWatcher: RepoChangeWatcher | null = null;
+	const suppressedWindows = new WeakSet<QuietGlimpseWindow>();
+
+	function stopActiveWatcher(): void {
+		if (activeWatcher == null) return;
+		activeWatcher.dispose();
+		activeWatcher = null;
+	}
+
+	function closeActiveWindow(options: { suppressResults?: boolean } = {}): void {
+		if (activeWindow == null) return;
+		const windowToClose = activeWindow;
+		activeWindow = null;
+		stopActiveWatcher();
+		if (options.suppressResults) {
+			suppressedWindows.add(windowToClose);
+		}
+		try {
+			windowToClose.close();
+		} catch {
+			// Window is already closing; ignore shutdown races.
+		}
+	}
+
+	async function reviewRepository(ctx: ExtensionCommandContext): Promise<void> {
+		if (!ctx.hasUI) {
+			ctx.ui.notify("annotate-git-diff requires interactive mode.", "error");
+			return;
+		}
+
+		if (activeWindow != null) {
+			ctx.ui.notify("A review window is already open.", "warning");
+			return;
+		}
+
+		try {
+			let reviewData = await getReviewWindowData(pi, ctx.cwd);
+			const { repoRoot } = reviewData;
+			if (reviewData.files.length === 0 && reviewData.commits.length === 0) {
+				ctx.ui.notify("No reviewable files found.", "info");
+				return;
+			}
+
+			const html = buildReviewHtml(reviewData);
+			const window = await openQuietGlimpse(html, {
+				width: 1680,
+				height: 1020,
+				title: "annotate-git-diff",
+			});
+			activeWindow = window;
+
+			const fileMap = new Map(reviewData.files.map((file) => [file.id, file]));
+			const commitFileCache = new Map<string, Promise<ReviewFile[]>>();
+			const contentCache = new Map<string, Promise<ReviewFileContents>>();
+
+			const clearRefreshableCaches = (): void => {
+				contentCache.clear();
+				for (const sha of commitFileCache.keys()) {
+					if (isWorkingTreeCommitSha(sha)) {
+						commitFileCache.delete(sha);
+					}
+				}
+			};
+
+			const sendWindowMessage = (message: ReviewHostMessage): void => {
+				if (activeWindow !== window) return;
+				const payload = escapeForInlineScript(JSON.stringify(message));
+				window.send(`window.__reviewReceive(${payload});`);
+			};
+
+			let watcherWarningShown = false;
+			activeWatcher = createRepoChangeWatcher(
+				repoRoot,
+				() => {
+					sendWindowMessage({ type: "working-tree-changed", changedAt: Date.now() });
+				},
+				{
+					onError: (error) => {
+						if (watcherWarningShown || activeWindow !== window) return;
+						watcherWarningShown = true;
+						ctx.ui.notify(`Review change watcher failed: ${error.message}`, "warning");
+					},
+				},
+			);
+
+			const loadCommitFiles = (sha: string): Promise<ReviewFile[]> => {
+				const cached = commitFileCache.get(sha);
+				if (cached != null) return cached;
+				const pending = getCommitFiles(pi, repoRoot, sha);
+				commitFileCache.set(sha, pending);
+				pending
+					.then((commitFiles) => {
+						for (const cf of commitFiles) fileMap.set(cf.id, cf);
+					})
+					.catch(() => {});
+				return pending;
+			};
+
+			const loadContents = (
+				file: ReviewFile,
+				scope: ReviewRequestFilePayload["scope"],
+				commitSha: string | null,
+			): Promise<ReviewFileContents> => {
+				const cacheKey = `${scope}:${commitSha ?? ""}:${file.id}`;
+				const cached = contentCache.get(cacheKey);
+				if (cached != null) return cached;
+
+				const pending = loadReviewFileContents(pi, repoRoot, file, scope, commitSha, reviewData.branchMergeBaseSha);
+				contentCache.set(cacheKey, pending);
+				return pending;
+			};
+
+			const terminalMessagePromise = new Promise<ReviewSubmitPayload | ReviewCancelPayload | null>(
+				(resolve, reject) => {
+					let settled = false;
+					let closeTimer: ReturnType<typeof setTimeout> | null = null;
+
+					const cleanup = (): void => {
+						if (closeTimer != null) {
+							clearTimeout(closeTimer);
+							closeTimer = null;
+						}
+						window.removeListener("message", onMessage);
+						window.removeListener("closed", onClosed);
+						window.removeListener("error", onError);
+						if (activeWindow === window) {
+							activeWindow = null;
+							stopActiveWatcher();
+						}
+					};
+
+					const settle = (value: ReviewSubmitPayload | ReviewCancelPayload | null): void => {
+						if (settled) return;
+						settled = true;
+						cleanup();
+						resolve(value);
+					};
+
+					const handleRequestFile = async (message: ReviewRequestFilePayload): Promise<void> => {
+						const file = fileMap.get(message.fileId);
+						if (file == null) {
+							sendWindowMessage({
+								type: "file-error",
+								requestId: message.requestId,
+								fileId: message.fileId,
+								scope: message.scope,
+								commitSha: message.commitSha ?? null,
+								message: "Unknown file requested.",
+							});
+							return;
+						}
+
+						try {
+							const contents = await loadContents(file, message.scope, message.commitSha ?? null);
+							sendWindowMessage({
+								type: "file-data",
+								requestId: message.requestId,
+								fileId: message.fileId,
+								scope: message.scope,
+								commitSha: message.commitSha ?? null,
+								originalContent: contents.originalContent,
+								modifiedContent: contents.modifiedContent,
+								kind: contents.kind,
+								mimeType: contents.mimeType,
+								originalExists: contents.originalExists,
+								modifiedExists: contents.modifiedExists,
+								originalPreviewUrl: contents.originalPreviewUrl,
+								modifiedPreviewUrl: contents.modifiedPreviewUrl,
+							});
+						} catch (error) {
+							const messageText = error instanceof Error ? error.message : String(error);
+							sendWindowMessage({
+								type: "file-error",
+								requestId: message.requestId,
+								fileId: message.fileId,
+								scope: message.scope,
+								commitSha: message.commitSha ?? null,
+								message: messageText,
+							});
+						}
+					};
+
+					const handleRequestCommit = async (message: ReviewRequestCommitPayload): Promise<void> => {
+						try {
+							const commitFiles = await loadCommitFiles(message.sha);
+							sendWindowMessage({
+								type: "commit-data",
+								requestId: message.requestId,
+								sha: message.sha,
+								files: commitFiles,
+							});
+						} catch (error) {
+							const messageText = error instanceof Error ? error.message : String(error);
+							sendWindowMessage({
+								type: "commit-error",
+								requestId: message.requestId,
+								sha: message.sha,
+								message: messageText,
+							});
+						}
+					};
+
+					const handleRequestReviewData = async (message: ReviewRequestReviewDataPayload): Promise<void> => {
+						try {
+							const nextReviewData = await getReviewWindowData(pi, repoRoot);
+							clearRefreshableCaches();
+							reviewData = nextReviewData;
+							for (const file of reviewData.files) fileMap.set(file.id, file);
+							sendWindowMessage({
+								type: "review-data",
+								requestId: message.requestId,
+								files: reviewData.files,
+								commits: reviewData.commits,
+								branchBaseRef: reviewData.branchBaseRef,
+								branchMergeBaseSha: reviewData.branchMergeBaseSha,
+								repositoryHasHead: reviewData.repositoryHasHead,
+							});
+						} catch (error) {
+							const messageText = error instanceof Error ? error.message : String(error);
+							sendWindowMessage({
+								type: "review-data-error",
+								requestId: message.requestId,
+								message: messageText,
+							});
+						}
+					};
+
+					const handleClipboardRead = (message: ReviewClipboardReadPayload): void => {
+						try {
+							sendWindowMessage({
+								type: "clipboard-data",
+								requestId: message.requestId,
+								text: readSystemClipboard(),
+							});
+						} catch (error) {
+							const messageText = error instanceof Error ? error.message : String(error);
+							sendWindowMessage({
+								type: "clipboard-data",
+								requestId: message.requestId,
+								text: "",
+								message: messageText,
+							});
+						}
+					};
+
+					const handleClipboardWrite = (message: ReviewClipboardWritePayload): void => {
+						try {
+							writeSystemClipboard(message.text);
+						} catch (error) {
+							const messageText = error instanceof Error ? error.message : String(error);
+							ctx.ui.notify(`Failed to copy from review window: ${messageText}`, "warning");
+						}
+					};
+
+					const onMessage = (message: unknown): void => {
+						if (isRequestFilePayload(message)) {
+							void handleRequestFile(message);
+							return;
+						}
+						if (isRequestCommitPayload(message)) {
+							void handleRequestCommit(message);
+							return;
+						}
+						if (isRequestReviewDataPayload(message)) {
+							void handleRequestReviewData(message);
+							return;
+						}
+						if (isClipboardReadPayload(message)) {
+							handleClipboardRead(message);
+							return;
+						}
+						if (isClipboardWritePayload(message)) {
+							handleClipboardWrite(message);
+							return;
+						}
+						if (isSubmitPayload(message) || isCancelPayload(message)) {
+							settle(message);
+						}
+					};
+
+					const onClosed = (): void => {
+						if (settled || closeTimer != null) return;
+						closeTimer = setTimeout(() => {
+							closeTimer = null;
+							settle(null);
+						}, 250);
+					};
+
+					const onError = (error: Error): void => {
+						if (settled) return;
+						settled = true;
+						cleanup();
+						reject(error);
+					};
+
+					window.on("message", onMessage);
+					window.on("closed", onClosed);
+					window.on("error", onError);
+				},
+			);
+
+			void (async () => {
+				try {
+					const message = await terminalMessagePromise;
+					if (suppressedWindows.has(window)) return;
+					if (message == null) return;
+					if (message.type === "cancel") {
+						ctx.ui.notify("Review cancelled.", "info");
+						return;
+					}
+					if (!hasReviewFeedback(message)) return;
+
+					const prompt = composeReviewPrompt([...fileMap.values()], message);
+					appendReviewPrompt(ctx, prompt);
+					ctx.ui.notify("Appended review feedback to the editor.", "info");
+				} catch (error) {
+					if (suppressedWindows.has(window)) return;
+					const message = error instanceof Error ? error.message : String(error);
+					ctx.ui.notify(`Review failed: ${message}`, "error");
+				}
+			})();
+
+			ctx.ui.notify("Opened native review window.", "info");
+		} catch (error) {
+			closeActiveWindow({ suppressResults: true });
+			const message = error instanceof Error ? error.message : String(error);
+			ctx.ui.notify(`Review failed: ${message}`, "error");
+		}
+	}
+
+	pi.registerCommand("annotate-git-diff", {
+		description: "Open a native review window with branch, per-commit, and all-files scopes",
+		handler: async (_args, ctx) => {
+			await reviewRepository(ctx);
+		},
+	});
+
+	pi.on("session_shutdown", async () => {
+		closeActiveWindow({ suppressResults: true });
+	});
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@diegopetrucci/pi-annotate-git-diff",
+  "version": "0.1.0",
+  "description": "A standalone pi extension that adds /annotate-git-diff, a native Glimpse UI for annotating git diffs and sending feedback to the editor.",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "annotate",
+    "git",
+    "diff",
+    "review"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/diegopetrucci/pi-extensions.git",
+    "directory": "extensions/annotate-git-diff"
+  },
+  "files": [
+    "index.ts",
+    "clipboard.ts",
+    "git.ts",
+    "prompt.ts",
+    "quiet-glimpse.ts",
+    "types.ts",
+    "ui.ts",
+    "watch.ts",
+    "web",
+    "glimpseui.d.ts",
+    "README.md",
+    ".pi-fleet-tested-version"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "pi": {
+    "extensions": [
+      "index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "dependencies": {
+    "@tailwindcss/browser": "^4.3.0",
+    "glimpseui": "^0.8.1",
+    "monaco-editor": "0.52.2"
+  },
+  "type": "module"
+}

package/prompt.ts

@@ -0,0 +1,65 @@
+import type { DiffReviewComment, ReviewFile, ReviewSubmitPayload } from "./types.js";
+
+function formatScopeLabel(comment: DiffReviewComment): string {
+	switch (comment.scope) {
+		case "branch":
+			return "branch diff";
+		case "commits":
+			return comment.commitKind === "working-tree"
+				? "working tree changes"
+				: comment.commitShort
+					? `commit ${comment.commitShort}`
+					: "commit";
+		default:
+			return "all files";
+	}
+}
+
+function getCommentFilePath(file: ReviewFile | undefined): string {
+	if (file == null) return "(unknown file)";
+	return file.gitDiff?.displayPath ?? file.path;
+}
+
+function formatLocation(comment: DiffReviewComment, file: ReviewFile | undefined): string {
+	const filePath = getCommentFilePath(file);
+	const scopePrefix = `[${formatScopeLabel(comment)}] `;
+
+	if (comment.side === "file" || comment.startLine == null) {
+		return `${scopePrefix}${filePath}`;
+	}
+
+	const range =
+		comment.endLine != null && comment.endLine !== comment.startLine
+			? `${comment.startLine}-${comment.endLine}`
+			: `${comment.startLine}`;
+
+	if (comment.scope === "all") {
+		return `${scopePrefix}${filePath}:${range}`;
+	}
+
+	const suffix = comment.side === "original" ? " (old)" : " (new)";
+	return `${scopePrefix}${filePath}:${range}${suffix}`;
+}
+
+export function composeReviewPrompt(files: ReviewFile[], payload: ReviewSubmitPayload): string {
+	const fileMap = new Map(files.map((file) => [file.id, file]));
+	const lines: string[] = [];
+
+	lines.push("Please address the following feedback");
+	lines.push("");
+
+	const overallComment = payload.overallComment.trim();
+	if (overallComment.length > 0) {
+		lines.push(overallComment);
+		lines.push("");
+	}
+
+	payload.comments.forEach((comment, index) => {
+		const file = fileMap.get(comment.fileId);
+		lines.push(`${index + 1}. ${formatLocation(comment, file)}`);
+		lines.push(`   ${comment.body.trim()}`);
+		lines.push("");
+	});
+
+	return lines.join("\n").trim();
+}