@gavin-hu/my-pi-agent 0.14.0 → 0.15.1

package/extensions/rewind/path-picker.ts

@@ -5,21 +5,21 @@
  * The screen is the timeline's sibling — same dock frame, same cursor, same
  * width-safe row grammar — so a partial restore reads as one more step in
  * `/rewind` rather than a second product. Rows are selected by default, which
- * makes `Enter` here reproduce the whole-tree restore exactly.
+ * makes `Enter` here reproduce the whole-tree restore exactly. The frame, the
+ * cursor, and the toggle keys come from {@link ChecklistScreen}.
  *
  * The component owns only the selection: paths in, a chosen subset out through
  * `onClose`, and the restore itself stays behind the confirmation that follows.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { Key, matchesKey, type Component, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
-import { fitRows, formatRange, isCloseKey, ListCursor, navigateList, scrollList } from "../../lib/tui/cursor.ts";
-import { dockListFrame, screenHint, type ViewportRowsSource } from "../../lib/tui/chrome.ts";
+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 { titleRule } from "../../lib/tui/rules.ts";
 import { paint } from "../../lib/tui/tokens.ts";
+import { ChecklistScreen } from "./checklist.ts";
 import { baseName, expandGroup, groupPaths, SELECTION_MARKS, type ChangedPath, type PathGroup } from "./paths.ts";
 
 export interface PathPickerOptions {
@@ -32,119 +32,79 @@ export interface PathPickerOptions {
 	viewportRows?: ViewportRowsSource;
 }
 
-/** Rows the screen shows when the terminal height is unknown. */
-const SCREEN_DEFAULT_ITEMS = 12;
-/** Header, summary, blanks, and footer rows around the list. */
-const SCREEN_CHROME_ROWS = 6;
-
 /** One rendered row: a directory header or a file under one. */
 type Row = { kind: "group"; group: PathGroup } | { kind: "file"; path: ChangedPath; dir: string };
 
 /** The checklist of changed paths. */
-export class PathPickerComponent implements Component {
-	private readonly cursor: ListCursor;
+export class PathPickerComponent extends ChecklistScreen<Row> {
+	private readonly view: PathPickerOptions;
 	private readonly groups: PathGroup[];
-	private readonly rows: Row[];
-	private readonly chosen = new Set<string>();
-
-	constructor(private readonly options: PathPickerOptions) {
-		this.cursor = new ListCursor(options.requestRender);
-		this.groups = groupPaths(options.paths);
-		// Every path starts selected, so confirming without touching anything means
-		// "restore it all" — the behavior `/rewind` had before the checklist existed.
-		for (const group of this.groups) for (const path of expandGroup(group)) this.chosen.add(path);
-		this.rows = this.groups.flatMap((group): Row[] => [
+	private readonly flat: readonly Row[];
+
+	constructor(view: PathPickerOptions) {
+		super({
+			title: "Restore paths",
+			theme: view.theme,
+			requestRender: view.requestRender,
+			viewportRows: view.viewportRows,
+		});
+		this.view = view;
+		this.groups = groupPaths(view.paths);
+		this.flat = this.groups.flatMap((group): Row[] => [
 			{ kind: "group", group },
 			...group.paths.map((path): Row => ({ kind: "file", path, dir: group.dir })),
 		]);
 	}
 
-	/** Whether every file under `group` is selected. */
-	private groupOn(group: PathGroup): boolean {
-		return group.paths.every((path) => this.chosen.has(path.path));
+	protected rows(): readonly Row[] {
+		return this.flat;
 	}
 
-	/** Toggle every file under `group` to `on`. */
-	private setGroup(group: PathGroup, on: boolean): void {
-		for (const path of expandGroup(group)) {
-			if (on) this.chosen.add(path);
-			else this.chosen.delete(path);
-		}
+	/** A group header's key is never selected: it toggles its files instead. */
+	protected keyOf(row: Row): string {
+		return row.kind === "group" ? row.group.dir : row.path.path;
 	}
 
-	/** Apply a key press. Exposed for the tests that drive the screen directly. */
-	handleInput(data: string): void {
-		if (isCloseKey(data)) {
-			this.options.onClose(undefined);
-			return;
-		}
-		if (navigateList(data, this.cursor, this.rows.length)) return;
-		if (data === " ") {
-			const row = this.rows[this.cursor.selected];
-			if (row?.kind === "group") this.setGroup(row.group, !this.groupOn(row.group));
-			else if (row) {
-				if (this.chosen.has(row.path.path)) this.chosen.delete(row.path.path);
-				else this.chosen.add(row.path.path);
-			}
-			this.options.requestRender();
-			return;
-		}
-		if (data === "a") {
-			for (const path of this.options.paths) this.chosen.add(path.path);
-			this.options.requestRender();
-			return;
-		}
-		if (data === "n") {
-			this.chosen.clear();
-			this.options.requestRender();
-			return;
-		}
-		if (matchesKey(data, Key.enter)) this.options.onClose([...this.chosen]);
+	/**
+	 * Every path starts selected, so confirming without touching anything means
+	 * "restore it all" — the behavior `/rewind` had before the checklist existed.
+	 */
+	protected initialSelection(): readonly string[] {
+		return this.groups.flatMap(expandGroup);
 	}
 
-	/** Wheel scrolling in fullscreen moves the cursor; regular mode leaves the wheel to the terminal. */
-	handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
-		return scrollList(event, this.cursor, this.rows.length);
+	protected selectableKeys(): readonly string[] {
+		return this.view.paths.map((path) => path.path);
 	}
 
-	dispose(): void {}
-
-	invalidate(): void {}
-
-	// The shared dock frame, like every other list screen.
-	render(width: number): string[] {
-		const w = Math.max(1, width);
-		const header = titleRule(this.theme, w, "Restore paths");
-		const cursor = this.cursor;
-		cursor.visible = fitRows(this.options.viewportRows, this.rows.length, SCREEN_CHROME_ROWS, SCREEN_DEFAULT_ITEMS);
-		const { start, end } = cursor.window(this.rows.length);
-
-		const body: string[] = [];
-		for (let i = start; i < end; i++) body.push(this.rowLine(w, this.rows[i], i === cursor.selected));
-
-		const total = this.options.paths.length;
-		const selected = this.chosen.size;
-		return dockListFrame({
-			header,
-			summary: clip(
-				`  ${paint(this.theme, "meta", `${selected} of ${total} selected${SEPARATORS.item}Space toggles a file or a directory`)}`,
-				w,
-			),
-			body,
-			range: cursor.clipped(this.rows.length)
-				? formatRange(this.theme, w, { start, end, total: this.rows.length })
-				: undefined,
-			detail: this.detail(w),
-			hint: this.hint(w),
-		});
+	protected onEnter(selection: string[]): void {
+		this.view.onClose(selection);
+	}
+
+	protected onCancel(): void {
+		this.view.onClose(undefined);
 	}
 
-	private get theme(): Theme {
-		return this.options.theme;
+	/** Space on a directory header toggles every file under it. */
+	protected override toggle(row: Row): void {
+		if (row.kind === "file") {
+			super.toggle(row);
+			return;
+		}
+		const on = !this.groupOn(row.group);
+		for (const path of expandGroup(row.group)) {
+			if (on) this.chosen.add(path);
+			else this.chosen.delete(path);
+		}
+	}
+
+	/** Whether every file under `group` is selected. */
+	private groupOn(group: PathGroup): boolean {
+		return group.paths.every((path) => this.chosen.has(path.path));
 	}
 
 	/** One row: a directory header with its count, or a file with its change mark. */
-	private rowLine(width: number, row: Row, selected: boolean): string {
+	protected rowLine(row: Row, width: number, selected: boolean): string {
 		const tone = selected ? "accent" : row.kind === "group" ? "meta" : "label";
 		if (row.kind === "group") {
 			const count = row.group.paths.length;
@@ -170,10 +130,15 @@ export class PathPickerComponent implements Component {
 		});
 	}
 
+	protected summaryText(): string {
+		const total = this.view.paths.length;
+		return `${this.chosen.size} of ${total} selected${SEPARATORS.item}Space toggles a file or a directory`;
+	}
+
 	/** What the focused row will do, in words. */
-	private detail(width: number): string[] | undefined {
-		const row = this.rows[this.cursor.selected];
-		if (!row) return undefined;
+	protected detailLines(width: number): string[] {
+		const row = this.focusedRow;
+		if (!row) return [];
 		const text =
 			row.kind === "group"
 				? `Space selects or clears all ${row.group.paths.length} file${row.group.paths.length === 1 ? "" : "s"} in this directory.`
@@ -181,12 +146,14 @@ export class PathPickerComponent implements Component {
 					? "A — created after the snapshot; restoring removes it."
 					: row.path.change === "deleted"
 						? "D — deleted since the snapshot; restoring brings it back."
-						: "M — modified since the snapshot; restoring rewrites it.";
+						: row.path.change === "renamed"
+							? `R — renamed from ${sanitizeLine(row.path.from)}; restoring brings the old path back and removes this one.`
+							: "M — modified since the snapshot; restoring rewrites it.";
 		return [clip(`  ${paint(this.theme, "meta", text)}`, width)];
 	}
 
 	/** The key-hint row, with the primary action in the accent role. */
-	private hint(width: number): string {
+	protected hint(width: number): string {
 		return screenHint(this.theme, width, [
 			"Esc cancel",
 			{ text: "Enter restore", color: "accent" },

package/extensions/rewind/paths.ts

@@ -6,27 +6,36 @@
  * cannot disagree about what changed. Pure: parsing, grouping, marks, and the
  * counts `RestoreSummary` reports.
  *
- * A rename arrives as `R100\told\tnew`. It is expanded into two entries — the old
- * path as deleted and the new one as added — because that is exactly what the
- * restore does to each: selecting the old path brings it back, selecting the new
- * one removes it. Both rows appear in the checklist rather than one opaque one.
+ * A rename arrives as `R100\told\tnew` and stays one entry: `path` is the
+ * destination, `from` the path it had in the snapshot, and the mark is `R`.
+ * Keeping both sides on one entry is what makes a single selection atomic — the
+ * restore recreates `from` and deletes `path`, so neither side can be left
+ * behind. `entryPaths` is the one place that names both.
  */
 
+/** The single-path statuses, which never carry a source path. */
+type SimpleChange = "modified" | "deleted" | "added";
+
 /** What a restore does to one path. */
-export type PathChange = "modified" | "deleted" | "added";
+export type PathChange = SimpleChange | "renamed";
 
-/** One path the snapshot differs on, and how. */
-export interface ChangedPath {
-	/** Repository-relative path, as git reports it. */
+/** Fields every changed path carries. */
+interface ChangedPathBase {
+	/** Repository-relative path, as git reports it; a rename's destination. */
 	path: string;
-	change: PathChange;
 }
 
+/** One path the snapshot differs on, and how. A rename always names its source. */
+export type ChangedPath =
+	| (ChangedPathBase & { change: SimpleChange })
+	| (ChangedPathBase & { change: "renamed"; from: string });
+
 /** The trailing mark for each change in the checklist. */
 export const SELECTION_MARKS: Readonly<Record<PathChange, string>> = {
 	modified: "M",
 	deleted: "D",
 	added: "A",
+	renamed: "R",
 };
 
 /** One directory's files, for the checklist's grouping. */
@@ -38,7 +47,7 @@ export interface PathGroup {
 }
 
 /** The status letter → change kind, for the single-path statuses. */
-function changeOf(letter: string): PathChange | undefined {
+function changeOf(letter: string): SimpleChange | undefined {
 	switch (letter) {
 		case "M":
 		case "T": // a type change (file ↔ symlink) rewrites the path
@@ -53,10 +62,10 @@ function changeOf(letter: string): PathChange | undefined {
 }
 
 /**
- * Parse `git diff --name-status` output. A rename expands to both of its paths
- * (as described in the module comment) and a copy to its destination only — the
- * source is untouched, so it is not a changed path. An unknown status letter is
- * skipped rather than guessed at.
+ * Parse `git diff --name-status` output. A rename keeps both of its paths on
+ * one entry and a copy becomes its destination only — the source is untouched,
+ * so it is not a changed path. An unknown status letter is skipped rather than
+ * guessed at.
  */
 export function parseNameStatus(stdout: string): ChangedPath[] {
 	const changed: ChangedPath[] = [];
@@ -67,8 +76,8 @@ export function parseNameStatus(stdout: string): ChangedPath[] {
 		const letter = status[0] ?? "";
 		if (letter === "R" || letter === "C") {
 			if (!second) continue;
-			if (letter === "R") changed.push({ path: first, change: "deleted" });
-			changed.push({ path: second, change: "added" });
+			if (letter === "R") changed.push({ path: second, change: "renamed", from: first });
+			else changed.push({ path: second, change: "added" });
 			continue;
 		}
 		const kind = changeOf(letter);
@@ -113,9 +122,19 @@ export function expandGroup(group: PathGroup): string[] {
 }
 
 /**
- * The counts the plan and the summary report: `changed` is modified plus deleted
- * (files rewritten from the snapshot), and `removed` is the paths created after
- * it, which the restore deletes.
+ * Every path an entry spans: both sides of a rename, otherwise just its path.
+ * A restore and a diff request both use this, so one selection covers the move.
+ */
+export function entryPaths(entry: ChangedPath): string[] {
+	return entry.change === "renamed" ? [entry.from, entry.path] : [entry.path];
+}
+
+/**
+ * The counts the plan and the summary report: `changed` is every path rewritten
+ * from the snapshot (modified, deleted, or a rename's source), and `removed` is
+ * the paths created after it, which the restore deletes. A rename counts once:
+ * it is one file changed, and its destination is removed as part of the move
+ * rather than counted a second time.
  */
 export function summarize(paths: readonly ChangedPath[]): { changed: number; removed: number } {
 	let changed = 0;
@@ -126,3 +145,58 @@ export function summarize(paths: readonly ChangedPath[]): { changed: number; rem
 	}
 	return { changed, removed };
 }
+
+/** Line counts for one path, or nulls when git reports a binary change. */
+export interface PathStat {
+	/** Added lines, or null when git reports `-` (binary). */
+	added: number | null;
+	/** Removed lines, or null when git reports `-` (binary). */
+	removed: number | null;
+}
+
+/** A changed path with the line counts the review list shows. */
+export type ReviewEntry = ChangedPath & {
+	added: number | null;
+	removed: number | null;
+};
+
+/**
+ * Parse `git diff --numstat` output into a path -> line-count map.
+ *
+ * Counts are `-` for a binary file, which becomes null so the screen can say
+ * `bin` instead of inventing a zero. A malformed line is skipped rather than
+ * guessed at, and the path is the rest of the line so a path containing a tab
+ * survives the split.
+ */
+export function parseNumStat(stdout: string): Map<string, PathStat> {
+	const stats = new Map<string, PathStat>();
+	for (const line of stdout.split("\n")) {
+		if (line.trim() === "") continue;
+		const [addedRaw, removedRaw, ...rest] = line.split("\t");
+		const path = rest.join("\t");
+		if (addedRaw === undefined || removedRaw === undefined || path === "") continue;
+		const added = addedRaw === "-" ? null : Number.parseInt(addedRaw, 10);
+		const removed = removedRaw === "-" ? null : Number.parseInt(removedRaw, 10);
+		if (added !== null && !Number.isFinite(added)) continue;
+		if (removed !== null && !Number.isFinite(removed)) continue;
+		stats.set(path, { added, removed });
+	}
+	return stats;
+}
+
+/**
+ * Attach line counts to changed paths and sort them for a stable screen order.
+ * Line counts are read with `--no-renames`, so a rename's `+n` lives on its
+ * destination and its `−n` on its source.
+ */
+export function toReviewEntries(paths: readonly ChangedPath[], stats: ReadonlyMap<string, PathStat>): ReviewEntry[] {
+	const countsOf = (entry: ChangedPath): PathStat => {
+		const destination = stats.get(entry.path);
+		const source = entry.change === "renamed" ? stats.get(entry.from) : undefined;
+		return {
+			added: destination?.added ?? null,
+			removed: (source ?? destination)?.removed ?? null,
+		};
+	};
+	return [...paths].sort((a, b) => a.path.localeCompare(b.path)).map((entry) => ({ ...entry, ...countsOf(entry) }));
+}

package/extensions/rewind/restore.ts

@@ -11,10 +11,11 @@
  * pathspec, so the selected paths are checked out of the snapshot instead, and
  * only the selected additions are deleted. Everything else is left exactly as it
  * is, and the same temporary index is used, so the real index stays untouched
- * either way.
+ * either way. A rename is one entry whose selection checks out its source and
+ * deletes its destination, so the pair cannot be split.
  */
 
-import { lstatSync, rmSync } from "node:fs";
+import { lstatSync, rmSync, statSync } from "node:fs";
 import { resolve, sep } from "node:path";
 import {
 	busyGitState,
@@ -25,7 +26,7 @@ import {
 	treeFromWorkingTree,
 	type RunGit,
 } from "./git.ts";
-import { summarize, type ChangedPath } from "./paths.ts";
+import { entryPaths, summarize, type ChangedPath } from "./paths.ts";
 import type { Snapshot, RestoreSummary } from "./types.ts";
 
 export interface RestoreDeps {
@@ -52,6 +53,8 @@ export interface RestorePlan {
 	removed: number;
 	/** Every changed path, with how the restore treats it. */
 	paths: ChangedPath[];
+	/** Tree id of the staged working tree the comparison used. */
+	currentTree: string;
 }
 
 export type PlanResult = { ok: true; plan: RestorePlan } | { ok: false; reason: string };
@@ -65,12 +68,13 @@ export async function planRestore(deps: RestoreDeps, input: RestoreInput): Promi
 	const cur = await stagedTree(deps, input);
 	const paths = await changedPaths(deps, input, cur);
 	const diff = await diffStat(deps.runGit, input.root, input.target.commit, cur, selectionOf(paths));
-	return { ok: true, plan: { diff, ...summarize(paths), paths } };
+	return { ok: true, plan: { diff, ...summarize(paths), paths, currentTree: cur } };
 }
 
 /** The selection narrowed to paths the plan actually found, or undefined for all. */
 function selectionOf(paths: readonly ChangedPath[]): string[] | undefined {
-	return paths.length > 0 ? paths.map((entry) => entry.path) : undefined;
+	const all = paths.flatMap(entryPaths);
+	return all.length > 0 ? all : undefined;
 }
 
 /**
@@ -82,12 +86,47 @@ async function stagedTree(deps: RestoreDeps, input: RestoreInput): Promise<strin
 	return treeFromWorkingTree(deps.runGit, input.root, input.indexFile, input.target.includeUntracked);
 }
 
-/** Every changed path, narrowed to the caller's selection when one is given. */
+/**
+ * Every changed path, narrowed to the caller's selection when one is given.
+ *
+ * The diff is never limited with a pathspec: git detects a rename only when both
+ * of its paths are in scope, so a narrowed diff would turn a selected rename
+ * back into an addition and lose the side that has to be recreated.
+ */
 async function changedPaths(deps: RestoreDeps, input: RestoreInput, cur: string): Promise<ChangedPath[]> {
 	const all = await nameStatus(deps.runGit, input.root, input.target.commit, cur);
 	if (!input.paths) return all;
 	const selected = new Set(input.paths);
-	return all.filter((entry) => selected.has(entry.path));
+	return all.filter((entry) =>
+		entry.change === "renamed" ? selected.has(entry.path) || selected.has(entry.from) : selected.has(entry.path),
+	);
+}
+
+/** Paths checked out of the snapshot: everything except a path the snapshot lacks. */
+function rewrittenPaths(paths: readonly ChangedPath[]): string[] {
+	return paths.flatMap((entry) => {
+		if (entry.change === "added") return [];
+		return entry.change === "renamed" ? [entry.from] : [entry.path];
+	});
+}
+
+/**
+ * Whether two working-tree paths name the same file.
+ *
+ * A case-only rename on a case-insensitive filesystem resolves both names to one
+ * file, so deleting the destination would delete the source the checkout just
+ * restored. Comparing device and inode is cross-platform and needs no assumption
+ * about the filesystem's case sensitivity.
+ */
+function sameFile(root: string, first: string, second: string): boolean {
+	try {
+		const a = statSync(resolve(root, first));
+		const b = statSync(resolve(root, second));
+		return a.dev === b.dev && a.ino === b.ino;
+	} catch {
+		// A missing path cannot be the same file, and deleting it is a no-op.
+		return false;
+	}
 }
 
 /** Delete a path under `root`, refusing to escape it or remove a directory. */
@@ -110,8 +149,7 @@ export async function applyRestore(deps: RestoreDeps, input: RestoreInput): Prom
 	const cur = await stagedTree(deps, input);
 	const paths = await changedPaths(deps, input, cur);
 	const { changed, removed } = summarize(paths);
-	const rewritten = paths.filter((entry) => entry.change !== "added").map((entry) => entry.path);
-	const created = paths.filter((entry) => entry.change === "added").map((entry) => entry.path);
+	const rewritten = rewrittenPaths(paths);
 
 	if (input.paths) {
 		await restorePaths(deps.runGit, input.root, input.target.commit, input.indexFile, rewritten);
@@ -120,7 +158,12 @@ export async function applyRestore(deps: RestoreDeps, input: RestoreInput): Prom
 		// which a pathspec checkout of every changed path would not.
 		await readTreeReset(deps.runGit, input.root, input.target.commit, input.indexFile);
 	}
-	for (const path of created) deleteFile(input.root, path);
+	for (const entry of paths) {
+		if (entry.change === "added") deleteFile(input.root, entry.path);
+		else if (entry.change === "renamed" && !sameFile(input.root, entry.from, entry.path)) {
+			deleteFile(input.root, entry.path);
+		}
+	}
 
 	// A subset notice says "2 of 5 files", so it needs the whole diff's size; the
 	// all-path query is already in hand when nothing was narrowed.