pi-openai-toolkit 0.14.8 → 0.14.10

package/src/auto-mode/tool-review-tui.ts

@@ -0,0 +1,211 @@
+import { ToolExecutionComponent, type Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { boundReviewText } from "./types";
+
+const TOOL_REVIEW_PATCH = Symbol.for("pi-openai-toolkit.auto-mode.tool-execution-renderer.v1");
+const MAX_REVIEW_STATES = 256;
+const MAX_DISPLAY_DETAIL_CHARS = 180;
+
+export type ToolReviewDisplayState =
+	| { phase: "skipped"; toolName: string; detail: string }
+	| { phase: "reviewing"; toolName: string }
+	| { phase: "awaiting-user"; toolName: string }
+	| { phase: "allowed"; toolName: string; source: "reviewer" | "classifier" | "human"; detail?: string }
+	| { phase: "denied"; toolName: string; detail: string }
+	| { phase: "blocked"; toolName: string; detail: string };
+
+export interface ToolReviewRendererBridge {
+	readonly supported: boolean;
+	readonly reason?: string;
+	setTheme(theme: Theme | undefined): void;
+	setState(toolCallId: string, state: ToolReviewDisplayState): void;
+	clear(): void;
+}
+
+type ToolExecutionInstance = {
+	toolCallId?: unknown;
+};
+
+type RenderMethod = (this: ToolExecutionInstance, width: number) => string[];
+type PropertyRecord = Record<PropertyKey, unknown>;
+
+type ReviewStateStore = {
+	states: Map<string, ToolReviewDisplayState>;
+	theme?: Theme;
+};
+
+type PatchRecord = {
+	originalRender: RenderMethod;
+	store: ReviewStateStore;
+};
+
+function asPropertyRecord(value: unknown): PropertyRecord | undefined {
+	if ((typeof value !== "object" || value === null) && typeof value !== "function") return undefined;
+	return value as PropertyRecord;
+}
+
+function isRenderMethod(value: unknown): value is RenderMethod {
+	return typeof value === "function";
+}
+
+function isPatchRecord(value: unknown): value is PatchRecord {
+	const record = asPropertyRecord(value);
+	const store = record?.store;
+	return (
+		isRenderMethod(record?.originalRender) &&
+		!!store &&
+		typeof store === "object" &&
+		(store as { states?: unknown }).states instanceof Map
+	);
+}
+
+function createStore(): ReviewStateStore {
+	return { states: new Map<string, ToolReviewDisplayState>() };
+}
+
+function normalizeDisplayText(value: unknown): string {
+	return boundReviewText(value, MAX_DISPLAY_DETAIL_CHARS).replace(/\s+/g, " ").trim();
+}
+
+function getStatusPresentation(state: ToolReviewDisplayState): {
+	color: "accent" | "success" | "error" | "warning" | "muted";
+	text: string;
+} {
+	switch (state.phase) {
+		case "skipped":
+			return { color: "muted", text: `not reviewed · ${normalizeDisplayText(state.detail)}` };
+		case "reviewing":
+			return { color: "accent", text: `reviewing ${normalizeDisplayText(state.toolName)}` };
+		case "awaiting-user":
+			return { color: "warning", text: `waiting for approval of ${normalizeDisplayText(state.toolName)}` };
+		case "allowed":
+			return {
+				color: "success",
+				text: `allowed by ${state.source}${state.detail ? ` · ${normalizeDisplayText(state.detail)}` : ""}`,
+			};
+		case "denied":
+			return { color: "error", text: `denied · ${normalizeDisplayText(state.detail)}` };
+		case "blocked":
+			return { color: "warning", text: `blocked · ${normalizeDisplayText(state.detail)}` };
+	}
+}
+
+/**
+ * Format the single line appended below a Pi tool block. Kept pure so width,
+ * truncation, and untrusted reviewer text are testable without booting the TUI.
+ */
+export function formatToolReviewLine(
+	state: ToolReviewDisplayState,
+	width: number,
+	theme?: Theme,
+): string {
+	const presentation = getStatusPresentation(state);
+	const plain = `  ${presentation.text}`;
+	const maxWidth = Number.isFinite(width) ? Math.max(1, Math.floor(width)) : 1;
+	const styled = theme ? theme.fg(presentation.color, plain) : plain;
+	const truncated = truncateToWidth(styled, maxWidth, "");
+	return truncated + " ".repeat(Math.max(0, maxWidth - visibleWidth(truncated)));
+}
+
+function normalizeState(state: ToolReviewDisplayState): ToolReviewDisplayState {
+	const toolName = normalizeDisplayText(state.toolName);
+	switch (state.phase) {
+		case "skipped":
+			return { phase: "skipped", toolName, detail: normalizeDisplayText(state.detail) };
+		case "reviewing":
+			return { phase: "reviewing", toolName };
+		case "awaiting-user":
+			return { phase: "awaiting-user", toolName };
+		case "allowed":
+			return state.detail
+				? { phase: "allowed", toolName, source: state.source, detail: normalizeDisplayText(state.detail) }
+				: { phase: "allowed", toolName, source: state.source };
+		case "denied":
+			return { phase: "denied", toolName, detail: normalizeDisplayText(state.detail) };
+		case "blocked":
+			return { phase: "blocked", toolName, detail: normalizeDisplayText(state.detail) };
+	}
+}
+
+function createUnsupportedBridge(reason: string): ToolReviewRendererBridge {
+	return {
+		supported: false,
+		reason,
+		setTheme: () => undefined,
+		setState: () => undefined,
+		clear: () => undefined,
+	};
+}
+
+function createBridge(store: ReviewStateStore, supported = true, reason?: string): ToolReviewRendererBridge {
+	return {
+		supported,
+		reason,
+		setTheme: (theme) => {
+			store.theme = theme;
+		},
+		setState: (toolCallId, state) => {
+			const id = toolCallId.trim();
+			if (!id) return;
+			store.states.set(id, normalizeState(state));
+			while (store.states.size > MAX_REVIEW_STATES) {
+				const oldest = store.states.keys().next().value;
+				if (oldest === undefined) break;
+				store.states.delete(oldest);
+			}
+		},
+		clear: () => {
+			store.states.clear();
+		},
+	};
+}
+
+/**
+ * Install the optional per-tool review footer against Pi's exported
+ * ToolExecutionComponent. Pi has no public decorator hook yet, so this is a
+ * deliberately narrow, feature-detected compatibility patch. If the class or
+ * its render method changes, callers retain the existing global footer path.
+ */
+export function installToolReviewRenderer(
+	target: unknown = ToolExecutionComponent,
+): ToolReviewRendererBridge {
+	const targetRecord = asPropertyRecord(target);
+	const prototype = asPropertyRecord(targetRecord?.prototype);
+	if (!prototype) return createUnsupportedBridge("ToolExecutionComponent prototype is unavailable");
+
+	const existing = prototype[TOOL_REVIEW_PATCH];
+	if (isPatchRecord(existing)) return createBridge(existing.store);
+
+	const originalRender = prototype.render;
+	if (!isRenderMethod(originalRender)) return createUnsupportedBridge("ToolExecutionComponent.render is unavailable");
+
+	const store = createStore();
+	const wrappedRender: RenderMethod = function (this: ToolExecutionInstance, width: number): string[] {
+		const lines = originalRender.call(this, width);
+		if (!Array.isArray(lines) || typeof this.toolCallId !== "string") return lines;
+		const state = store.states.get(this.toolCallId);
+		if (!state) return lines;
+		return [...lines, formatToolReviewLine(state, width, store.theme)];
+	};
+	const patch: PatchRecord = { originalRender, store };
+
+	try {
+		Object.defineProperty(prototype, TOOL_REVIEW_PATCH, {
+			configurable: true,
+			enumerable: false,
+			writable: false,
+			value: patch,
+		});
+		prototype.render = wrappedRender;
+		if (prototype.render !== wrappedRender) throw new Error("ToolExecutionComponent.render is not writable");
+	} catch {
+		try {
+			delete prototype[TOOL_REVIEW_PATCH];
+		} catch {
+			// Best effort only: the compatibility fallback remains safe either way.
+		}
+		return createUnsupportedBridge("ToolExecutionComponent.render cannot be patched");
+	}
+
+	return createBridge(store);
+}

package/src/auto-mode/transcript.ts

@@ -1,133 +1,133 @@
-import type { SessionEntry } from "@earendil-works/pi-coding-agent";
-import {
-	boundReviewText,
-	MAX_TRANSCRIPT_CHARS,
-	MAX_TRANSCRIPT_ENTRY_CHARS,
-	MAX_TRANSCRIPT_RECENT_ENTRIES,
-	MAX_TRANSCRIPT_TOOL_CHARS,
-	TRUNCATION_MARKER,
-} from "./types";
-
-/**
- * A transcript line already reduced to text, with the role kept so the reviewer can
- * tell whose words these are. `[user]` is the only role that carries authorization.
- */
-export type TranscriptLine = {
-	role: "user" | "assistant" | "tool";
-	text: string;
-};
-
-function textOfContent(content: unknown): string {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return "";
-	return content
-		.map((block) => {
-			if (!block || typeof block !== "object") return "";
-			const record = block as Record<string, unknown>;
-			if (record.type === "text" && typeof record.text === "string") return record.text;
-			if (record.type === "image") return "[image omitted]";
-			if (record.type === "toolCall" && typeof record.name === "string") {
-				const args = record.arguments;
-				return `${record.name} ${typeof args === "object" && args ? JSON.stringify(args) : ""}`.trim();
-			}
-			return "";
-		})
-		.filter(Boolean)
-		.join("\n")
-		.trim();
-}
-
-/**
- * Flatten session entries into reviewer lines. Non-message entries are skipped,
- * except a compaction summary, which is kept as a `[user]`-adjacent context marker
- * because it is the only surviving view of the older conversation.
- */
-export function sessionEntriesToLines(entries: readonly SessionEntry[]): TranscriptLine[] {
-	const lines: TranscriptLine[] = [];
-	for (const entry of entries) {
-		if (entry.type === "compaction" && typeof entry.summary === "string") {
-			const summary = boundReviewText(entry.summary, MAX_TRANSCRIPT_ENTRY_CHARS);
-			if (summary) lines.push({ role: "assistant", text: `[earlier conversation summary] ${summary}` });
-			continue;
-		}
-		if (entry.type !== "message") continue;
-		const message = entry.message as { role?: unknown; content?: unknown };
-		const text = textOfContent(message.content);
-		if (!text) continue;
-		if (message.role === "user") lines.push({ role: "user", text });
-		else if (message.role === "assistant") lines.push({ role: "assistant", text });
-		else if (message.role === "toolResult") lines.push({ role: "tool", text });
-	}
-	return lines;
-}
-
-function renderLine(index: number, line: TranscriptLine): string {
-	const body = boundReviewText(line.text, MAX_TRANSCRIPT_ENTRY_CHARS);
-	return `[${index}] [${line.role}]: ${body}`;
-}
-
-/**
- * Build a bounded transcript the way Codex's guardian does: user turns are the
- * anchors and are protected, tool and assistant evidence gets its own smaller
- * budget so verbose command output cannot crowd out the human conversation that
- * actually establishes authorization.
- *
- * Selection order is newest-first, then rendered in chronological order.
- */
-export function buildReviewTranscript(
-	lines: readonly TranscriptLine[],
-	budgets: {
-		maxTotalChars?: number;
-		maxToolChars?: number;
-		maxRecentEntries?: number;
-	} = {},
-): { text: string; omitted: boolean } {
-	const maxTotalChars = budgets.maxTotalChars ?? MAX_TRANSCRIPT_CHARS;
-	const maxToolChars = budgets.maxToolChars ?? MAX_TRANSCRIPT_TOOL_CHARS;
-	const maxRecentEntries = budgets.maxRecentEntries ?? MAX_TRANSCRIPT_RECENT_ENTRIES;
-
-	const recent = lines.slice(-Math.max(1, maxRecentEntries));
-	const omitted = recent.length < lines.length;
-
-	const userLines: number[] = [];
-	const otherLines: number[] = [];
-	recent.forEach((line, index) => {
-		if (line.role === "user") userLines.push(index);
-		else otherLines.push(index);
-	});
-
-	const selected = new Set<number>();
-	let userChars = 0;
-	// The first user turn carries the task; the latest carries the immediate ask.
-	for (const index of [userLines[0]!, userLines[userLines.length - 1]!, ...userLines.slice(1, -1).reverse()]) {
-		if (index === undefined || selected.has(index)) continue;
-		const cost = recent[index]!.text.length;
-		if (userChars + cost > maxTotalChars) break;
-		selected.add(index);
-		userChars += cost;
-	}
-
-	let toolChars = 0;
-	for (const index of [...otherLines].reverse()) {
-		const cost = recent[index]!.text.length;
-		if (toolChars + cost > maxToolChars) continue;
-		if (userChars + toolChars + cost > maxTotalChars) continue;
-		selected.add(index);
-		toolChars += cost;
-	}
-
-	const ordered = [...selected].sort((a, b) => a - b);
-	const rendered = ordered.map((index) => renderLine(index + 1, recent[index]!));
-	if (omitted) rendered.unshift(`${TRUNCATION_MARKER} earlier conversation entries were omitted.`);
-	return { text: rendered.join("\n"), omitted };
-}
-
-/**
- * Build the reviewer transcript straight from session entries.
- */
-export function transcriptFromEntries(
-	entries: readonly SessionEntry[],
-	budgets?: Parameters<typeof buildReviewTranscript>[1],
-): { text: string; omitted: boolean } {
-	return buildReviewTranscript(sessionEntriesToLines(entries), budgets);
-}
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import {
+	boundReviewText,
+	MAX_TRANSCRIPT_CHARS,
+	MAX_TRANSCRIPT_ENTRY_CHARS,
+	MAX_TRANSCRIPT_RECENT_ENTRIES,
+	MAX_TRANSCRIPT_TOOL_CHARS,
+	TRUNCATION_MARKER,
+} from "./types";
+
+/**
+ * A transcript line already reduced to text, with the role kept so the reviewer can
+ * tell whose words these are. `[user]` is the only role that carries authorization.
+ */
+export type TranscriptLine = {
+	role: "user" | "assistant" | "tool";
+	text: string;
+};
+
+function textOfContent(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content
+		.map((block) => {
+			if (!block || typeof block !== "object") return "";
+			const record = block as Record<string, unknown>;
+			if (record.type === "text" && typeof record.text === "string") return record.text;
+			if (record.type === "image") return "[image omitted]";
+			if (record.type === "toolCall" && typeof record.name === "string") {
+				const args = record.arguments;
+				return `${record.name} ${typeof args === "object" && args ? JSON.stringify(args) : ""}`.trim();
+			}
+			return "";
+		})
+		.filter(Boolean)
+		.join("\n")
+		.trim();
+}
+
+/**
+ * Flatten session entries into reviewer lines. Non-message entries are skipped,
+ * except a compaction summary, which is kept as a `[user]`-adjacent context marker
+ * because it is the only surviving view of the older conversation.
+ */
+export function sessionEntriesToLines(entries: readonly SessionEntry[]): TranscriptLine[] {
+	const lines: TranscriptLine[] = [];
+	for (const entry of entries) {
+		if (entry.type === "compaction" && typeof entry.summary === "string") {
+			const summary = boundReviewText(entry.summary, MAX_TRANSCRIPT_ENTRY_CHARS);
+			if (summary) lines.push({ role: "assistant", text: `[earlier conversation summary] ${summary}` });
+			continue;
+		}
+		if (entry.type !== "message") continue;
+		const message = entry.message as { role?: unknown; content?: unknown };
+		const text = textOfContent(message.content);
+		if (!text) continue;
+		if (message.role === "user") lines.push({ role: "user", text });
+		else if (message.role === "assistant") lines.push({ role: "assistant", text });
+		else if (message.role === "toolResult") lines.push({ role: "tool", text });
+	}
+	return lines;
+}
+
+function renderLine(index: number, line: TranscriptLine): string {
+	const body = boundReviewText(line.text, MAX_TRANSCRIPT_ENTRY_CHARS);
+	return `[${index}] [${line.role}]: ${body}`;
+}
+
+/**
+ * Build a bounded transcript the way Codex's guardian does: user turns are the
+ * anchors and are protected, tool and assistant evidence gets its own smaller
+ * budget so verbose command output cannot crowd out the human conversation that
+ * actually establishes authorization.
+ *
+ * Selection order is newest-first, then rendered in chronological order.
+ */
+export function buildReviewTranscript(
+	lines: readonly TranscriptLine[],
+	budgets: {
+		maxTotalChars?: number;
+		maxToolChars?: number;
+		maxRecentEntries?: number;
+	} = {},
+): { text: string; omitted: boolean } {
+	const maxTotalChars = budgets.maxTotalChars ?? MAX_TRANSCRIPT_CHARS;
+	const maxToolChars = budgets.maxToolChars ?? MAX_TRANSCRIPT_TOOL_CHARS;
+	const maxRecentEntries = budgets.maxRecentEntries ?? MAX_TRANSCRIPT_RECENT_ENTRIES;
+
+	const recent = lines.slice(-Math.max(1, maxRecentEntries));
+	const omitted = recent.length < lines.length;
+
+	const userLines: number[] = [];
+	const otherLines: number[] = [];
+	recent.forEach((line, index) => {
+		if (line.role === "user") userLines.push(index);
+		else otherLines.push(index);
+	});
+
+	const selected = new Set<number>();
+	let userChars = 0;
+	// The first user turn carries the task; the latest carries the immediate ask.
+	for (const index of [userLines[0]!, userLines[userLines.length - 1]!, ...userLines.slice(1, -1).reverse()]) {
+		if (index === undefined || selected.has(index)) continue;
+		const cost = recent[index]!.text.length;
+		if (userChars + cost > maxTotalChars) break;
+		selected.add(index);
+		userChars += cost;
+	}
+
+	let toolChars = 0;
+	for (const index of [...otherLines].reverse()) {
+		const cost = recent[index]!.text.length;
+		if (toolChars + cost > maxToolChars) continue;
+		if (userChars + toolChars + cost > maxTotalChars) continue;
+		selected.add(index);
+		toolChars += cost;
+	}
+
+	const ordered = [...selected].sort((a, b) => a - b);
+	const rendered = ordered.map((index) => renderLine(index + 1, recent[index]!));
+	if (omitted) rendered.unshift(`${TRUNCATION_MARKER} earlier conversation entries were omitted.`);
+	return { text: rendered.join("\n"), omitted };
+}
+
+/**
+ * Build the reviewer transcript straight from session entries.
+ */
+export function transcriptFromEntries(
+	entries: readonly SessionEntry[],
+	budgets?: Parameters<typeof buildReviewTranscript>[1],
+): { text: string; omitted: boolean } {
+	return buildReviewTranscript(sessionEntriesToLines(entries), budgets);
+}