@diegopetrucci/pi-annotate-git-diff 0.1.0

package/quiet-glimpse.ts

@@ -0,0 +1,156 @@
+/// <reference path="./glimpseui.d.ts" />
+
+import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { existsSync } from "node:fs";
+import { createInterface } from "node:readline";
+import type { GlimpseOpenOptions } from "glimpseui";
+
+interface NativeHostInfo {
+	path: string;
+	extraArgs?: string[];
+	buildHint?: string;
+}
+
+interface GlimpseProtocolMessage {
+	type?: string;
+	data?: unknown;
+	screen?: unknown;
+	screens?: unknown;
+	appearance?: unknown;
+	cursor?: unknown;
+	cursorTip?: unknown;
+}
+
+export interface QuietGlimpseWindow {
+	on(event: "message", listener: (data: unknown) => void): this;
+	on(event: "closed", listener: () => void): this;
+	on(event: "error", listener: (error: Error) => void): this;
+	removeListener(event: "message", listener: (data: unknown) => void): this;
+	removeListener(event: "closed", listener: () => void): this;
+	removeListener(event: "error", listener: (error: Error) => void): this;
+	send(js: string): void;
+	close(): void;
+}
+
+class QuietGlimpseWindowImpl extends EventEmitter implements QuietGlimpseWindow {
+	#proc: ChildProcessWithoutNullStreams;
+	#closed = false;
+	#pendingHTML: string | null;
+	#stderr = "";
+
+	constructor(proc: ChildProcessWithoutNullStreams, initialHTML: string) {
+		super();
+		this.#proc = proc;
+		this.#pendingHTML = initialHTML;
+
+		proc.stdin.on("error", () => {});
+		proc.stderr.on("data", (chunk) => {
+			this.#stderr += chunk.toString();
+		});
+
+		const rl = createInterface({ input: proc.stdout, crlfDelay: Infinity });
+		rl.on("line", (line) => {
+			let message: GlimpseProtocolMessage;
+			try {
+				message = JSON.parse(line) as GlimpseProtocolMessage;
+			} catch {
+				this.emit("error", new Error(`Malformed glimpse protocol line: ${line}`));
+				return;
+			}
+
+			switch (message.type) {
+				case "ready":
+					if (this.#pendingHTML != null) {
+						this.setHTML(this.#pendingHTML);
+						this.#pendingHTML = null;
+					}
+					break;
+				case "message":
+					this.emit("message", message.data);
+					break;
+				case "closed":
+					this.#markClosed();
+					break;
+				default:
+					break;
+			}
+		});
+
+		proc.on("error", (error) => this.emit("error", error));
+		proc.on("exit", (code, signal) => {
+			const stderr = this.#stderr.trim();
+			const failed = signal != null || (code != null && code !== 0);
+			if (!this.#closed && failed) {
+				const message = stderr || `Glimpse process exited abnormally (code: ${code}, signal: ${signal}).`;
+				this.emit("error", new Error(message));
+			}
+			this.#markClosed();
+		});
+	}
+
+	send(js: string): void {
+		this.#write({ type: "eval", js });
+	}
+
+	close(): void {
+		this.#write({ type: "close" });
+	}
+
+	#markClosed(): void {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.emit("closed");
+	}
+
+	#write(obj: Record<string, unknown>): void {
+		if (this.#closed) return;
+		this.#proc.stdin.write(`${JSON.stringify(obj)}\n`);
+	}
+
+	setHTML(html: string): void {
+		this.#write({ type: "html", html: Buffer.from(html).toString("base64") });
+	}
+}
+
+async function getNativeHostInfo(): Promise<NativeHostInfo> {
+	const glimpseModule = (await import("glimpseui")) as unknown as { getNativeHostInfo: () => NativeHostInfo };
+	return glimpseModule.getNativeHostInfo();
+}
+
+export async function openQuietGlimpse(html: string, options: GlimpseOpenOptions = {}): Promise<QuietGlimpseWindow> {
+	const host = await getNativeHostInfo();
+	if (!existsSync(host.path)) {
+		const hint = host.buildHint ? ` ${host.buildHint}` : "";
+		throw new Error(`Glimpse host not found at '${host.path}'.${hint}`);
+	}
+	const args: string[] = [];
+
+	if (options.width != null) args.push("--width", String(options.width));
+	if (options.height != null) args.push("--height", String(options.height));
+	if (options.title != null) args.push("--title", options.title);
+	if (options.frameless) args.push("--frameless");
+	if (options.floating) args.push("--floating");
+	if (options.transparent) args.push("--transparent");
+	if (options.clickThrough) args.push("--click-through");
+	if (options.hidden) args.push("--hidden");
+	if (options.autoClose) args.push("--auto-close");
+	if (options.x != null) args.push(`--x=${options.x}`);
+	if (options.y != null) args.push(`--y=${options.y}`);
+	if (options.cursorOffset?.x != null) args.push(`--cursor-offset-x=${options.cursorOffset.x}`);
+	if (options.cursorOffset?.y != null) args.push(`--cursor-offset-y=${options.cursorOffset.y}`);
+	if (options.cursorAnchor != null) args.push("--cursor-anchor", options.cursorAnchor);
+	if (options.followMode != null) args.push("--follow-mode", options.followMode);
+	if (options.followCursor) args.push("--follow-cursor");
+
+	const proc = spawn(host.path, [...(host.extraArgs ?? []), ...args], {
+		stdio: ["pipe", "pipe", "pipe"],
+		windowsHide: process.platform === "win32",
+		env: {
+			...process.env,
+			OS_ACTIVITY_MODE: process.env.OS_ACTIVITY_MODE ?? "disable",
+		},
+	});
+
+	return new QuietGlimpseWindowImpl(proc, html);
+}

