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

package/extensions/rewind/review.ts

@@ -0,0 +1,397 @@
+/**
+ * The `/review` orchestration.
+ *
+ * The latest prompt with an `auto` snapshot on the active branch is the review
+ * target. `runtime.plan` already knows how to diff that snapshot against the
+ * working tree and how to restore a subset, so this module only coordinates:
+ * the file list, the per-file patch, the confirmations, the restore, and the
+ * refresh afterwards. No state is persisted; every open re-derives the review
+ * from git and the session branch.
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { messageOf } from "../../lib/errors.ts";
+import { sanitizeLine } from "../../lib/format.ts";
+import { isPlanModeEnabled } from "../../lib/plan-state.ts";
+import { withRailsSuppressed } from "../../lib/rails.ts";
+import {
+	boundDiff,
+	formatHunkRevertBody,
+	formatHunkRevertText,
+	formatRevertAllBody,
+	formatRevertOneBody,
+	formatRevertSelectedBody,
+	formatReviewListText,
+	formatReviewRevertText,
+} from "./format.ts";
+import { HunkPickerComponent } from "./hunk-picker.ts";
+import { buildHunkPatch, parseFilePatch } from "./patch.ts";
+import { entryPaths, toReviewEntries, type ReviewEntry } from "./paths.ts";
+import {
+	ReviewDiffComponent,
+	ReviewListComponent,
+	type ReviewDiffAction,
+	type ReviewListResult,
+} from "./review-tui.ts";
+import type { RestorePlan } from "./restore.ts";
+import type { RewindRuntime } from "./runtime.ts";
+import { buildRewindPoints, type RewindPoint } from "./timeline.ts";
+import type { Snapshot, RestoreSummary } from "./types.ts";
+
+/** One reviewable view of the working tree. */
+interface ReviewView {
+	plan: RestorePlan;
+	entries: ReviewEntry[];
+	/** Tree id of HEAD when the view was read, or undefined without a commit. */
+	headTree?: string;
+}
+
+/** Whether the working tree is clean against HEAD, so the diff is all committed. */
+function isCommitted(view: ReviewView): boolean {
+	return view.headTree !== undefined && view.plan.currentTree === view.headTree;
+}
+
+/** A loaded review: where it is, which prompt it follows, and what changed. */
+interface LoadedReview {
+	root: string;
+	point: RewindPoint;
+	snapshot: Snapshot;
+	view: ReviewView;
+}
+
+type LoadResult = { ok: true; review: LoadedReview } | { ok: false; kind: "info" | "warning"; message: string };
+
+type RefreshResult = { kind: "ok"; view: ReviewView } | { kind: "empty" } | { kind: "error"; message: string };
+
+type RevertResult =
+	| { kind: "ok"; summary: RestoreSummary; next: ReviewView }
+	| { kind: "empty"; summary: RestoreSummary }
+	| { kind: "error"; message: string };
+
+/** The latest prompt on the branch with a code snapshot, or a reason there is none. */
+async function loadReview(runtime: RewindRuntime, ctx: ExtensionCommandContext): Promise<LoadResult> {
+	if (!ctx.isIdle()) await ctx.waitForIdle();
+	if (isPlanModeEnabled(ctx.sessionManager.getBranch())) {
+		return {
+			ok: false,
+			kind: "warning",
+			message: "Plan mode is read-only. Approve the plan before reviewing and reverting its changes.",
+		};
+	}
+
+	const root = await runtime.rootFor(ctx);
+	if (!root) return { ok: false, kind: "warning", message: "Review needs a git repository." };
+
+	const snapshots = await runtime.list(root);
+	const point = buildRewindPoints(ctx.sessionManager.getBranch(), snapshots, ctx.sessionManager.getSessionId()).find(
+		(candidate) => candidate.snapshot,
+	);
+	if (!point?.snapshot) {
+		return { ok: false, kind: "info", message: "No prompt with a code snapshot to review yet." };
+	}
+
+	const planned = await runtime.plan(root, point.snapshot);
+	if (!planned.ok) return { ok: false, kind: "warning", message: planned.reason };
+	if (planned.plan.paths.length === 0) {
+		const label = point.summary || "this prompt";
+		return { ok: false, kind: "info", message: `No changes since the snapshot for "${label}".` };
+	}
+
+	const stats = await runtime.numStat(root, point.snapshot, planned.plan.currentTree);
+	const headTree = await runtime.headTree(root);
+	return {
+		ok: true,
+		review: {
+			root,
+			point,
+			snapshot: point.snapshot,
+			view: { plan: planned.plan, entries: toReviewEntries(planned.plan.paths, stats), headTree },
+		},
+	};
+}
+
+/** Re-plan after a revert, so the list and counts reflect the tree that is left. */
+async function refreshView(runtime: RewindRuntime, root: string, snapshot: Snapshot): Promise<RefreshResult> {
+	const planned = await runtime.plan(root, snapshot);
+	if (!planned.ok) return { kind: "error", message: planned.reason };
+	if (planned.plan.paths.length === 0) return { kind: "empty" };
+	const stats = await runtime.numStat(root, snapshot, planned.plan.currentTree);
+	const headTree = await runtime.headTree(root);
+	return { kind: "ok", view: { plan: planned.plan, entries: toReviewEntries(planned.plan.paths, stats), headTree } };
+}
+
+/**
+ * Repaint the status chip, then re-read the review. A repaint failure is never
+ * reported as a restore failure, because the restore has already happened.
+ */
+async function refreshAfterMutation(
+	runtime: RewindRuntime,
+	ctx: ExtensionCommandContext,
+	review: LoadedReview,
+): Promise<RefreshResult> {
+	try {
+		await runtime.setStatus(ctx);
+	} catch {
+		// The status chip is best-effort; a failed repaint must not report the
+		// restore itself as failed.
+	}
+	try {
+		return await refreshView(runtime, review.root, review.snapshot);
+	} catch (error) {
+		return { kind: "error", message: `Reverted, but could not refresh the review: ${messageOf(error)}` };
+	}
+}
+
+/** Restore one or more paths, then re-read the review. */
+async function revertPaths(
+	runtime: RewindRuntime,
+	ctx: ExtensionCommandContext,
+	review: LoadedReview,
+	paths: readonly string[],
+): Promise<RevertResult> {
+	let summary: RestoreSummary;
+	try {
+		summary = await runtime.restore(ctx, review.root, review.snapshot, runtime.configFor(review.root), paths);
+	} catch (error) {
+		return { kind: "error", message: `Revert failed: ${messageOf(error)}` };
+	}
+	const refreshed = await refreshAfterMutation(runtime, ctx, review);
+	if (refreshed.kind === "error") return { kind: "error", message: refreshed.message };
+	if (refreshed.kind === "empty") return { kind: "empty", summary };
+	return { kind: "ok", summary, next: refreshed.view };
+}
+
+/** Ask before reverting one file. */
+async function confirmRevertOne(
+	ctx: ExtensionCommandContext,
+	review: LoadedReview,
+	entry: ReviewEntry,
+	safety: boolean,
+	committed: boolean,
+): Promise<boolean> {
+	return ctx.ui.confirm(
+		`Revert ${sanitizeLine(entry.path)}?`,
+		formatRevertOneBody(entry, review.point.prompt, safety, committed),
+	);
+}
+
+/** Ask before reverting one or more selected files. */
+async function confirmRevertSelected(
+	ctx: ExtensionCommandContext,
+	review: LoadedReview,
+	entries: readonly ReviewEntry[],
+	safety: boolean,
+	committed: boolean,
+): Promise<boolean> {
+	const files = `${entries.length} selected file${entries.length === 1 ? "" : "s"}`;
+	return ctx.ui.confirm(`Revert ${files}?`, formatRevertSelectedBody(entries, review.point.prompt, safety, committed));
+}
+
+/** Ask before reverting chosen hunks of one file. */
+async function confirmHunks(
+	ctx: ExtensionCommandContext,
+	review: LoadedReview,
+	entry: ReviewEntry,
+	selected: number,
+	total: number,
+	safety: boolean,
+	committed: boolean,
+): Promise<boolean> {
+	return ctx.ui.confirm(
+		`Revert ${selected} hunk${selected === 1 ? "" : "s"} in ${sanitizeLine(entry.path)}?`,
+		formatHunkRevertBody(entry, selected, total, review.point.prompt, safety, committed),
+	);
+}
+
+/** Ask before reverting every changed path in the review. */
+async function confirmRevertAll(
+	ctx: ExtensionCommandContext,
+	review: LoadedReview,
+	entries: readonly ReviewEntry[],
+	safety: boolean,
+	committed: boolean,
+): Promise<boolean> {
+	const files = `${entries.length} file${entries.length === 1 ? "" : "s"}`;
+	return ctx.ui.confirm(`Revert all ${files}?`, formatRevertAllBody(entries, review.point.prompt, safety, committed));
+}
+
+/** The interactive loop: list, diff, confirm, restore, refresh. */
+async function reviewLoop(runtime: RewindRuntime, ctx: ExtensionCommandContext, review: LoadedReview): Promise<void> {
+	const label = review.point.summary || review.point.prompt || "this prompt";
+	const safety = runtime.configFor(review.root).safetySnapshot;
+	let view = review.view;
+	let index = 0;
+	let selected: string[] = [];
+
+	/** Take a refreshed view: the selection is gone and the focus is re-clamped. */
+	const adopt = (next: ReviewView): void => {
+		view = next;
+		selected = [];
+		index = Math.min(index, view.entries.length - 1);
+	};
+
+	/** Fold one revert into the loop's state; `"done"` means the loop should leave. */
+	const settleRevert = (result: RevertResult): "next" | "done" => {
+		if (result.kind === "error") {
+			ctx.ui.notify(result.message, "error");
+			return "done";
+		}
+		const remaining = result.kind === "ok" ? result.next.entries.length : 0;
+		ctx.ui.notify(formatReviewRevertText(result.summary, remaining), "info");
+		if (result.kind === "empty") return "done";
+		adopt(result.next);
+		return "next";
+	};
+
+	while (true) {
+		const committed = isCommitted(view);
+		const screen = await ctx.ui.custom<ReviewListResult | undefined>(
+			(tui, theme, _keybindings, done) =>
+				new ReviewListComponent({
+					entries: view.entries,
+					prompt: label,
+					theme,
+					initialIndex: index,
+					initialSelected: selected,
+					committed,
+					onClose: (result) => done(result),
+					requestRender: () => tui.requestRender(),
+					viewportRows: () => tui.terminal?.rows,
+				}),
+		);
+		if (!screen) return;
+		selected = screen.selected;
+		const action = screen.action;
+		if (!action) return;
+
+		if (action.kind === "revertAll") {
+			if (!(await confirmRevertAll(ctx, review, view.entries, safety, committed))) continue;
+			const paths = view.plan.paths.map((entry) => entry.path);
+			if (settleRevert(await revertPaths(runtime, ctx, review, paths)) === "done") return;
+			continue;
+		}
+
+		if (action.kind === "revert") {
+			const entries = action.paths
+				.map((path) => view.entries.find((candidate) => candidate.path === path))
+				.filter((entry): entry is ReviewEntry => entry !== undefined);
+			if (entries.length === 0) continue;
+			const paths = entries.map((entry) => entry.path);
+			const approved =
+				entries.length === 1
+					? await confirmRevertOne(ctx, review, entries[0], safety, committed)
+					: await confirmRevertSelected(ctx, review, entries, safety, committed);
+			if (!approved) continue;
+			if (settleRevert(await revertPaths(runtime, ctx, review, paths)) === "done") return;
+			continue;
+		}
+
+		const entry = view.entries.find((candidate) => candidate.path === action.path);
+		if (!entry) continue;
+		let patch: string;
+		try {
+			patch = await runtime.patch(review.root, review.snapshot, view.plan.currentTree, entryPaths(entry));
+		} catch (error) {
+			ctx.ui.notify(`Could not read the diff: ${messageOf(error)}`, "error");
+			continue;
+		}
+		const filePatch = parseFilePatch(patch);
+		const canRevertHunks = filePatch !== undefined && filePatch.hunks.length > 0;
+		const decision = await ctx.ui.custom<ReviewDiffAction | undefined>(
+			(tui, theme, _keybindings, done) =>
+				new ReviewDiffComponent({
+					entry,
+					prompt: label,
+					lines: boundDiff(patch),
+					canRevertHunks,
+					committed,
+					theme,
+					onClose: (chosen) => done(chosen),
+					requestRender: () => tui.requestRender(),
+					viewportRows: () => tui.terminal?.rows,
+				}),
+		);
+		if (decision === "hunks") {
+			if (!filePatch) continue;
+			const chosen = await ctx.ui.custom<number[] | undefined>(
+				(tui, theme, _keybindings, done) =>
+					new HunkPickerComponent({
+						path: entry.path,
+						hunks: filePatch.hunks,
+						theme,
+						onClose: (selection) => done(selection),
+						requestRender: () => tui.requestRender(),
+						viewportRows: () => tui.terminal?.rows,
+					}),
+			);
+			if (chosen === undefined) continue;
+			if (chosen.length === 0) {
+				ctx.ui.notify("No hunks selected.", "info");
+				continue;
+			}
+			if (!(await confirmHunks(ctx, review, entry, chosen.length, filePatch.hunks.length, safety, committed))) {
+				continue;
+			}
+			let safetyId: string | undefined;
+			try {
+				const reverted = await runtime.revertHunks(
+					ctx,
+					review.root,
+					review.snapshot,
+					runtime.configFor(review.root),
+					buildHunkPatch(filePatch, chosen),
+				);
+				safetyId = reverted.safety;
+			} catch (error) {
+				ctx.ui.notify(`Revert failed: ${messageOf(error)}`, "error");
+				continue;
+			}
+			const refreshed = await refreshAfterMutation(runtime, ctx, review);
+			if (refreshed.kind === "error") {
+				ctx.ui.notify(refreshed.message, "error");
+				return;
+			}
+			const remaining = refreshed.kind === "ok" ? refreshed.view.entries.length : 0;
+			ctx.ui.notify(formatHunkRevertText(entry.path, chosen.length, safetyId, remaining), "info");
+			if (refreshed.kind === "empty") return;
+			adopt(refreshed.view);
+			continue;
+		}
+		if (decision !== "revert") continue;
+		if (!(await confirmRevertOne(ctx, review, entry, safety, committed))) continue;
+		if (settleRevert(await revertPaths(runtime, ctx, review, [entry.path])) === "done") return;
+	}
+}
+
+/**
+ * Open `/review`: the latest turn's changes, with per-file diffs and reverts.
+ *
+ * The TUI gets the two screens. RPC, print, and JSON print the changed-file
+ * list, because custom components cannot be forwarded; that keeps the command
+ * useful without pretending the review actions exist there.
+ */
+export async function openReview(
+	pi: ExtensionAPI,
+	runtime: RewindRuntime,
+	ctx: ExtensionCommandContext,
+): Promise<void> {
+	let loaded: LoadResult;
+	try {
+		loaded = await loadReview(runtime, ctx);
+	} catch (error) {
+		ctx.ui.notify(`Review failed: ${messageOf(error)}`, "error");
+		return;
+	}
+	if (!loaded.ok) {
+		ctx.ui.notify(loaded.message, loaded.kind);
+		return;
+	}
+	if (ctx.mode !== "tui") {
+		ctx.ui.notify(
+			formatReviewListText(loaded.review.view.entries, loaded.review.point.prompt, isCommitted(loaded.review.view)),
+			"info",
+		);
+		return;
+	}
+	await withRailsSuppressed(pi, () => reviewLoop(runtime, ctx, loaded.review));
+}

