@gavin-hu/my-pi-agent 0.8.0 → 0.9.0

package/extensions/file-browse/client.ts

@@ -525,7 +525,89 @@ export const CLIENT_JS = `(function () {
 		if (result) window.location.assign("/view/" + encodeSegments(result.path));
 	}
 
+	// Keyboard: a shortcut sheet, the per-page actions the server rendered, and
+	// hunk-to-hunk navigation through a diff.
+	var keysDialog = document.getElementById("keys-dialog");
+	var keysButton = document.getElementById("keys-open");
+	var hunkAnchors = Array.prototype.slice.call(document.querySelectorAll("[data-hunk]"));
+	var progressFill = document.getElementById("progress-fill");
+
+	function toggleKeys(force) {
+		if (!keysDialog) return;
+		var open = force !== undefined ? force : keysDialog.hidden;
+		keysDialog.hidden = !open;
+		if (open) {
+			var close = document.getElementById("keys-close");
+			if (close) close.focus();
+		}
+	}
+
+	function toggleRaw() {
+		var next = document.querySelector(".bf-card__actions .bf-segmented a.bf-segmented__item:not([aria-current])");
+		if (next) window.location.assign(next.getAttribute("href") || next.href);
+	}
+
+	// The hunk whose header is pinned (or last passed), then one step either way.
+	function moveHunk(delta) {
+		if (hunkAnchors.length === 0) return;
+		var current = -1;
+		for (var index = 0; index < hunkAnchors.length; index++) {
+			if (hunkAnchors[index].getBoundingClientRect().top <= 8) current = index;
+		}
+		var next = Math.max(0, Math.min(hunkAnchors.length - 1, current + delta));
+		hunkAnchors[next].scrollIntoView({ block: "start" });
+	}
+
+	// The page's primary scroller: the card body for a file or diff, the main
+	// column otherwise.
+	function primaryScroller() {
+		var candidates = [
+			document.getElementById("main"),
+			document.querySelector(".bf-md"),
+			document.querySelector("pre.bf-code")
+		];
+		var best = null;
+		var bestRange = 0;
+		candidates.forEach(function (node) {
+			if (!node) return;
+			var range = node.scrollHeight - node.clientHeight;
+			if (range > bestRange) { bestRange = range; best = node; }
+		});
+		return bestRange > 0 ? best : null;
+	}
+
+	function updateProgress() {
+		if (!progressFill) return;
+		var scroller = primaryScroller();
+		var doc = document.scrollingElement || document.documentElement;
+		var top = doc ? doc.scrollTop : 0;
+		var height = doc ? doc.scrollHeight : 0;
+		var view = doc ? doc.clientHeight : 0;
+		if (scroller) { top = scroller.scrollTop; height = scroller.scrollHeight; view = scroller.clientHeight; }
+		var max = height - view;
+		var percent = max > 0 ? Math.min(100, Math.max(0, (top / max) * 100)) : 0;
+		progressFill.style.width = percent + "%";
+	}
+
+	if (keysButton) keysButton.addEventListener("click", function () { toggleKeys(); });
+	if (keysDialog) {
+		keysDialog.addEventListener("click", function (event) {
+			if (event.target === keysDialog) toggleKeys(false);
+		});
+		var keysClose = document.getElementById("keys-close");
+		if (keysClose) keysClose.addEventListener("click", function () { toggleKeys(false); });
+	}
+
+	window.addEventListener("scroll", updateProgress, true);
+	window.addEventListener("resize", updateProgress);
+	updateProgress();
+
 	document.addEventListener("keydown", function (event) {
+		if (event.key === "Escape" && keysDialog && !keysDialog.hidden) {
+			event.preventDefault();
+			toggleKeys(false);
+			return;
+		}
 		if (paletteOpen()) {
 			if (event.key === "Escape") {
 				event.preventDefault();
@@ -533,15 +615,34 @@ export const CLIENT_JS = `(function () {
 			}
 			return;
 		}
+		if (keysDialog && !keysDialog.hidden) return;
 		var target = event.target;
 		var editable = target && (target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.isContentEditable);
 		if (editable) return;