package/types.ts

@@ -0,0 +1,202 @@
+export type ReviewScope = "branch" | "commits" | "all";
+
+export type ChangeStatus = "modified" | "added" | "deleted" | "renamed";
+
+export type ReviewFileKind = "text" | "binary" | "image";
+
+export type ReviewCommitKind = "commit" | "working-tree";
+
+export interface ReviewFileComparison {
+	status: ChangeStatus;
+	oldPath: string | null;
+	newPath: string | null;
+	displayPath: string;
+	hasOriginal: boolean;
+	hasModified: boolean;
+}
+
+export interface ReviewFile {
+	id: string;
+	path: string;
+	worktreeStatus: ChangeStatus | null;
+	hasWorkingTreeFile: boolean;
+	/** True when the file is touched by the current branch diff (merge-base/base ref vs HEAD). */
+	inGitDiff: boolean;
+	/** Diff comparison to render for the file in the current scope.
+	 *  - branch scope: merge-base/base ref vs HEAD
+	 *  - commits scope: commit vs commit^ (populated when loaded via request-commit) */
+	gitDiff: ReviewFileComparison | null;
+	kind: ReviewFileKind;
+	mimeType: string | null;
+}
+
+export interface ReviewCommitInfo {
+	sha: string;
+	shortSha: string;
+	subject: string;
+	authorName: string;
+	authorDate: string;
+	kind: ReviewCommitKind;
+}
+
+export interface ReviewFileContents {
+	originalContent: string;
+	modifiedContent: string;
+	kind: ReviewFileKind;
+	mimeType: string | null;
+	originalExists: boolean;
+	modifiedExists: boolean;
+	originalPreviewUrl: string | null;
+	modifiedPreviewUrl: string | null;
+}
+
+export type CommentSide = "original" | "modified" | "file";
+
+export interface DiffReviewComment {
+	id: string;
+	fileId: string;
+	scope: ReviewScope;
+	/** Commit SHA when scope === "commits". */
+	commitSha?: string | null;
+	/** Short commit identifier to render in the prompt (e.g. first 7 chars of SHA). */
+	commitShort?: string | null;
+	commitKind?: ReviewCommitKind | null;
+	side: CommentSide;
+	startLine: number | null;
+	endLine: number | null;
+	body: string;
+}
+
+export interface ReviewSubmitPayload {
+	type: "submit";
+	overallComment: string;
+	comments: DiffReviewComment[];
+}
+
+export interface ReviewCancelPayload {
+	type: "cancel";
+}
+
+export interface ReviewRequestFilePayload {
+	type: "request-file";
+	requestId: string;
+	fileId: string;
+	scope: ReviewScope;
+	commitSha?: string | null;
+}
+
+export interface ReviewRequestCommitPayload {
+	type: "request-commit";
+	requestId: string;
+	sha: string;
+}
+
+export interface ReviewRequestReviewDataPayload {
+	type: "request-review-data";
+	requestId: string;
+}
+
+export interface ReviewClipboardReadPayload {
+	type: "clipboard-read";
+	requestId: string;
+}
+
+export interface ReviewClipboardWritePayload {
+	type: "clipboard-write";
+	text: string;
+}
+
+export type ReviewWindowMessage =
+	| ReviewSubmitPayload
+	| ReviewCancelPayload
+	| ReviewRequestFilePayload
+	| ReviewRequestCommitPayload
+	| ReviewRequestReviewDataPayload
+	| ReviewClipboardReadPayload
+	| ReviewClipboardWritePayload;
+
+export interface ReviewFileDataMessage {
+	type: "file-data";
+	requestId: string;
+	fileId: string;
+	scope: ReviewScope;
+	commitSha?: string | null;
+	originalContent: string;
+	modifiedContent: string;
+	kind: ReviewFileKind;
+	mimeType: string | null;
+	originalExists: boolean;
+	modifiedExists: boolean;
+	originalPreviewUrl: string | null;
+	modifiedPreviewUrl: string | null;
+}
+
+export interface ReviewFileErrorMessage {
+	type: "file-error";
+	requestId: string;
+	fileId: string;
+	scope: ReviewScope;
+	commitSha?: string | null;
+	message: string;
+}
+
+export interface ReviewCommitDataMessage {
+	type: "commit-data";
+	requestId: string;
+	sha: string;
+	files: ReviewFile[];
+}
+
+export interface ReviewCommitErrorMessage {
+	type: "commit-error";
+	requestId: string;
+	sha: string;
+	message: string;
+}
+
+export interface ReviewReviewDataMessage {
+	type: "review-data";
+	requestId: string;
+	files: ReviewFile[];
+	commits: ReviewCommitInfo[];
+	branchBaseRef: string | null;
+	branchMergeBaseSha: string | null;
+	repositoryHasHead: boolean;
+}
+
+export interface ReviewReviewDataErrorMessage {
+	type: "review-data-error";
+	requestId: string;
+	message: string;
+}
+
+export interface ReviewClipboardDataMessage {
+	type: "clipboard-data";
+	requestId: string;
+	text: string;
+	message?: string;
+}
+
+export interface ReviewWorkingTreeChangedMessage {
+	type: "working-tree-changed";
+	changedAt: number;
+}
+
+export type ReviewHostMessage =
+	| ReviewFileDataMessage
+	| ReviewFileErrorMessage
+	| ReviewCommitDataMessage
+	| ReviewCommitErrorMessage
+	| ReviewReviewDataMessage
+	| ReviewReviewDataErrorMessage
+	| ReviewClipboardDataMessage
+	| ReviewWorkingTreeChangedMessage;
+
+export interface ReviewWindowData {
+	repoRoot: string;
+	files: ReviewFile[];
+	commits: ReviewCommitInfo[];
+	branchBaseRef: string | null;
+	branchMergeBaseSha: string | null;
+	repositoryHasHead: boolean;
+}