package/extensions/rewind/rewind-tui.ts

@@ -11,7 +11,7 @@
 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 { detailBlockRows, dockListFrame, screenHint, type ViewportRowsSource } from "../../lib/tui/chrome.ts";
 import { clip } from "../../lib/tui/columns.ts";
 import { SEPARATORS } from "../../lib/tui/glyphs.ts";
 import { emptyState, listRow } from "../../lib/tui/rows.ts";
@@ -89,10 +89,11 @@ export class RewindListComponent implements Component {
 		const cursor = this.cursor;
 		const focused = this.points[cursor.selected];
 		const detail = focused ? formatRewindDetail(Boolean(focused.snapshot), focused.snapshot?.id) : "";
+		const detailLines = detail ? [clip(`  ${paint(this.theme, "meta", detail)}`, w)] : undefined;
 		cursor.visible = fitRows(
 			this.options.viewportRows,
 			this.points.length,
-			SCREEN_CHROME_ROWS + (detail ? 1 : 0),
+			SCREEN_CHROME_ROWS + detailBlockRows(detailLines),
 			SCREEN_DEFAULT_ITEMS,
 		);
 
@@ -127,7 +128,7 @@ export class RewindListComponent implements Component {
 			range: cursor.clipped(this.points.length)
 				? formatRange(this.theme, w, { start, end, total: this.points.length })
 				: undefined,
-			detail: detail ? [clip(`  ${paint(this.theme, "meta", detail)}`, w)] : undefined,
+			detail: detailLines,
 			hint: this.hint(w),
 		});
 	}