-		if (event.key === "/" && !event.metaKey && !event.ctrlKey && !event.altKey) {
+		if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "k") {
 			event.preventDefault();
 			openPalette();
-		} else if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "k") {
+			return;
+		}
+		if (event.metaKey || event.ctrlKey || event.altKey) return;
+		if (event.key === "/") {
 			event.preventDefault();
 			openPalette();
+		} else if (event.key === "?") {
+			event.preventDefault();
+			toggleKeys();
+		} else if (event.key === "u" && wrapButton) {
+			event.preventDefault();
+			wrapButton.click();
+		} else if (event.key === "r" && document.querySelector(".bf-card__actions .bf-segmented")) {
+			event.preventDefault();
+			toggleRaw();
+		} else if (event.key === "n" && hunkAnchors.length > 0) {
+			event.preventDefault();
+			moveHunk(1);
+		} else if (event.key === "p" && hunkAnchors.length > 0) {
+			event.preventDefault();
+			moveHunk(-1);
 		}
 	});
 

package/extensions/file-browse/config.ts

@@ -28,6 +28,12 @@ export interface ServeConfig {
 	markdown: boolean;
 	/** Files collected for the quick-open index before it is truncated. */
 	maxIndexEntries: number;
+	/** Offer the read-only git diff view. */
+	gitDiff: boolean;
+	/** Unified diff context lines. */
+	diffContext: number;
+	/** Diff lines rendered before the view is truncated. */
+	maxDiffLines: number;
 }
 
 export const DEFAULT_CONFIG: ServeConfig = {
@@ -40,6 +46,9 @@ export const DEFAULT_CONFIG: ServeConfig = {
 	thumbnails: true,
 	markdown: true,
 	maxIndexEntries: 20000,
+	gitDiff: true,
+	diffContext: 3,
+	maxDiffLines: 4000,
 };
 
 /** Base of the per-session port range. */
@@ -73,6 +82,9 @@ export function normalizeConfig(
 		thumbnails: bool(raw.thumbnails, base.thumbnails),
 		markdown: bool(raw.markdown, base.markdown),
 		maxIndexEntries: clampInteger(raw.maxIndexEntries, base.maxIndexEntries, 1, 1_000_000),
+		gitDiff: bool(raw.gitDiff, base.gitDiff),
+		diffContext: clampInteger(raw.diffContext, base.diffContext, 0, 100),
+		maxDiffLines: clampInteger(raw.maxDiffLines, base.maxDiffLines, 1, 1_000_000),
 	};
 }
 

package/extensions/file-browse/diff.ts