package/ui.ts

@@ -0,0 +1,71 @@
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { fileURLToPath } from "node:url";
+import type { ReviewWindowData } from "./types.js";
+
+const require = createRequire(import.meta.url);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const webDir = join(__dirname, "web");
+
+function escapeForInlineScript(value: string): string {
+	return value.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+}
+
+function escapeInlineScriptSource(value: string): string {
+	return value.replace(/<\/(script)/gi, "<\\/$1");
+}
+
+interface ReviewUiAssets {
+	tailwindBrowserJs: string;
+	monacoLoaderJs: string;
+	monacoVsBaseUrl: string;
+	bootstrapError: string | null;
+}
+
+function safeReadResolvedAsset(specifier: string): string {
+	return readFileSync(require.resolve(specifier), "utf8");
+}
+
+function resolveReviewUiAssets(): ReviewUiAssets {
+	try {
+		const tailwindBrowserJs = safeReadResolvedAsset("@tailwindcss/browser");
+		const monacoLoaderPath = join(dirname(require.resolve("monaco-editor/package.json")), "min", "vs", "loader.js");
+		const monacoLoaderJs = readFileSync(monacoLoaderPath, "utf8");
+		const monacoVsBaseUrl = pathToFileURL(dirname(monacoLoaderPath)).href;
+		return {
+			tailwindBrowserJs,
+			monacoLoaderJs,
+			monacoVsBaseUrl,
+			bootstrapError: null,
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			tailwindBrowserJs: "",
+			monacoLoaderJs: "",
+			monacoVsBaseUrl: "",
+			bootstrapError: `Unable to load packaged review UI assets: ${message}`,
+		};
+	}
+}
+
+export function buildReviewHtml(data: ReviewWindowData): string {
+	const templateHtml = readFileSync(join(webDir, "index.html"), "utf8");
+	const appJs = escapeInlineScriptSource(readFileSync(join(webDir, "app.js"), "utf8"));
+	const assets = resolveReviewUiAssets();
+	const payload = escapeForInlineScript(JSON.stringify(data));
+	const assetConfig = escapeForInlineScript(
+		JSON.stringify({
+			monacoVsBaseUrl: assets.monacoVsBaseUrl,
+			bootstrapError: assets.bootstrapError,
+		}),
+	);
+	return templateHtml
+		.replace('"__INLINE_DATA__"', payload)
+		.replace("__INLINE_ASSET_CONFIG__", assetConfig)
+		.replace("__INLINE_TAILWIND_JS__", escapeInlineScriptSource(assets.tailwindBrowserJs))
+		.replace("__INLINE_MONACO_LOADER_JS__", escapeInlineScriptSource(assets.monacoLoaderJs))
+		.replace("__INLINE_JS__", appJs);
+}

