@gavin-hu/my-pi-agent 0.13.1 → 0.15.0

package/extensions/rewind/format.ts

@@ -7,8 +7,9 @@
  */
 
 import { sliceByColumn, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { sanitizeLine } from "../../lib/format.ts";
-import { GLYPHS } from "../../lib/tui/glyphs.ts";
+import { sanitizeLine, stripControlChars } from "../../lib/format.ts";
+import { GLYPHS, SEPARATORS } from "../../lib/tui/glyphs.ts";
+import { SELECTION_MARKS, type ReviewEntry } from "./paths.ts";
 import type { RestoreSummary } from "./types.ts";
 
 /** Longest prompt summary shown before truncation. */
@@ -141,3 +142,220 @@ export function formatRestoreText(summary: RestoreSummary): string {
 	const safety = summary.safety ? ` A safety snapshot #${summary.safety} captures the pre-restore state.` : "";
 	return `${line}${safety}`;
 }
+
+/** The trailing `+n −n`, `bin`, or `0` for one review row. */
+export function formatReviewEntryCounts(entry: Pick<ReviewEntry, "added" | "removed">): string {
+	if (entry.added === null && entry.removed === null) return "bin";
+	const parts: string[] = [];
+	if (entry.added !== null && entry.added > 0) parts.push(`+${entry.added}`);
+	if (entry.removed !== null && entry.removed > 0) parts.push(`−${entry.removed}`);
+	return parts.length > 0 ? parts.join(" ") : "0";
+}
+
+/** The review list's summary: `4 files · +128 −19`, plus `N selected` and `bin` when needed. */
+export function formatReviewSummary(entries: readonly ReviewEntry[], selected = 0): string {
+	const files = `${entries.length} file${entries.length === 1 ? "" : "s"}`;
+	let added = 0;
+	let removed = 0;
+	let binary = false;
+	for (const entry of entries) {
+		if (entry.added === null && entry.removed === null) binary = true;
+		else {
+			added += entry.added ?? 0;
+			removed += entry.removed ?? 0;
+		}
+	}
+	const parts = [files];
+	if (added > 0 || removed > 0) parts.push(`+${added} −${removed}`);
+	if (binary) parts.push("bin");
+	if (selected > 0) parts.push(`${selected} selected`);
+	return parts.join(SEPARATORS.item);
+}
+
+/** The sanitized snapshot-side name of a rename, or undefined for any other row. */
+function renameFrom(entry: ReviewEntry): string | undefined {
+	return entry.change === "renamed" ? sanitizeLine(entry.from) : undefined;
+}
+
+/** How a review change kind reads in a detail line or a confirmation. */
+function changeDescription(entry: ReviewEntry): string {
+	if (entry.change === "added") return "created after the snapshot; reverting deletes it";
+	if (entry.change === "deleted") return "deleted since the snapshot; reverting brings it back";
+	const from = renameFrom(entry);
+	return from === undefined
+		? "modified since the snapshot; reverting rewrites it"
+		: `renamed from ${from}; reverting moves it back`;
+}
+
+/**
+ * What the focused review row will do, in words.
+ *
+ * The keys are the hint row's job: a detail line long enough to repeat them is
+ * clipped mid-sentence at the widths the screen runs at.
+ */
+export function formatReviewDetail(entry: ReviewEntry): string {
+	return `${SELECTION_MARKS[entry.change]} — ${changeDescription(entry)}${SEPARATORS.item}${formatReviewEntryCounts(entry)}.`;
+}
+
+/** Headless `/review` text for modes without a custom screen. */
+export function formatReviewListText(
+	entries: readonly ReviewEntry[],
+	prompt: string | undefined,
+	committed = false,
+): string {
+	const label = summarizePrompt(prompt) ?? "the last prompt";
+	const rows = entries.map((entry) => {
+		const counts = formatReviewEntryCounts(entry);
+		const from = renameFrom(entry);
+		const name = from === undefined ? sanitizeLine(entry.path) : `${sanitizeLine(entry.path)} (from ${from})`;
+		return `  ${SELECTION_MARKS[entry.change]} ${name}${counts ? `  ${counts}` : ""}`;
+	});
+	const files = `${entries.length} file${entries.length === 1 ? "" : "s"}`;
+	const note = committed ? ["These changes are already committed; reverting rewrites the working tree only."] : [];
+	return [`Reviewing after "${label}" (${files}):`, ...rows, ...note].join("\n");
+}
+
+/** What one review revert did, and what is left to review. */
+export function formatReviewRevertText(summary: RestoreSummary, remaining: number): string {
+	const count = summary.changed + summary.removed;
+	const files = `${count} file${count === 1 ? "" : "s"}`;
+	const safety = summary.safety ? ` Safety snapshot #${summary.safety}.` : "";
+	const left =
+		remaining === 0 ? " No changes remain." : ` ${remaining} file${remaining === 1 ? "" : "s"} still changed.`;
+	return `Reverted ${files}.${safety}${left}`;
+}
+
+/** What a revert does to HEAD and the index, with the committed case named. */
+function headNote(committed: boolean): string {
+	return committed
+		? "These changes are already committed; reverting rewrites the working tree and leaves the commits in place. HEAD and the index are untouched."
+		: "HEAD and the index are untouched.";
+}
+
+/** The confirmation body for reverting one file. */
+export function formatRevertOneBody(entry: ReviewEntry, prompt: string, safety: boolean, committed = false): string {
+	const label = summarizePrompt(prompt) ?? "this prompt";
+	const counts =
+		entry.added === null && entry.removed === null
+			? "Git reports a binary change; the whole file is restored."
+			: `Diff: ${formatReviewEntryCounts(entry)}.`;
+	const from = renameFrom(entry);
+	const target =
+		from === undefined
+			? `Returns ${sanitizeLine(entry.path)} to the snapshot taken before "${label}".`
+			: `Moves ${sanitizeLine(entry.path)} back to ${from} as it was before "${label}".`;
+	return [
+		`${SELECTION_MARKS[entry.change]} — ${changeDescription(entry)}.`,
+		counts,
+		"",
+		target,
+		headNote(committed),
+		safety
+			? "A safety snapshot first makes the revert undoable with /rewind."
+			: "Safety snapshots are off; this cannot be undone.",
+	].join("\n");
+}
+
+/** The confirmation body for reverting every changed path in the review. */
+export function formatRevertAllBody(
+	entries: readonly ReviewEntry[],
+	prompt: string,
+	safety: boolean,
+	committed = false,
+): string {
+	const label = summarizePrompt(prompt) ?? "this prompt";
+	const files = `${entries.length} file${entries.length === 1 ? "" : "s"}`;
+	return [
+		`Restores ${files} to the snapshot taken before "${label}".`,
+		formatReviewSummary(entries),
+		headNote(committed),
+		safety
+			? "A safety snapshot first makes the revert undoable with /rewind."
+			: "Safety snapshots are off; this cannot be undone.",
+	].join("\n");
+}
+
+/** The confirmation body for reverting a chosen subset. */
+export function formatRevertSelectedBody(
+	entries: readonly ReviewEntry[],
+	prompt: string,
+	safety: boolean,
+	committed = false,
+): string {
+	const label = summarizePrompt(prompt) ?? "this prompt";
+	const selected = `${entries.length} selected file${entries.length === 1 ? "" : "s"}`;
+	return [
+		`Restores ${selected} to the snapshot taken before "${label}".`,
+		"Other changed files stay as they are.",
+		formatReviewSummary(entries),
+		headNote(committed),
+		safety
+			? "A safety snapshot first makes the revert undoable with /rewind."
+			: "Safety snapshots are off; this cannot be undone.",
+	].join("\n");
+}
+
+/** The confirmation body for reverting chosen hunks of one file. */
+export function formatHunkRevertBody(
+	entry: ReviewEntry,
+	selected: number,
+	total: number,
+	prompt: string,
+	safety: boolean,
+	committed = false,
+): string {
+	const label = summarizePrompt(prompt) ?? "this prompt";
+	const rest = total - selected;
+	return [
+		`Reverts ${selected} of ${total} hunk${total === 1 ? "" : "s"} in ${sanitizeLine(entry.path)} to the snapshot taken before "${label}".`,
+		rest > 0
+			? `${rest} hunk${rest === 1 ? "" : "s"} in the file stay${rest === 1 ? "s" : ""} as ${rest === 1 ? "it is" : "they are"}.`
+			: "Every hunk in the file is reverted.",
+		headNote(committed),
+		safety
+			? "A safety snapshot first makes the revert undoable with /rewind."
+			: "Safety snapshots are off; this cannot be undone.",
+	].join("\n");
+}
+
+/** What a hunk revert did, and what is left to review. */
+export function formatHunkRevertText(
+	path: string,
+	hunks: number,
+	safety: string | undefined,
+	remaining: number,
+): string {
+	const files = `${hunks} hunk${hunks === 1 ? "" : "s"} in ${sanitizeLine(path)}`;
+	const safetyText = safety ? ` Safety snapshot #${safety}.` : "";
+	const left =
+		remaining === 0 ? " No changes remain." : ` ${remaining} file${remaining === 1 ? "" : "s"} still changed.`;
+	return `Reverted ${files}.${safetyText}${left}`;
+}
+
+/** Lines of one review diff shown at most. */
+export const REVIEW_DIFF_MAX_LINES = 2_000;
+
+/** Characters of one review diff kept before the line cap applies. */
+export const REVIEW_DIFF_MAX_CHARS = 400_000;
+
+/**
+ * A review patch as display lines: sanitized, tab-expanded, and bounded.
+ *
+ * The cap is applied before the pane ever holds the buffer, so a generated or
+ * minified file cannot make the screen allocate its whole diff. A truncated
+ * buffer ends with a note, and an empty patch (a binary change git would not
+ * render) gets a one-line placeholder instead of an empty screen.
+ */
+export function boundDiff(text: string, maxLines = REVIEW_DIFF_MAX_LINES, maxChars = REVIEW_DIFF_MAX_CHARS): string[] {
+	if (text.trim() === "") return ["No textual diff."];
+	const truncatedByChars = text.length > maxChars;
+	const raw = (truncatedByChars ? text.slice(0, maxChars) : text).split(/\r?\n/);
+	if (raw.at(-1) === "") raw.pop();
+	// A diff keeps its indentation, so this uses the multi-line boundary and
+	// expands tabs itself; `sanitizeLine` would collapse both.
+	const lines = raw.map((line) => stripControlChars(line).replaceAll("\t", "    "));
+	if (!truncatedByChars && lines.length <= maxLines) return lines;
+	const kept = lines.slice(0, maxLines);
+	kept.push(truncatedByChars ? "… diff truncated" : `… diff truncated at ${maxLines} lines`);
+	return kept;
+}

package/extensions/rewind/git.ts

@@ -9,8 +9,9 @@
  * (`GIT_INDEX_FILE`) so the user's real index and HEAD are never modified.
  */
 
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import {
 	createExecRunner,
@@ -22,7 +23,7 @@ import {
 	runGitOrThrow as run,
 	type RunGit,
 } from "../../lib/git/index.ts";
-import { parseNameStatus, type ChangedPath } from "./paths.ts";
+import { parseNameStatus, parseNumStat, type ChangedPath, type PathStat } from "./paths.ts";
 
 // Re-export exactly the shared helpers this extension consumes, so rewind code
 // has one git import surface instead of reaching into `lib/git` directly.
@@ -144,7 +145,9 @@ function literalPathspec(path: string): string {
  * The changed paths between two trees, with how each changed.
  *
  * One call replaces the separate added-path and changed-count queries, so the
- * preview, the checklist, and the apply step all read the same list.
+ * preview, the checklist, and the apply step all read the same list. Rename
+ * detection is explicit (`-M`) rather than inherited from `diff.renames`, so a
+ * user's git config cannot change what a selection covers.
  */
 export async function nameStatus(
 	runGit: RunGit,
@@ -153,13 +156,18 @@ export async function nameStatus(
 	to: string,
 	paths?: readonly string[],
 ): Promise<ChangedPath[]> {
-	const args = ["diff", "--no-color", "--name-status", from, to, "--"];
+	const args = ["diff", "--no-color", "-M", "--name-status", from, to, "--"];
 	if (paths) args.push(...paths.map(literalPathspec));
 	const result = await runGit(args, { cwd });
 	return result.code === 0 ? parseNameStatus(result.stdout) : [];
 }
 
-/** `git diff --stat` between two trees, optionally limited to `paths`. */
+/**
+ * `git diff --stat` between two trees, optionally limited to `paths`.
+ *
+ * Rename detection matches `nameStatus`, so the confirm preview names the move
+ * even though the per-file patch below stays a delete plus a create.
+ */
 export async function diffStat(
 	runGit: RunGit,
 	cwd: string,
@@ -167,12 +175,51 @@ export async function diffStat(
 	to: string,
 	paths?: readonly string[],
 ): Promise<string> {
-	const args = ["diff", "--no-color", "--stat", from, to, "--"];
+	const args = ["diff", "--no-color", "-M", "--stat", from, to, "--"];
 	if (paths) args.push(...paths.map(literalPathspec));
 	const result = await runGit(args, { cwd });
 	return result.code === 0 ? result.stdout.trim() : "";
 }
 
+/**
+ * A unified patch between two trees, optionally limited to `paths`.
+ *
+ * `--no-renames` is deliberate: `nameStatus` pairs a rename into one row, while
+ * its patch stays a delete plus a create, which describes exactly the two working
+ * tree operations a revert of that row performs.
+ */
+export async function diffPatch(
+	runGit: RunGit,
+	cwd: string,
+	from: string,
+	to: string,
+	paths?: readonly string[],
+): Promise<string> {
+	const args = ["diff", "--no-color", "--no-ext-diff", "--no-textconv", "--no-renames", "--unified=3", from, to, "--"];
+	if (paths) args.push(...paths.map(literalPathspec));
+	const result = await runGit(args, { cwd });
+	return result.code === 0 ? result.stdout : "";
+}
+
+/**
+ * Per-path added/removed line counts between two trees, with binary as nulls.
+ *
+ * `--no-renames` keeps a rename's removed lines on its source and its added lines
+ * on its destination; `toReviewEntries` joins the two onto the paired entry.
+ */
+export async function diffNumStat(
+	runGit: RunGit,
+	cwd: string,
+	from: string,
+	to: string,
+	paths?: readonly string[],
+): Promise<Map<string, PathStat>> {
+	const args = ["diff", "--no-color", "--numstat", "--no-renames", from, to, "--"];
+	if (paths) args.push(...paths.map(literalPathspec));
+	const result = await runGit(args, { cwd });
+	return result.code === 0 ? parseNumStat(result.stdout) : new Map();
+}
+
 /**
  * Rewrite the given paths in the working tree from `commit`.
  *
@@ -195,6 +242,26 @@ export async function restorePaths(
 	});
 }
 
+/**
+ * Reverse-apply a prepared patch to the working tree.
+ *
+ * `pi.exec` has no stdin, so the patch goes through a private temporary
+ * directory and a path argument. Without `--index` or `--cached`, `git apply`
+ * writes only the working tree, and it verifies every hunk before writing, so a
+ * file edited after its diff was read fails atomically instead of applying stale
+ * context. The caller builds the patch from already-fetched diff output.
+ */
+export async function applyPatchReverse(runGit: RunGit, cwd: string, patch: string): Promise<void> {
+	const dir = mkdtempSync(join(tmpdir(), "pi-rewind-patch-"));
+	try {
+		const file = join(dir, "patch.diff");
+		writeFileSync(file, patch);
+		await run(runGit, ["apply", "--reverse", "--whitespace=nowarn", file], { cwd });
+	} finally {
+		rmSync(dir, { recursive: true, force: true });
+	}
+}
+
 /** Label of an in-progress git operation that a rewind must not clobber, if any. */
 export async function busyGitState(runGit: RunGit, cwd: string): Promise<string | undefined> {
 	const markers: Array<[string, string]> = [

package/extensions/rewind/hunk-picker.ts

@@ -0,0 +1,114 @@
+/**
+ * The hunk checklist `/review` opens from a modified file's diff.
+ *
+ * One row per textual hunk, all selected by default, so `Enter` twice reproduces
+ * the whole-file revert. The screen owns only the selection: hunks in, chosen
+ * indices out through `onClose`, and the reverse apply stays behind the
+ * confirmation that follows. The frame, the cursor, and the toggle keys come
+ * from {@link ChecklistScreen}.
+ *
+ * Pure UI: no git, no filesystem.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { sanitizeLine } from "../../lib/format.ts";
+import { screenHint, type ViewportRowsSource } from "../../lib/tui/chrome.ts";
+import { clip } from "../../lib/tui/columns.ts";
+import { SEPARATORS } from "../../lib/tui/glyphs.ts";
+import { checkbox, listRow } from "../../lib/tui/rows.ts";
+import { paint } from "../../lib/tui/tokens.ts";
+import { ChecklistScreen } from "./checklist.ts";
+import { formatReviewEntryCounts } from "./format.ts";
+import type { Hunk } from "./patch.ts";
+
+export interface HunkPickerOptions {
+	/** The file the hunks belong to. */
+	path: string;
+	hunks: readonly Hunk[];
+	theme: Theme;
+	/** Called once when the screen closes: chosen hunk indices, or undefined when cancelled. */
+	onClose: (selection?: number[]) => void;
+	requestRender: () => void;
+	viewportRows?: ViewportRowsSource;
+}
+
+/** One rendered row: a hunk and the index the screen returns. */
+interface HunkRow {
+	index: number;
+	hunk: Hunk;
+}
+
+/** The first removed and first added line, for the focused hunk's detail. */
+function previewOf(hunk: Hunk): string[] {
+	const removed = hunk.lines.find((line) => line.startsWith("-"));
+	const added = hunk.lines.find((line) => line.startsWith("+"));
+	return [removed, added].filter((line): line is string => line !== undefined).slice(0, 2);
+}
+
+/** The checklist of a file's hunks. */
+export class HunkPickerComponent extends ChecklistScreen<HunkRow> {
+	private readonly hunkRows: readonly HunkRow[];
+
+	constructor(private readonly view: HunkPickerOptions) {
+		super({
+			title: "Revert hunks",
+			theme: view.theme,
+			requestRender: view.requestRender,
+			viewportRows: view.viewportRows,
+			emptyLabel: "No hunks to select.",
+		});
+		this.hunkRows = view.hunks.map((hunk, index) => ({ index, hunk }));
+	}
+
+	protected rows(): readonly HunkRow[] {
+		return this.hunkRows;
+	}
+
+	protected keyOf(row: HunkRow): string {
+		return String(row.index);
+	}
+
+	protected onEnter(selection: string[]): void {
+		this.view.onClose(selection.map(Number).sort((a, b) => a - b));
+	}
+
+	protected onCancel(): void {
+		this.view.onClose(undefined);
+	}
+
+	protected rowLine(row: HunkRow, width: number, selected: boolean): string {
+		return listRow(this.theme, width, {
+			selected,
+			leading: checkbox(this.theme, this.chosen.has(String(row.index))),
+			label: sanitizeLine(row.hunk.header),
+			labelRole: selected ? "accent" : "label",
+			trailing: formatReviewEntryCounts(row.hunk),
+			trailingRole: "meta",
+		});
+	}
+
+	protected summaryText(): string {
+		const selected = `${this.chosen.size} of ${this.view.hunks.length} hunks selected`;
+		return `${selected}${SEPARATORS.item}${sanitizeLine(this.view.path)}`;
+	}
+
+	/** The focused hunk's first removed and added line. */
+	protected detailLines(width: number): string[] {
+		const focused = this.focused;
+		if (!focused) return [];
+		return previewOf(focused.hunk).map((line) => {
+			const role = line.startsWith("+") ? "ok" : line.startsWith("-") ? "bad" : "meta";
+			return clip(`  ${paint(this.theme, role, sanitizeLine(line))}`, width);
+		});
+	}
+
+	protected hint(width: number): string {
+		return screenHint(this.theme, width, [
+			"Esc cancel",
+			{ text: "Enter revert", color: "accent" },
+			"Space toggle",
+			"a all",
+			"n none",
+		]);
+	}
+}

package/extensions/rewind/patch.ts

@@ -0,0 +1,88 @@
+/**
+ * A single-file unified diff split into its header and hunks.
+ *
+ * `/review` shows one file's patch and can revert a chosen subset of its hunks.
+ * The raw patch is what `git apply` consumes, so the parser separates the header
+ * and each hunk without rewriting them: line bodies keep their exact bytes,
+ * including a trailing `\r` or a `` marker.
+ *
+ * Only a textual, single-file patch is accepted. A binary patch, a mode-only
+ * change, and a multi-file patch all return `undefined`, so a caller cannot
+ * reverse-apply something the builder cannot reproduce faithfully.
+ *
+ * Pure: no git, no terminal, no filesystem.
+ */
+
+/** One unified-diff hunk, header included. */
+export interface Hunk {
+	/** The `@@ -a,b +c,d @@` line. */
+	header: string;
+	/** Body lines, each starting with ` `, `+`, `-`, or `\`. */
+	lines: string[];
+	/** Lines the hunk adds. */
+	added: number;
+	/** Lines the hunk removes. */
+	removed: number;
+}
+
+/** A single-file patch: the file header and its hunks. */
+export interface FilePatch {
+	/** Lines before the first hunk: `diff --git`, `index`, `---`, `+++`. */
+	header: string[];
+	hunks: Hunk[];
+}
+
+/** Prefix that starts a hunk. */
+const HUNK_PREFIX = "@@ ";
+
+/**
+ * Parse a one-file unified diff, or `undefined` when it has no textual hunks or
+ * spans more than one file.
+ */
+export function parseFilePatch(text: string): FilePatch | undefined {
+	const lines = text.split("\n");
+	if (lines.at(-1) === "") lines.pop();
+
+	const header: string[] = [];
+	const hunks: Hunk[] = [];
+	let current: Hunk | undefined;
+
+	for (const line of lines) {
+		if (line.startsWith(HUNK_PREFIX)) {
+			if (current) hunks.push(current);
+			current = { header: line, lines: [], added: 0, removed: 0 };
+			continue;
+		}
+		if (!current) {
+			// A second file starts with `diff --git` after the first header.
+			if (line.startsWith("diff --git ") && header.length > 0) return undefined;
+			header.push(line);
+			continue;
+		}
+		if (line.startsWith("diff --git ")) return undefined;
+		current.lines.push(line);
+		if (line.startsWith("+")) current.added++;
+		else if (line.startsWith("-")) current.removed++;
+	}
+
+	if (current) hunks.push(current);
+	if (hunks.length === 0) return undefined;
+	if (!header.some((line) => line.startsWith("diff --git "))) return undefined;
+	if (!header.some((line) => line.startsWith("+++ "))) return undefined;
+	return { header, hunks };
+}
+
+/**
+ * Rebuild the patch from the chosen hunks, in source order. Out-of-range and
+ * duplicate indices are dropped, so a stale selection cannot duplicate context.
+ */
+export function buildHunkPatch(patch: FilePatch, indices: readonly number[]): string {
+	const chosen = [...new Set(indices)]
+		.filter((index) => index >= 0 && index < patch.hunks.length)
+		.sort((a, b) => a - b);
+	const selected = chosen.flatMap((index) => {
+		const hunk = patch.hunks[index];
+		return hunk === undefined ? [] : [hunk.header, ...hunk.lines];
+	});
+	return [...patch.header, ...selected, ""].join("\n");
+}