package/extensions/rewind/runtime.ts

@@ -11,9 +11,18 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { resolveEffectiveCwd } from "../../lib/env.ts";
 import { loadConfig, type RewindConfig } from "./config.ts";
-import { createRewindRunner, repoRoot, type RunGit } from "./git.ts";
+import {
+	applyPatchReverse,
+	createRewindRunner,
+	diffNumStat,
+	diffPatch,
+	repoRoot,
+	revParse,
+	type RunGit,
+} from "./git.ts";
 import { createOperationQueue } from "./queue.ts";
 import { applyRestore, planRestore, type PlanResult, type RestoreInput } from "./restore.ts";
+import type { PathStat } from "./paths.ts";
 import { createSnapshot } from "./snapshot.ts";
 import { createStatusChip } from "./status.ts";
 import { belongsToRoot, listSnapshots, pruneSnapshots } from "./store.ts";
@@ -26,6 +35,12 @@ export interface SnapshotOptions {
 	prompt?: string;
 }
 
+/** What a hunk revert did beyond the file it touched. */
+export interface HunkRevertResult {
+	/** Id of the pre-restore safety snapshot, when one was taken. */
+	safety?: string;
+}
+
 export interface RewindRuntime {
 	/** Repository (or worktree) root, or undefined outside a repository. */
 	rootFor(ctx: ExtensionContext): Promise<string | undefined>;
@@ -35,6 +50,12 @@ export interface RewindRuntime {
 	list(root: string): Promise<Snapshot[]>;
 	/** Preview a restore; `paths` narrows it to a subset of the changed paths. */
 	plan(root: string, target: Snapshot, paths?: readonly string[]): Promise<PlanResult>;
+	/** Unified patch between a snapshot and the working-tree tree `tree`. Read-only. */
+	patch(root: string, target: Snapshot, tree: string, paths?: readonly string[]): Promise<string>;
+	/** Per-path line counts for the same comparison. Read-only. */
+	numStat(root: string, target: Snapshot, tree: string, paths?: readonly string[]): Promise<Map<string, PathStat>>;
+	/** Tree id of HEAD, or undefined when the repository has no commit. Read-only. */
+	headTree(root: string): Promise<string | undefined>;
 	restore(
 		ctx: ExtensionContext,
 		root: string,
@@ -42,6 +63,14 @@ export interface RewindRuntime {
 		config: RewindConfig,
 		paths?: readonly string[],
 	): Promise<RestoreSummary>;
+	/** Reverse-apply a prepared hunk patch, after the same safety snapshot as a restore. */
+	revertHunks(
+		ctx: ExtensionContext,
+		root: string,
+		target: Snapshot,
+		config: RewindConfig,
+		patch: string,
+	): Promise<HunkRevertResult>;
 	/** Repaint the `↺ N` chip from the prompt count on the active branch (`/rewind` list size). */
 	setStatus(ctx: ExtensionContext): Promise<void>;
 	clearStatus(ctx: ExtensionContext): void;
@@ -123,6 +152,50 @@ export function createRuntime(pi: ExtensionAPI): RewindRuntime {
 			return planRestore({ runGit }, { root, indexFile: await indexStore.pathFor(root), target, paths });
 		});
 
+	const patch = (root: string, target: Snapshot, tree: string, paths?: readonly string[]): Promise<string> =>
+		diffPatch(runGit, root, target.commit, tree, paths);
+
+	const numStat = (
+		root: string,
+		target: Snapshot,
+		tree: string,
+		paths?: readonly string[],
+	): Promise<Map<string, PathStat>> => diffNumStat(runGit, root, target.commit, tree, paths);
+
+	const headTree = async (root: string): Promise<string | undefined> => {
+		try {
+			return await revParse(runGit, root, "HEAD^{tree}");
+		} catch {
+			return undefined;
+		}
+	};
+
+	/**
+	 * Snapshot the current state before a restore, returning its id. The ref is
+	 * not pruned here: the next automatic snapshot applies `max`, so the snapshot
+	 * being restored from stays available for a follow-up restore.
+	 */
+	const safetySnapshot = async (
+		ctx: ExtensionContext,
+		root: string,
+		config: RewindConfig,
+		indexFile: string,
+	): Promise<string> => {
+		const before = await createSnapshot(
+			{ runGit },
+			{
+				root,
+				indexFile,
+				namespace: config.refNamespace,
+				reason: "pre-restore",
+				includeUntracked: config.includeUntracked,
+				sessionId: ctx.sessionManager.getSessionId(),
+				entryId: lastUserEntryId(ctx.sessionManager.getBranch()),
+			},
+		);
+		return before.id;
+	};
+
 	const restore = (
 		ctx: ExtensionContext,
 		root: string,
@@ -134,26 +207,26 @@ export function createRuntime(pi: ExtensionAPI): RewindRuntime {
 			if (!belongsToRoot(target, root)) throw new Error(foreignRootReason(target, root));
 			const indexFile = await indexStore.pathFor(root);
 			const input: RestoreInput = { root, indexFile, target, paths };
-			let safety: string | undefined;
-			if (config.safetySnapshot) {
-				const before = await createSnapshot(
-					{ runGit },
-					{
-						root,
-						indexFile,
-						namespace: config.refNamespace,
-						reason: "pre-restore",
-						includeUntracked: config.includeUntracked,
-						sessionId: ctx.sessionManager.getSessionId(),
-						entryId: lastUserEntryId(ctx.sessionManager.getBranch()),
-					},
-				);
-				safety = before.id;
-			}
+			const safety = config.safetySnapshot ? await safetySnapshot(ctx, root, config, indexFile) : undefined;
 			const summary = await applyRestore({ runGit }, input);
 			return { ...summary, safety };
 		});
 
+	const revertHunks = (
+		ctx: ExtensionContext,
+		root: string,
+		target: Snapshot,
+		config: RewindConfig,
+		patch: string,
+	): Promise<HunkRevertResult> =>
+		queue.enqueue(async () => {
+			if (!belongsToRoot(target, root)) throw new Error(foreignRootReason(target, root));
+			const indexFile = await indexStore.pathFor(root);
+			const safety = config.safetySnapshot ? await safetySnapshot(ctx, root, config, indexFile) : undefined;
+			await applyPatchReverse(runGit, root, patch);
+			return { safety };
+		});
+
 	const sweepStaleIndexes = async (ctx: ExtensionContext): Promise<void> => {
 		try {
 			const root = await rootFor(ctx);
@@ -169,7 +242,11 @@ export function createRuntime(pi: ExtensionAPI): RewindRuntime {
 		snapshot,
 		list,
 		plan,
+		patch,
+		numStat,
+		headTree,
 		restore,
+		revertHunks,
 		setStatus: status.set,
 		clearStatus: status.clear,
 		releaseIndexes: indexStore.release,