@@ -0,0 +1,187 @@
+/**
+ * Pure parsing for the git diff view.
+ *
+ * Turns unified-diff text and `git status --porcelain=v1 -z` output into plain
+ * view models. No git, no filesystem, no HTML: `git.ts` runs the commands and
+ * `html.ts` renders the result, so the parser can be tested in isolation.
+ */
+
+/** The three comparison scopes the diff view offers. */
+export type DiffMode = "head" | "staged" | "worktree";
+
+/** Every valid mode, in segmented-control order. */
+export const DIFF_MODES: readonly DiffMode[] = ["head", "staged", "worktree"];
+
+/** Whether an untrusted query value names a mode. */
+export function isDiffMode(value: string | null | undefined): value is DiffMode {
+	return value === "head" || value === "staged" || value === "worktree";
+}
+
+/**
+ * Revision arguments for `git diff` for a mode, placed before `--`.
+ * `head` compares the working tree and index against the commit; `staged`
+ * compares the index against the commit; `worktree` compares the working tree
+ * against the index.
+ */
+export function diffArgs(mode: DiffMode): string[] {
+	if (mode === "staged") return ["--cached"];
+	if (mode === "worktree") return [];
+	return ["HEAD"];
+}
+
+/** A line's role in a unified diff. */
+export type DiffLineKind = "meta" | "hunk" | "add" | "del" | "ctx" | "note";
+
+export interface DiffLine {
+	kind: DiffLineKind;
+	/** Content without the leading marker for add/del/ctx; raw text otherwise. */
+	text: string;
+	/** Old-file line number, when the line exists on that side. */
+	oldNo?: number;
+	/** New-file line number, when the line exists on that side. */
+	newNo?: number;
+}
+
+export interface ParsedDiff {
+	lines: DiffLine[];
+	/** True when `maxLines` cut the diff short. */
+	truncated: boolean;
+	/** True for a binary diff (`Binary files … differ` / `GIT binary patch`). */
+	binary: boolean;
+}
+
+const HUNK_HEADER = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
+
+/** A line git emits for a binary change; there is no text diff to show. */
+const BINARY_LINE = /^(?:Binary files .* differ|GIT binary patch)$/;
+
+/**
+ * Parse unified-diff text into lines tagged by role and line number.
+ *
+ * `---` / `+++` are treated as file metadata only before the first hunk, so a
+ * removed line whose content itself begins with `--` still reads as a deletion.
+ * A trailing newline is not a line; `maxLines` bounds the result and sets
+ * `truncated`.
+ */
+export function parseUnifiedDiff(text: string, maxLines: number): ParsedDiff {
+	const raw = text.split("\n");
+	if (raw.length > 0 && raw[raw.length - 1] === "") raw.pop();
+	const truncated = raw.length > maxLines;
+	const lines: DiffLine[] = [];
+	let binary = false;
+	let inHunk = false;
+	let oldNo = 0;
+	let newNo = 0;
+
+	for (let line of truncated ? raw.slice(0, maxLines) : raw) {
+		if (line.endsWith("\r")) line = line.slice(0, -1);
+
+		const hunk = HUNK_HEADER.exec(line);
+		if (hunk) {
+			oldNo = Number(hunk[1]);
+			newNo = Number(hunk[2]);
+			inHunk = true;
+			lines.push({ kind: "hunk", text: line });
+			continue;
+		}
+
+		if (inHunk) {
+			if (line.startsWith("\\ ")) {
+				lines.push({ kind: "note", text: line });
+			} else if (line.startsWith("+")) {
+				lines.push({ kind: "add", text: line.slice(1), newNo: newNo++ });
+			} else if (line.startsWith("-")) {
+				lines.push({ kind: "del", text: line.slice(1), oldNo: oldNo++ });
+			} else if (line.startsWith(" ") || line === "") {
+				lines.push({
+					kind: "ctx",
+					text: line.startsWith(" ") ? line.slice(1) : "",
+					oldNo: oldNo++,
+					newNo: newNo++,
+				});
+			} else {
+				// A new file block (`diff --git …`) closes the hunk.
+				inHunk = false;
+				if (BINARY_LINE.test(line)) binary = true;
+				lines.push({ kind: line.startsWith("\\ ") ? "note" : "meta", text: line });
+			}
+			continue;
+		}
+
+		if (BINARY_LINE.test(line)) binary = true;
+		lines.push({ kind: line.startsWith("\\ ") ? "note" : "meta", text: line });
+	}
+
+	return { lines, truncated, binary };
+}
+
+/** One changed path from `git status --porcelain=v1 -z`. */
+export interface ChangedFile {
+	/** Root-relative, posix-style path. */
+	rel: string;
+	/** Original path for a rename or copy. */
+	origRel?: string;
+	/** Index (staged) status character; `" "` when unchanged there. */
+	index: string;
+	/** Worktree (unstaged) status character; `" "` when unchanged there. */
+	worktree: string;
+	/** Both status characters are `?`, so the path is untracked. */
+	untracked: boolean;
+}
+
+/**
+ * Parse `git status --porcelain=v1 -z`.
+ *
+ * NUL-delimited records survive spaces and newlines in a path. A rename or copy
+ * (`R`/`C` in either column) carries the new path first and the original path as
+ * the next field; the destination is the entry's `rel`.
+ */
+export function parseStatusZ(stdout: string): ChangedFile[] {
+	const tokens = stdout.split("\0");
+	const files: ChangedFile[] = [];
+	for (let index = 0; index < tokens.length; index++) {
+		const entry = tokens[index];
+		if (entry.length < 3 || entry[2] !== " ") continue;
+		const x = entry[0];
+		const y = entry[1];
+		const untracked = x === "?" && y === "?";
+		const file: ChangedFile = { rel: entry.slice(3), index: x, worktree: y, untracked };
+		if (x === "R" || x === "C" || y === "R" || y === "C") {
+			const original = tokens[++index] ?? "";
+			if (original) file.origRel = original;
+		}
+		files.push(file);
+	}
+	return files;
+}
+
+/** The single status letter shown in the change list. */
+export function statusLetter(file: ChangedFile): string {
+	if (file.untracked) return "?";
+	return file.index !== " " ? file.index : file.worktree;
+}
+
+/** Whether a changed path belongs in a mode's list. */
+export function inMode(file: ChangedFile, mode: DiffMode): boolean {
+	if (mode === "staged") return !file.untracked && file.index !== " " && file.index !== "?";
+	if (mode === "worktree") return file.untracked || (file.worktree !== " " && file.worktree !== "?");
+	return true;
+}
+
+/**
+ * The ancestor directories of every changed path, root-relative. A directory in
+ * this set contains a change, which lets a listing or tree mark it without
+ * walking its subtree.
+ */
+export function changeDirs(files: readonly ChangedFile[]): Set<string> {
+	const dirs = new Set<string>();
+	for (const file of files) {
+		const parts = file.rel.split("/");
+		let prefix = "";
+		for (let index = 0; index < parts.length - 1; index++) {
+			prefix = prefix ? `${prefix}/${parts[index]}` : parts[index];
+			dirs.add(prefix);
+		}
+	}
+	return dirs;
+}