package/watch.ts

@@ -0,0 +1,104 @@
+import { type FSWatcher, watch } from "node:fs";
+
+export interface RepoChangeWatcher {
+	dispose(): void;
+}
+
+interface RepoChangeWatcherOptions {
+	debounceMs?: number;
+	onError?: (error: Error) => void;
+}
+
+const DEFAULT_DEBOUNCE_MS = 2000;
+
+const ignoredPathSegments = new Set([
+	".cache",
+	".git",
+	".hg",
+	".next",
+	".nuxt",
+	".svn",
+	".turbo",
+	"build",
+	"coverage",
+	"dist",
+	"node_modules",
+	"out",
+	"target",
+	"tmp",
+]);
+
+const ignoredFileNames = new Set([".DS_Store"]);
+
+function normalizeWatchPath(path: string): string {
+	return path.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+
+export function isIgnoredWatchPath(path: string | Buffer | null | undefined): boolean {
+	if (path == null) return false;
+	const normalized = normalizeWatchPath(path.toString());
+	if (normalized.length === 0) return false;
+
+	const segments = normalized.split("/").filter((segment) => segment.length > 0);
+	if (segments.some((segment) => ignoredPathSegments.has(segment))) return true;
+
+	const fileName = segments.at(-1) ?? normalized;
+	if (ignoredFileNames.has(fileName)) return true;
+	if (fileName.endsWith("~") || fileName.endsWith(".swp") || fileName.endsWith(".tmp")) return true;
+
+	return false;
+}
+
+export function createRepoChangeWatcher(
+	repoRoot: string,
+	onChange: () => void,
+	options: RepoChangeWatcherOptions = {},
+): RepoChangeWatcher {
+	const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+	let disposed = false;
+	let timer: ReturnType<typeof setTimeout> | null = null;
+	let watcher: FSWatcher | null = null;
+
+	const clearPending = (): void => {
+		if (timer == null) return;
+		clearTimeout(timer);
+		timer = null;
+	};
+
+	const scheduleChange = (path: string | Buffer | null): void => {
+		if (disposed || isIgnoredWatchPath(path)) return;
+		clearPending();
+		timer = setTimeout(() => {
+			timer = null;
+			if (!disposed) onChange();
+		}, debounceMs);
+	};
+
+	try {
+		watcher = watch(repoRoot, { recursive: true }, (_eventType, fileName) => {
+			scheduleChange(fileName);
+		});
+		watcher.on("error", (error) => {
+			if (!disposed) options.onError?.(error);
+		});
+	} catch (error) {
+		options.onError?.(error instanceof Error ? error : new Error(String(error)));
+	}
+
+	return {
+		dispose() {
+			disposed = true;
+			clearPending();
+			try {
+				watcher?.close();
+			} catch {
+				// Ignore watcher shutdown races.
+			}
+			watcher = null;
+		},
+	};
+}
+
+export const __testing = {
+	isIgnoredWatchPath,
+};