pi-bro 0.23.1 → 0.24.0

package/src/review-ui.ts

@@ -1,7 +1,5 @@
 import {
 	matchesKey,
-	truncateToWidth,
-	visibleWidth,
 	wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
 import {
@@ -10,8 +8,8 @@ import {
 	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 { execute, reviewBackendNotice } from "./backend.ts";
+import { capabilityBackend, readSettings, selectionForCapability } from "./settings.ts";
 import {
 	replaceGuide,
 	guideEvidence,
@@ -24,19 +22,22 @@ import {
 	type ReviewRecord,
 } from "./review.ts";
 import { captureReview, readEvidence, resolveReviewTarget } from "./review-source.ts";
-import { ReviewModal, newReviewView, safeReviewText } from "./review-modal.ts";
+import { REVIEW_OVERLAY, ReviewModal, newReviewView, safeReviewText } from "./review-modal.ts";
+import { formatNotice, modalHeight, openBroOverlay, renderFrame } from "./modal-kit.ts";
 import { consumeWheel } from "./ui-capabilities.ts";
 
+export const REVIEW_ACQUIRE_OVERLAY = {
+	anchor: "center",
+	width: "70%",
+	minWidth: 44,
+	maxHeight: "60%",
+	margin: { top: 1, bottom: 1 },
+} as const;
+
 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,
@@ -74,10 +75,12 @@ export async function openGuidedReview(
 		if (!picked) return;
 		record = records[labels.indexOf(picked)];
 	} else {
-		record = await ctx.ui.custom<ReviewRecord | undefined>(
+		record = await openBroOverlay<ReviewRecord | undefined>(
+			ctx,
 			(tui, theme, _keys, done) => {
 				let controller = new AbortController();
 				let message = "Resolving PR identity…";
+				let advisory: string | undefined;
 				let failed = false;
 				let retryable = true;
 				let startedAt = Date.now();
@@ -95,11 +98,15 @@ export async function openGuidedReview(
 				const acquire = async () => {
 					failed = false;
 					retryable = true;
+					advisory = undefined;
 					startedAt = Date.now();
 					controller = new AbortController();
 					message = "Resolving PR identity…";
 					tui.requestRender();
 					try {
+						// Resolved before PR identity: the advisory is about the backend that will run the
+						// review, so it belongs on a resolution failure too, not only a capture failure.
+						advisory = reviewBackendNotice(capabilityBackend(await readSettings(), "review"));
 						const target = await resolveReviewTarget(value, ctx.cwd, controller.signal);
 						if (disposed) return;
 						const id = reviewKey(target);
@@ -125,12 +132,6 @@ export async function openGuidedReview(
 							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);
@@ -153,29 +154,22 @@ export async function openGuidedReview(
 				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, "")));
+						const height = modalHeight(tui, REVIEW_ACQUIRE_OVERLAY);
+						const hints = failed ? (retryable ? "Enter retry · Esc close" : "Esc close") : "Esc cancel";
+						return renderFrame(theme, width, height, {
+							header: () =>
+								theme.fg("accent", theme.bold("Bro · Review")) +
+								(failed ? "" : theme.fg("dim", ` · ${Math.floor((Date.now() - startedAt) / 1000)}s`)),
+							body: (_rows, innerWidth) =>
+								wrapTextWithAnsi(safeReviewText(message), innerWidth).map((line) =>
+									failed ? theme.fg("error", line) : theme.fg("dim", line),
+								),
+							// An advisory is information, not a failure: keep it visible even when the fetch fails.
+							notice: advisory ? formatNotice(theme, advisory, "warning") : undefined,
+							hints,
+							fill: false,
+							minBody: 1,
+						});
 					},
 					invalidate() {},
 					handleMouse: consumeWheel,
@@ -195,7 +189,7 @@ export async function openGuidedReview(
 					},
 				};
 			},
-			{ overlay: true, overlayOptions },
+			{ overlay: REVIEW_ACQUIRE_OVERLAY },
 		);
 	}
 	if (!record) return;
@@ -207,7 +201,8 @@ export async function openGuidedReview(
 	activeReviews.set(state.id, undefined);
 	let overlayHandle: { setHidden(hidden: boolean): void } | undefined;
 	try {
-		await ctx.ui.custom<void>(
+		await openBroOverlay<void>(
+			ctx,
 			(tui, theme, _keys, done) => {
 				let controller: AbortController | undefined;
 				let running: Promise<void> | undefined;
@@ -309,7 +304,9 @@ export async function openGuidedReview(
 						await persist();
 						const settings = await readSettings();
 						const selection = selectionForCapability(settings, "review");
-						panel.notice = `${question ? "Answering" : regenerate ? "Regenerating guide" : "Preparing guide"} · ${selection.backend ?? "agy"}`;
+						const backend = capabilityBackend(settings, "review");
+						panel.advisory = reviewBackendNotice(backend) ?? "";
+						panel.notice = `${question ? "Answering" : regenerate ? "Regenerating guide" : "Preparing guide"} · ${backend}`;
 						panel.stage = {
 							step: "investigate",
 							detail: question ? "Considering your question" : "Inspecting captured changes",
@@ -474,6 +471,14 @@ export async function openGuidedReview(
 					changed,
 				});
 				void hydrateEvidence();
+				// Also on reopen: the advisory is about the selected backend, not about a new turn.
+				void readSettings().then(
+					(settings) => {
+						panel.advisory = reviewBackendNotice(capabilityBackend(settings, "review")) ?? "";
+						if (!closed) tui.requestRender();
+					},
+					() => {},
+				);
 				if (fresh)
 					queueMicrotask(() => {
 						if (!closed && !closing) running = run("whole review");
@@ -509,8 +514,9 @@ export async function openGuidedReview(
 				};
 			},
 			{
-				overlay: true,
-				overlayOptions,
+				overlay: REVIEW_OVERLAY,
+				// Regular-mode wheel scrolling; released while hidden behind the regenerate confirm.
+				mouse: true,
 				onHandle: (handle) => {
 					overlayHandle = handle;
 				},

package/src/ui-capabilities.ts

@@ -34,16 +34,23 @@ export async function insertBroDesktopText(ctx: UiContext, text: string): Promis
 /** Only terminal mode uses synchronous insertion; Desktop uses insertBroDesktopText instead. */
 export function canBroInsertIntoEditor(ctx: UiContext): boolean { return ctx.mode === "tui"; }
 
+/** Any raw SGR mouse report; regular-mode reporting delivers these to handleInput. */
+export const SGR_MOUSE = /^\x1b\[<(\d+);(\d+);(\d+)[Mm]$/;
+
+/** A raw SGR wheel report (Pi 0.84 and regular mode): ±3 lines at a 1-based terminal cell. */
+export function rawWheel(data: string): { delta: number; column: number; row: number } | undefined {
+	const match = SGR_MOUSE.exec(data);
+	const button = match ? Number.parseInt(match[1]!, 10) : 0;
+	if ((button & 64) === 0 || (button & 3) > 1) return undefined;
+	return { delta: button & 1 ? 3 : -3, column: Number(match![2]), row: Number(match![3]) };
+}
+
 export function wheelDelta(data: string): number {
-	const match = /^\x1b\[<(\d+);\d+;\d+[Mm]$/.exec(data);
-	if (!match) return 0;
-	const button = Number.parseInt(match[1], 10);
-	if ((button & 64) === 0) return 0;
-	return (button & 3) === 0 ? -3 : (button & 3) === 1 ? 3 : 0;
+	return rawWheel(data)?.delta ?? 0;
 }
 
 /** Structural subset of pi-tui's mouse event; Pi 0.84 declares no mouse types. */
-export type BroMouseEvent = { type: string; wheelDelta?: number };
+export type BroMouseEvent = { type: string; x?: number; y?: number; wheelDelta?: number };
 export type BroMouseResult = { handled: boolean; render: boolean } | undefined;
 
 /** Pi 1.2+ scrolls the chat behind an overlay whose handleMouse leaves a wheel unhandled. */