package/extensions/file-browse/git.ts

@@ -8,7 +8,17 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { createExecRunner, currentBranch, repoRoot, revParse, type RunGit } from "../../lib/git/index.ts";
+import { createExecRunner, currentBranch, hasCommits, repoRoot, revParse, type RunGit } from "../../lib/git/index.ts";
+import {
+	diffArgs,
+	inMode,
+	parseStatusZ,
+	parseUnifiedDiff,
+	type ChangedFile,
+	type DiffLine,
+	type DiffMode,
+} from "./diff.ts";
+import { readFileView } from "./files.ts";
 
 export interface GitStatus {
 	/** Checked-out branch, when HEAD is attached. */
@@ -72,3 +82,168 @@ export function createGitStatus(
 		return pending;
 	};
 }
+
+/** One comparison scope's change list. */
+export interface DiffList {
+	mode: DiffMode;
+	files: ChangedFile[];
+	/** `git diff --stat` output for the scope, or an empty string. */
+	stat: string;
+	/** Added lines in the scope. */
+	insertions: number;
+	/** Removed lines in the scope. */
+	deletions: number;
+}
+
+/** A single file's diff for a scope. */
+export interface DiffFileView {
+	mode: DiffMode;
+	rel: string;
+	lines: DiffLine[];
+	/** True for a binary or unreadable change; `lines` is then empty. */
+	binary: boolean;
+	truncated: boolean;
+}
+
+/**
+ * Change list and per-file diffs for the browse pages. Like
+ * {@link createGitStatus}, it never throws: a non-repository, a failed git
+ * call, or a timeout yields `undefined`, and the page omits the diff UI.
+ */
+export interface GitDiffProvider {
+	list(mode: DiffMode): Promise<DiffList | undefined>;
+	file(rel: string, mode: DiffMode): Promise<DiffFileView | undefined>;
+}
+
+export interface GitDiffOptions {
+	/** How long the status list is reused, in ms (default 2000). */
+	ttlMs?: number;
+	/** Unified context lines (default 3). */
+	context?: number;
+	/** Rendered diff lines before truncation (default 4000). */
+	maxLines?: number;
+	/** Per-call git timeout in ms (default 4000). */
+	timeoutMs?: number;
+	/** Max bytes read for an untracked file's all-add diff (default 1 MiB). */
+	maxFileBytes?: number;
+	/** Max lines read for an untracked file's all-add diff (default 5000). */
+	maxTextLines?: number;
+	/** Wall-clock seam; defaults to the real clock. */
+	now?: () => number;
+}
+
+interface RepoState {
+	files: ChangedFile[];
+	hasCommits: boolean;
+}
+
+const INSERTIONS = /(\d+) insertions?\(\+\)/;
+const DELETIONS = /(\d+) deletions?\(-\)/;
+
+/** A count from a `--shortstat` line, or `0` when the line does not carry it. */
+function shortstatCount(text: string, pattern: RegExp): number {
+	const match = pattern.exec(text);
+	return match ? Number(match[1]) : 0;
+}
+
+/** Build a read-only diff provider for `root`, with a TTL-cached status list. */
+export function createGitDiff(
+	pi: Pick<ExtensionAPI, "exec">,
+	root: string,
+	options: GitDiffOptions = {},
+): GitDiffProvider {
+	const exec = createExecRunner(pi);
+	const run: RunGit = (args, opts) => exec(args, { timeoutMs: options.timeoutMs ?? 4000, ...opts });
+	const ttlMs = options.ttlMs ?? 2000;
+	const context = Math.max(0, options.context ?? 3);
+	const maxLines = Math.max(1, options.maxLines ?? 4000);
+	const maxFileBytes = options.maxFileBytes ?? 1024 * 1024;
+	const maxTextLines = options.maxTextLines ?? 5000;
+	const now = options.now ?? (() => Date.now());
+
+	let cached: RepoState | undefined;
+	let checkedAt = 0;
+	let pending: Promise<RepoState | undefined> | undefined;
+
+	async function read(): Promise<RepoState | undefined> {
+		if (!(await repoRoot(run, root))) return undefined;
+		const status = await run(["status", "--porcelain=v1", "-z", "--untracked-files=all"], { cwd: root });
+		if (status.code !== 0) return undefined;
+		return { files: parseStatusZ(status.stdout), hasCommits: await hasCommits(run, root) };
+	}
+
+	/** The cached repository state, or `undefined` outside a repository. */
+	function state(): Promise<RepoState | undefined> {
+		if (pending) return pending;
+		const t = now();
+		if (checkedAt !== 0 && t - checkedAt < ttlMs) return Promise.resolve(cached);
+		checkedAt = t;
+		pending = read()
+			.catch(() => undefined)
+			.then((next) => {
+				cached = next;
+				return next;
+			})
+			.finally(() => {
+				pending = undefined;
+			});
+		return pending;
+	}
+
+	/** `head` needs a commit; before the first one, compare the index instead. */
+	const effectiveMode = (mode: DiffMode, has: boolean): DiffMode => (mode === "head" && !has ? "staged" : mode);
+
+	/** An untracked file as an all-add diff, read through the shared file view. */
+	async function untracked(rel: string, mode: DiffMode): Promise<DiffFileView> {
+		try {
+			const view = await readFileView(root, rel, maxFileBytes, maxTextLines);
+			if (view.kind === "text" || view.kind === "markdown") {
+				// Drop the empty element a trailing newline produces, so the added
+				// lines match the count git shows for the same file.
+				const last = view.lines.length - 1;
+				const source = last >= 0 && view.lines[last] === "" ? view.lines.slice(0, last) : view.lines;
+				return {
+					mode,
+					rel,
+					lines: source.map((text, index) => ({ kind: "add" as const, text, newNo: index + 1 })),
+					binary: false,
+					truncated: view.truncated,
+				};
+			}
+			return { mode, rel, lines: [], binary: true, truncated: false };
+		} catch {
+			return { mode, rel, lines: [], binary: false, truncated: false };
+		}
+	}
+
+	return {
+		async list(mode) {
+			const current = await state();
+			if (!current) return undefined;
+			const args = diffArgs(effectiveMode(mode, current.hasCommits));
+			const [stat, shortstat] = await Promise.all([
+				run(["diff", "--no-color", "--stat", ...args, "--"], { cwd: root }),
+				run(["diff", "--no-color", "--shortstat", ...args, "--"], { cwd: root }),
+			]);
+			const summary = shortstat.code === 0 ? shortstat.stdout : "";
+			return {
+				mode,
+				files: current.files.filter((file) => inMode(file, mode)),
+				stat: stat.code === 0 ? stat.stdout.trim() : "",
+				insertions: shortstatCount(summary, INSERTIONS),
+				deletions: shortstatCount(summary, DELETIONS),
+			};
+		},
+		async file(rel, mode) {
+			const current = await state();
+			if (!current) return undefined;
+			if (current.files.some((file) => file.rel === rel && file.untracked)) return untracked(rel, mode);
+			const result = await run(
+				["diff", "--no-color", `-U${context}`, "-M", ...diffArgs(effectiveMode(mode, current.hasCommits)), "--", rel],
+				{ cwd: root, env: { GIT_LITERAL_PATHSPECS: "1" } },
+			);
+			if (result.code !== 0) return undefined;
+			return { mode, rel, ...parseUnifiedDiff(result.stdout, maxLines) };
+		},
+	};
+}