pi-bro 0.20.0 → 0.22.0

package/review-ui.ts

@@ -0,0 +1,519 @@
+import {
+	matchesKey,
+	truncateToWidth,
+	visibleWidth,
+	wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+import {
+	copyToClipboard,
+	getAgentDir,
+	type ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+import { join } from "node:path";
+import { execute, reviewBackendError } from "./backend.ts";
+import { readSettings, selectionForCapability } from "./settings.ts";
+import {
+	replaceGuide,
+	guideEvidence,
+	buildReviewPrompt,
+	listReviews,
+	loadReview,
+	parseGuide,
+	reviewKey,
+	saveReview,
+	type ReviewRecord,
+} from "./review.ts";
+import { captureReview, readEvidence, resolveReviewTarget } from "./review-source.ts";
+import { ReviewModal, newReviewView, safeReviewText } from "./review-modal.ts";
+
+const activeReviews = new Map<string, AbortController | undefined>();
+export function stopGuidedReviews(): void {
+	for (const controller of activeReviews.values()) controller?.abort();
+}
+const overlayOptions = {
+	anchor: "center" as const,
+	width: "100%" as const,
+	maxHeight: "100%" as const,
+	margin: { top: 1, bottom: 1 },
+};
+
+export async function openGuidedReview(
+	ctx: ExtensionCommandContext,
+	value: string,
+	preferences: string,
+): Promise<void> {
+	if (ctx.mode !== "tui") {
+		ctx.ui.notify("Guided Review requires local Pi interactive mode.", "warning");
+		return;
+	}
+	const root = join(getAgentDir(), "bro-reviews");
+	let record: ReviewRecord | undefined;
+	let fresh = false;
+	if (value === "resume" || !value) {
+		const records = await listReviews(root, (file, error) =>
+			ctx.ui.notify(
+				`Cannot load ${file}: ${String(error)}. Original file left untouched.`,
+				"warning",
+			),
+		);
+		if (!records.length) {
+			ctx.ui.notify("Start with /bro guided-review <PR number or URL>.", "info");
+			return;
+		}
+		records.sort(
+			(a, b) =>
+				a.snapshot.target.repository.localeCompare(b.snapshot.target.repository) ||
+				b.snapshot.target.number - a.snapshot.target.number,
+		);
+		const labels = records.map(
+			(item) =>
+				`${item.snapshot.target.repository} #${item.snapshot.target.number} · ${safeReviewText(item.snapshot.target.title ?? "").replace(/[\r\n\t]/g, " ")} · ${item.guide ? (item.guide.assessment ? "review ready" : "guide ready") : "not prepared"} · ${item.snapshot.target.head.slice(0, 8)}`,
+		);
+		const picked = await ctx.ui.select("Resume guided review", labels);
+		if (!picked) return;
+		record = records[labels.indexOf(picked)];
+	} else {
+		record = await ctx.ui.custom<ReviewRecord | undefined>(
+			(tui, theme, _keys, done) => {
+				let controller = new AbortController();
+				let message = "Resolving PR identity…";
+				let failed = false;
+				let retryable = true;
+				let startedAt = Date.now();
+				let disposed = false;
+				const heartbeat = setInterval(() => {
+					if (!disposed && !failed) tui.requestRender();
+				}, 200);
+				let locked: string | undefined;
+				const release = () => {
+					if (locked) {
+						activeReviews.delete(locked);
+						locked = undefined;
+					}
+				};
+				const acquire = async () => {
+					failed = false;
+					retryable = true;
+					startedAt = Date.now();
+					controller = new AbortController();
+					message = "Resolving PR identity…";
+					tui.requestRender();
+					try {
+						const target = await resolveReviewTarget(value, ctx.cwd, controller.signal);
+						if (disposed) return;
+						const id = reviewKey(target);
+						if (activeReviews.has(id)) {
+							retryable = false;
+							throw Error(
+								"This review is already open in this Pi session. Close its existing workspace first.",
+							);
+						}
+						locked = id;
+						activeReviews.set(id, controller);
+						const existing = await loadReview(root, id);
+						if (existing) {
+							if (
+								existing.snapshot.target.head !== target.head ||
+								existing.snapshot.target.base !== target.base
+							)
+								ctx.ui.notify(
+									"PR has newer source. Continuing your saved captured revision.",
+									"info",
+								);
+							release();
+							if (!disposed) done(existing);
+							return;
+						}
+						const selection = selectionForCapability(await readSettings(), "review");
+						const backendError = reviewBackendError(selection.backend ?? "agy");
+						if (backendError) {
+							retryable = false;
+							throw Error(backendError);
+						}
+						message = `${target.repository} #${target.number} · ${target.head.slice(0, 8)}\nFetching captured source…`;
+						tui.requestRender();
+						const snapshot = await captureReview(target, root, controller.signal);
+						if (disposed) return;
+						const next: ReviewRecord = { version: 1, id, snapshot, turns: [], ui: newReviewView() };
+						await saveReview(root, next);
+						fresh = true;
+						release();
+						if (!disposed) done(next);
+					} catch (error) {
+						if (!disposed) {
+							failed = true;
+							message = error instanceof Error ? error.message : String(error);
+							tui.requestRender();
+						}
+					} finally {
+						release();
+					}
+				};
+				void acquire();
+				return {
+					render(width: number) {
+						const inner = Math.max(1, width - 2);
+						const height = Math.max(1, tui.terminal.rows - 2);
+						const border = "─".repeat(inner);
+						const row = (text: string) => {
+							const line = truncateToWidth(text, inner, "…");
+							return `│${line}${" ".repeat(Math.max(0, inner - visibleWidth(line)))}│`;
+						};
+						const body = wrapTextWithAnsi(safeReviewText(message), inner).slice(
+							0,
+							Math.max(1, height - 4),
+						);
+						const lines = [
+							`╭${border}╮`,
+							row(
+								`Bro · Review${failed ? "" : ` · ${Math.floor((Date.now() - startedAt) / 1000)}s`}`,
+							),
+							...body.map(row),
+							row(failed ? (retryable ? "Esc close · Enter retry" : "Esc close") : "Esc cancel"),
+							`╰${border}╯`,
+						];
+						return lines
+							.slice(0, height)
+							.map((line) => theme.fg("accent", truncateToWidth(line, width, "")));
+					},
+					invalidate() {},
+					handleInput(data: string) {
+						if (matchesKey(data, "escape")) {
+							disposed = true;
+							controller.abort();
+							release();
+							done(undefined);
+						} else if (failed && retryable && matchesKey(data, "return")) void acquire();
+					},
+					dispose() {
+						disposed = true;
+						clearInterval(heartbeat);
+						controller.abort();
+						release();
+					},
+				};
+			},
+			{ overlay: true, overlayOptions },
+		);
+	}
+	if (!record) return;
+	const state = record;
+	if (activeReviews.has(state.id)) {
+		ctx.ui.notify("This review is already open in this Pi session.", "info");
+		return;
+	}
+	activeReviews.set(state.id, undefined);
+	let overlayHandle: { setHidden(hidden: boolean): void } | undefined;
+	try {
+		await ctx.ui.custom<void>(
+			(tui, theme, _keys, done) => {
+				let controller: AbortController | undefined;
+				let running: Promise<void> | undefined;
+				let closed = false;
+				let closing = false;
+				let confirming = false;
+				let saveTimer: ReturnType<typeof setTimeout> | undefined;
+				let queue = Promise.resolve();
+				const evidenceAbort = new AbortController();
+				const persist = () => {
+					if (saveTimer) {
+						clearTimeout(saveTimer);
+						saveTimer = undefined;
+					}
+					const snapshot = structuredClone(state);
+					queue = queue.catch(() => {}).then(() => saveReview(root, snapshot));
+					return queue.then(
+						() => {
+							panel.saveError = "";
+							if (!closed) tui.requestRender();
+						},
+						(error) => {
+							panel.saveError = `Not saved: ${error instanceof Error ? error.message : String(error)}. Use Retry saving, or Close to retry.`;
+							tui.requestRender();
+							throw error;
+						},
+					);
+				};
+				const changed = () => {
+					if (saveTimer) clearTimeout(saveTimer);
+					saveTimer = setTimeout(() => {
+						void persist().catch(() => {});
+					}, 250);
+				};
+				const evidenceReads = new Map<string, Promise<void>>();
+				const hydrateEvidence = async () => {
+					for (const ref of guideEvidence(state.guide)) {
+						if (!ref.valid || closed) continue;
+						const key = `${ref.path}:${ref.side}:${ref.start}:${ref.end}`;
+						if (panel.evidence.has(key)) continue;
+						let pending = evidenceReads.get(key);
+						if (!pending) {
+							pending = (async () => {
+								try {
+									const source = await readEvidence(
+										state.snapshot,
+										ref.path,
+										ref.side,
+										evidenceAbort.signal,
+									);
+									panel.evidence.set(
+										key,
+										source
+											.split("\n")
+											.slice(ref.start - 1, ref.end)
+											.join("\n"),
+									);
+									panel.evidenceErrors.delete(key);
+								} catch (error) {
+									panel.evidenceErrors.set(key, `Captured code unavailable: ${String(error)}`);
+								} finally {
+									evidenceReads.delete(key);
+								}
+								if (!closed) tui.requestRender();
+							})();
+							evidenceReads.set(key, pending);
+						}
+						await pending;
+					}
+				};
+				const run = async (target: string, question?: string, regenerate = false) => {
+					if (controller || closed || closing) return;
+					if (!question && state.guide && !regenerate) return;
+					let generated = false;
+					const abort = new AbortController();
+					controller = abort;
+					activeReviews.set(state.id, abort);
+					panel.busy = true;
+					panel.operation = question ? "answer" : regenerate ? "regenerate" : "guide";
+					panel.startedAt = Date.now();
+					panel.notice = question
+						? "Answering…"
+						: regenerate
+							? "Regenerating guide…"
+							: "Preparing guide…";
+					panel.stage = { step: "start", detail: "Starting review" };
+					const heartbeat = setInterval(() => {
+						if (!closed) tui.requestRender();
+					}, 200);
+					const prompt = buildReviewPrompt(state, question, target, preferences);
+					const turn: ReviewRecord["turns"][number] | undefined = question
+						? { question, answer: "", target, status: "partial" }
+						: undefined;
+					panel.activeTurn = turn;
+					if (turn) state.turns.push(turn);
+					else state.guideAttempt = { text: "", status: "partial" };
+					tui.requestRender();
+					try {
+						await persist();
+						const settings = await readSettings();
+						const selection = selectionForCapability(settings, "review");
+						panel.notice = `${question ? "Answering" : regenerate ? "Regenerating guide" : "Preparing guide"} · ${selection.backend ?? "agy"}`;
+						panel.stage = {
+							step: "investigate",
+							detail: question ? "Considering your question" : "Inspecting captured changes",
+						};
+						tui.requestRender();
+						const outcome = await execute(
+							{ feature: "review", access: "restricted", cwd: state.snapshot.checkout, prompt },
+							selection,
+							abort.signal,
+							(progress) => {
+								if (closed || abort.signal.aborted) return;
+								if (progress.kind === "text") {
+									if (turn) turn.answer = progress.text;
+									else state.guideAttempt = { text: progress.text, status: "partial" };
+									panel.stage = {
+										step: "receive",
+										detail: `Receiving response · ${progress.text.length.toLocaleString()} chars`,
+									};
+								} else panel.notice = progress.label;
+								changed();
+								tui.requestRender();
+							},
+						);
+						if (outcome.status !== "success") {
+							if (outcome.partialText) {
+								if (turn) turn.answer = outcome.partialText;
+								else state.guideAttempt = { text: outcome.partialText, status: "partial" };
+							}
+							throw Error(outcome.message);
+						}
+						if (abort.signal.aborted) throw Error("Cancelled");
+						if (turn) {
+							turn.answer = outcome.text;
+							turn.status = "complete";
+						} else {
+							state.guideAttempt = { text: outcome.text, status: "partial" };
+							let checked = 0;
+							panel.stage = { step: "check", detail: "Checking references" };
+							tui.requestRender();
+							const guide = await parseGuide(
+								outcome.text,
+								async (path, side) => {
+									try {
+										return await readEvidence(state.snapshot, path, side, abort.signal);
+									} finally {
+										panel.stage = {
+											step: "check",
+											detail: `Checking references · ${++checked} checked`,
+										};
+										if (!closed) tui.requestRender();
+									}
+								},
+								true,
+							);
+							if (abort.signal.aborted) throw Error("Cancelled");
+							replaceGuide(state, guide);
+							panel.syncGuideView();
+							generated = true;
+							delete state.guideAttempt;
+							void hydrateEvidence();
+						}
+						panel.stage = { step: "save", detail: "Saving review" };
+						tui.requestRender();
+						await persist();
+						panel.notice = "Saved";
+					} catch (error) {
+						if (turn && !abort.signal.aborted) {
+							turn.status = "failed";
+							turn.error = error instanceof Error ? error.message : String(error);
+						}
+						if (!turn && !generated && !abort.signal.aborted)
+							state.guideAttempt = {
+								text: state.guideAttempt?.text ?? "",
+								status: "failed",
+								error: String(error),
+							};
+						panel.notice = abort.signal.aborted ? "Stopped; partial work retained." : String(error);
+						try {
+							await persist();
+						} catch {
+							/* saveError stays visible independently of request status. */
+						}
+					} finally {
+						clearInterval(heartbeat);
+						controller = undefined;
+						if (activeReviews.has(state.id)) activeReviews.set(state.id, undefined);
+						panel.activeTurn = undefined;
+						panel.stage = undefined;
+						panel.busy = false;
+						if (!closed) tui.requestRender();
+					}
+				};
+				const close = async () => {
+					if (closing || closed) return;
+					closing = true;
+					controller?.abort();
+					try {
+						await running;
+						await persist();
+						closed = true;
+						ctx.ui.notify(
+							`Review saved privately. Reopen with /bro guided-review ${state.snapshot.target.url ?? `https://${state.snapshot.target.host ?? "github.com"}/${state.snapshot.target.repository}/pull/${state.snapshot.target.number}`}. Use /bro guided-review to list saved reviews.`,
+							"info",
+						);
+						done();
+					} catch {
+						closing = false;
+						tui.requestRender();
+					}
+				};
+				const panel = new ReviewModal(state, tui, theme, {
+					ask(target, question) {
+						running = run(target, question);
+					},
+					prepare() {
+						running = run("whole review");
+					},
+					retrySave() {
+						void persist().catch(() => {});
+					},
+					regenerate() {
+						if (confirming || controller || closing || closed) return;
+						confirming = true;
+						overlayHandle?.setHidden(true);
+						void ctx.ui
+							.confirm(
+								"Regenerate guide?",
+								`Generate a new guide for captured revision ${state.snapshot.target.head.slice(0, 8)}? The new guide replaces your current guide when generation succeeds. Questions and drafts are kept with their original context. This makes a model call.`,
+							)
+							.then((approved) => {
+								if (approved && !closed && !closing) running = run("whole review", undefined, true);
+							})
+							.catch((error) => {
+								panel.notice = String(error);
+							})
+							.finally(() => {
+								confirming = false;
+								if (!closed) overlayHandle?.setHidden(false);
+								tui.requestRender();
+							});
+					},
+					stop() {
+						controller?.abort();
+						panel.notice = "Stopping…";
+						tui.requestRender();
+					},
+					copy(text) {
+						void copyToClipboard(text)
+							.then(() => {
+								panel.notice = "Finding copied to clipboard. Nothing submitted.";
+							})
+							.catch((error) => {
+								panel.notice = `Copy failed: ${String(error)}`;
+							})
+							.finally(() => {
+								if (!closed) tui.requestRender();
+							});
+					},
+					close() {
+						void close();
+					},
+					changed,
+				});
+				void hydrateEvidence();
+				if (fresh)
+					queueMicrotask(() => {
+						if (!closed && !closing) running = run("whole review");
+					});
+				return {
+					render: (width: number) => panel.render(width),
+					invalidate: () => panel.invalidate(),
+					handleInput: (data: string) => {
+						if (!closing) {
+							panel.handleInput(data);
+							if (matchesKey(data, "return") && ["reading", "finding"].includes(panel.view.screen))
+								void hydrateEvidence();
+						}
+					},
+					handleMouse: (event: Parameters<ReviewModal["handleMouse"]>[0]) =>
+						closing ? { handled: true, render: false } : panel.handleMouse(event),
+					get focused() {
+						return panel.focused;
+					},
+					set focused(value: boolean) {
+						panel.focused = value;
+					},
+					dispose() {
+						closed = true;
+						panel.dispose();
+						evidenceAbort.abort();
+						controller?.abort();
+						if (saveTimer) clearTimeout(saveTimer);
+						void persist().catch(() => {});
+					},
+				};
+			},
+			{
+				overlay: true,
+				overlayOptions,
+				onHandle: (handle) => {
+					overlayHandle = handle;
+				},
+			},
+		);
+	} finally {
+		activeReviews.get(state.id)?.abort();
+		activeReviews.delete(state.id);
+	}
+}