@adeildo/pi-ask-permission 4.0.0

package/src/ui/dialog.ts

@@ -0,0 +1,395 @@
+import { renderDiff, type Theme } from "@earendil-works/pi-coding-agent";
+import {
+	type Component,
+	type Focusable,
+	Input,
+	Key,
+	type KeybindingsManager,
+	matchesKey,
+	truncateToWidth,
+	visibleWidth,
+	wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+
+import { type Scope, SCOPE_LABEL, SCOPES } from "#core/always-yes.ts";
+import type { DialogAnswer } from "#core/answer.ts";
+import type { CallDescriptor } from "#core/tools.ts";
+import { readClipboard } from "#ui/clipboard.ts";
+import { CHOICES, type Choice } from "#ui/decision-options.ts";
+import {
+	cleanPaste,
+	expandPastes,
+	PASTE_END,
+	PASTE_START,
+	pasteMarker,
+	shouldCollapse,
+} from "#ui/paste.ts";
+
+type Phase = "menu" | "levels";
+
+const TITLE_PREFIX = "\u256d\u2500 ";
+const TITLE_SUFFIX = "\u256e";
+// The 1 is the space between the title and its dashes.
+const TITLE_CHROME_WIDTH = visibleWidth(TITLE_PREFIX) + 1 + visibleWidth(TITLE_SUFFIX);
+
+const SUMMARY_ROWS = 3;
+const DIFF_ROWS = 16;
+
+interface AskDialogOptions {
+	theme: Theme;
+	toolName: string;
+	target: CallDescriptor;
+	diff?: string;
+	keybindings: KeybindingsManager;
+	requestRender: () => void;
+	complete: (answer: DialogAnswer) => void;
+}
+
+export class AskDialog implements Component, Focusable {
+	private readonly theme: Theme;
+	private readonly toolName: string;
+	private readonly target: CallDescriptor;
+	private readonly diff: string | undefined;
+	private readonly requestRender: () => void;
+	private readonly complete: (answer: DialogAnswer) => void;
+	private readonly keybindings: KeybindingsManager;
+
+	private readonly noteInputs: Input[];
+
+	private readonly pastes = new Map<number, string>();
+	private pasteId = 0;
+	private pasteBuffer = "";
+
+	private phase: Phase = "menu";
+	private selected = 0;
+	private levelIndex = 0;
+	private scopeIndex = 0;
+	private pending: Choice | null = null;
+	private noteIndex: number | null = null;
+
+	private pendingNote: string | undefined;
+
+	private get activeNoteInput(): Input | undefined {
+		return this.noteIndex === null ? undefined : this.noteInputs[this.noteIndex];
+	}
+
+	private focusedFlag = false;
+	get focused(): boolean {
+		return this.focusedFlag;
+	}
+	set focused(value: boolean) {
+		this.focusedFlag = value;
+		for (const input of this.noteInputs) input.focused = value;
+	}
+
+	constructor(options: AskDialogOptions) {
+		this.theme = options.theme;
+		this.toolName = options.toolName;
+		this.target = options.target;
+		this.diff = options.diff;
+		this.requestRender = options.requestRender;
+		this.complete = options.complete;
+		this.keybindings = options.keybindings;
+
+		this.noteInputs = [...CHOICES.keys()].map((index) => {
+			const input = new Input({ prompt: "", placeholder: "" });
+			input.onSubmit = () => this.choose(index);
+			input.onEscape = () => {
+				this.noteIndex = null;
+			};
+			return input;
+		});
+	}
+
+	handleInput(data: string): void {
+		try {
+			this.dispatch(data);
+		} finally {
+			this.requestRender();
+		}
+	}
+
+	invalidate(): void {
+		for (const input of this.noteInputs) input.invalidate();
+	}
+
+	render(width: number): string[] {
+		const inner = Math.max(1, width - 4);
+		const lines: string[] = [...this.summaryLines(inner), ...this.diffLines()];
+		lines.push("");
+
+		if (this.phase === "levels") {
+			lines.push(...this.levelLines());
+		} else {
+			for (const [index, option] of CHOICES.entries()) {
+				lines.push(this.renderOption(option, index, inner));
+			}
+			lines.push("");
+			lines.push(
+				this.theme.fg(
+					"dim",
+					this.noteIndex === null
+						? "\u2191\u2193 or 1-3 pick   enter confirm   tab note   esc deny"
+						: "\u2191\u2193 pick   enter confirm   esc back",
+				),
+			);
+		}
+
+		return this.frame(lines, width, inner, `permission \u00b7 ${this.toolName}`);
+	}
+
+	private dispatch(data: string): void {
+		if (this.phase === "menu" && this.noteIndex !== null) {
+			if (matchesKey(data, Key.up)) this.moveNote(-1);
+			else if (matchesKey(data, Key.down)) this.moveNote(1);
+			else if (matchesKey(data, Key.tab)) this.noteIndex = null;
+			else this.handleNoteInput(data);
+			return;
+		}
+
+		if (this.phase === "levels") {
+			if (matchesKey(data, Key.up)) this.levelIndex = Math.max(0, this.levelIndex - 1);
+			else if (matchesKey(data, Key.down))
+				this.levelIndex = Math.min(this.target.levels.length - 1, this.levelIndex + 1);
+			else if (matchesKey(data, Key.tab)) this.scopeIndex = (this.scopeIndex + 1) % SCOPES.length;
+			else if (matchesKey(data, Key.enter)) this.confirmLevel();
+			else if (matchesKey(data, Key.escape)) this.phase = "menu";
+			return;
+		}
+
+		if (matchesKey(data, Key.up)) {
+			this.moveSelection(-1);
+			return;
+		}
+		if (matchesKey(data, Key.down)) {
+			this.moveSelection(1);
+			return;
+		}
+		if (matchesKey(data, Key.tab)) {
+			this.noteIndex = this.selected;
+			return;
+		}
+		if (matchesKey(data, Key.enter)) {
+			this.choose(this.selected);
+			return;
+		}
+		if (matchesKey(data, Key.escape)) {
+			this.complete({ decision: "deny" });
+			return;
+		}
+
+		const picked = CHOICES.findIndex((option) => option.key === data);
+		if (picked >= 0) this.selected = picked;
+	}
+
+	private moveSelection(delta: number): void {
+		const count = CHOICES.length;
+		this.selected = (this.selected + delta + count) % count;
+	}
+
+	private moveNote(delta: number): void {
+		if (this.noteIndex === null) return;
+		this.moveSelection(delta);
+		this.noteIndex = this.selected;
+	}
+
+	private choose(index: number): void {
+		const option = CHOICES[index];
+		if (!option) return;
+		this.selected = index;
+
+		if (option.always) {
+			this.pending = option;
+			this.pendingNote = this.draftNote();
+			this.noteIndex = null;
+			this.levelIndex = this.target.levels.length - 1;
+			this.scopeIndex = 0;
+			this.phase = "levels";
+			return;
+		}
+
+		this.complete({
+			decision: option.decision,
+			note: this.draftNote(),
+			remember: option.always ? this.target.levels[0] : undefined,
+		});
+	}
+
+	private confirmLevel(): void {
+		const level = this.target.levels[this.levelIndex];
+		if (!this.pending || level === undefined) return;
+
+		this.complete({
+			decision: this.pending.decision,
+			note: this.pendingNote,
+			remember: level,
+			scope: this.currentScope,
+		});
+	}
+
+	private get currentScope(): Scope {
+		return SCOPES[this.scopeIndex] ?? "session";
+	}
+
+	private draftNote(): string | undefined {
+		const input = this.activeNoteInput;
+		if (!input) return undefined;
+
+		const note = expandPastes(input.getValue(), this.pastes).trim();
+		return note || undefined;
+	}
+
+	private handleNoteInput(data: string): void {
+		if (this.pasteBuffer !== "" || data.includes(PASTE_START)) {
+			this.bufferPaste(data);
+			return;
+		}
+
+		if (this.keybindings.matches(data, "app.clipboard.pasteImage")) {
+			this.pasteClipboard();
+			return;
+		}
+
+		this.activeNoteInput?.handleInput(data);
+	}
+
+	private bufferPaste(data: string): void {
+		const start = data.indexOf(PASTE_START);
+		const text = this.pasteBuffer + (start === -1 ? data : data.slice(start + PASTE_START.length));
+		const end = text.indexOf(PASTE_END);
+
+		if (end === -1) {
+			this.pasteBuffer = text;
+			return;
+		}
+
+		this.pasteBuffer = "";
+		const index = this.noteIndex;
+		if (index !== null) this.insertPaste(index, text.slice(0, end));
+
+		const rest = text.slice(end + PASTE_END.length);
+		if (rest) this.handleNoteInput(rest);
+	}
+
+	private pasteClipboard(): void {
+		const index = this.noteIndex;
+		if (index === null) return;
+
+		void readClipboard().then((text) => {
+			if (!text) return;
+			this.insertPaste(index, text);
+			this.requestRender();
+		});
+	}
+
+	private insertPaste(index: number, pastedText: string): void {
+		const input = this.noteInputs[index];
+		if (!input) return;
+
+		const text = cleanPaste(pastedText);
+		if (shouldCollapse(text)) {
+			this.pasteId++;
+			this.pastes.set(this.pasteId, text);
+			input.handleInput(pasteMarker(this.pasteId, text));
+			return;
+		}
+
+		const spacer = /^[/~.]/.test(text) && /\w$/.test(input.getValue()) ? " " : "";
+		input.handleInput(spacer + text);
+	}
+
+	private levelLines(): string[] {
+		const lines = [this.theme.fg("muted", "always yes for...")];
+
+		for (const [index, level] of this.target.levels.entries()) {
+			const active = index === this.levelIndex;
+			const marker = active ? this.theme.fg("accent", "\u276f ") : "  ";
+			lines.push(marker + this.theme.fg(active ? "accent" : "text", level));
+		}
+
+		if (this.pendingNote) lines.push(this.theme.fg("muted", `note: ${this.pendingNote}`));
+		lines.push("");
+		lines.push(
+			this.theme.fg("muted", "scope: ") +
+				this.theme.fg("accent", SCOPE_LABEL[this.currentScope]) +
+				this.theme.fg("dim", "   (tab to change)"),
+		);
+		lines.push("");
+		lines.push(this.theme.fg("dim", "\u2191\u2193 depth   tab scope   enter confirm   esc back"));
+		return lines;
+	}
+
+	private renderOption(option: Choice, index: number, inner: number): string {
+		const active = index === this.selected;
+		const editing = this.noteIndex === index;
+		const input = this.noteInputs[index];
+		const draft = input?.getValue().trim() ?? "";
+		const marker = active ? this.theme.fg("accent", "\u276f ") : "  ";
+		const key = this.theme.fg(active ? "accent" : "dim", option.key);
+		const prefix = `${marker}${key}  `;
+
+		if (!editing && !draft) {
+			return `${prefix}${this.theme.fg(active ? option.tone : "text", option.label)}`;
+		}
+
+		const room = Math.max(1, inner - visibleWidth(prefix));
+		const label = truncateToWidth(`${option.label}, `, room);
+		const noteRoom = Math.max(1, room - visibleWidth(label));
+		const note = editing
+			? (input?.render(noteRoom)[0] ?? "")
+			: this.theme.fg("dim", truncateToWidth(draft, noteRoom));
+		const head = this.theme.fg(active ? option.tone : "text", label);
+		return truncateToWidth(`${prefix}${head}${note}`, inner);
+	}
+
+	private diffLines(): string[] {
+		if (!this.diff) return [];
+
+		const lines = renderDiff(this.diff).split("\n");
+		const shown = lines.slice(0, DIFF_ROWS);
+		const hidden = lines.length - shown.length;
+		if (hidden > 0) shown.push(this.theme.fg("dim", `\u2026 ${hidden} more lines`));
+		return ["", ...shown];
+	}
+
+	private summaryLines(inner: number): string[] {
+		const wrapped = wrapTextWithAnsi(this.target.summary || "(no input)", inner);
+		const shown = wrapped.slice(0, SUMMARY_ROWS);
+		const elideLast = wrapped.length > shown.length;
+
+		return shown.map((line, index) => {
+			const text =
+				elideLast && index === shown.length - 1
+					? `${truncateToWidth(line, Math.max(0, inner - 3))}...`
+					: line;
+			return this.theme.fg("muted", text);
+		});
+	}
+
+	private frame(lines: string[], width: number, inner: number, title: string): string[] {
+		const out: string[] = [this.topBorder(width, title)];
+
+		for (const line of lines) {
+			const clipped = truncateToWidth(line, inner);
+			const pad = " ".repeat(Math.max(0, inner - visibleWidth(clipped)));
+			out.push(
+				`${this.theme.fg("border", "\u2502")} ${clipped}${pad} ${this.theme.fg("border", "\u2502")}`,
+			);
+		}
+
+		out.push(this.theme.fg("border", `\u2570${"\u2500".repeat(Math.max(0, width - 2))}\u256f`));
+		return out;
+	}
+
+	private topBorder(width: number, title: string): string {
+		const room = Math.max(0, width - TITLE_CHROME_WIDTH);
+		const label = this.theme.fg("accent", truncateToWidth(title, Math.max(0, room - 3), "..."));
+		const dashes = Math.max(0, room - visibleWidth(label));
+
+		return (
+			this.theme.fg("border", TITLE_PREFIX) +
+			label +
+			this.theme.fg("border", ` ${"\u2500".repeat(dashes)}${TITLE_SUFFIX}`)
+		);
+	}
+}

package/src/ui/judge-entry.ts

@@ -0,0 +1,130 @@
+import type { FeatureScope } from "@adeildo/pi-kit";
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+import { flatten, judgeActionLabel, judgeSignalText, judgeStatText } from "#core/judge/report.ts";
+import type { JudgeRecord } from "#core/judge/types.ts";
+import { NAME } from "#identity";
+
+const JUDGE_ENTRY = `${NAME}:judge`;
+
+const MIN_TARGET = 12;
+
+interface Columns {
+	action: number;
+	tool: number;
+}
+
+export function registerJudgeEntry(scope: FeatureScope): void {
+	scope.registerEntryRenderer<unknown>(JUDGE_ENTRY, (entry, { expanded }, theme) => {
+		const records = toRecords(entry.data);
+		if (records.length === 0) return undefined;
+		return new JudgeEntry(records, expanded, theme);
+	});
+}
+
+/** Early versions persisted one record per entry; now a turn's records share one. */
+export function toRecords(data: unknown): JudgeRecord[] {
+	const list = Array.isArray(data) ? data : [data];
+	return list.filter(isJudgeRecord);
+}
+
+function isJudgeRecord(value: unknown): value is JudgeRecord {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value as Partial<JudgeRecord>;
+	return typeof record.summary === "string" && typeof record.toolName === "string";
+}
+
+/**
+ * One entry per decision, written as soon as the judge answers. Waiting for
+ * the turn to end held the card back until after execution, so a parallel
+ * call hid every verdict behind the slowest command. The array shape is kept
+ * because sessions written before this grouped a turn's records into one.
+ */
+export function appendJudgeEntry(pi: ExtensionAPI, record: JudgeRecord): void {
+	pi.appendEntry(JUDGE_ENTRY, [record]);
+}
+
+class JudgeEntry implements Component {
+	constructor(
+		private readonly records: JudgeRecord[],
+		private readonly expanded: boolean,
+		private readonly theme: Theme,
+	) {}
+
+	invalidate(): void {}
+
+	/** A throw here kills the whole TUI, so a drifted entry degrades to a stub. */
+	render(width: number): string[] {
+		try {
+			return this.build(width);
+		} catch {
+			return [this.theme.fg("dim", `${NAME} \u00b7 judge \u00b7 unreadable entry`)];
+		}
+	}
+
+	private build(width: number): string[] {
+		const lines: string[] = [];
+		const columns = this.columns();
+
+		if (this.records.length > 1) {
+			lines.push(
+				this.theme.fg("accent", this.theme.bold(`${NAME} \u00b7 judge`)) +
+					this.theme.fg("dim", ` \u00b7 ${this.records.length} decisions`),
+			);
+		}
+
+		for (const record of this.records) {
+			lines.push(this.row(record, width, columns));
+			if (!this.expanded) continue;
+			lines.push(`    ${this.theme.fg("dim", record.reason)}`);
+			lines.push(`    ${this.theme.fg("dim", judgeSignalText(record))}`);
+		}
+
+		return lines;
+	}
+
+	/**
+	 * Widths come from this card's own records, so a lone `ask you` is not
+	 * charged for a `would ask you` that lives in someone else's card. The
+	 * extra column keeps at least one space before the next field: a tool
+	 * named `webfetch` used to run straight into its target.
+	 */
+	private columns(): Columns {
+		const action = Math.max(...this.records.map((r) => judgeActionLabel(r).length));
+		const tool = Math.max(...this.records.map((r) => r.toolName.length));
+		return { action: action + 1, tool: tool + 1 };
+	}
+
+	/** Stats hug the right edge, so the target uses whatever room is left. */
+	private row(record: JudgeRecord, width: number, columns: Columns): string {
+		const tone = toneFor(record);
+		const action = judgeActionLabel(record).padEnd(columns.action);
+		const tool = record.toolName.padEnd(columns.tool);
+		const stats = judgeStatText(record);
+
+		const head = `  \u25c8 ${action}${tool}`;
+		const room = width - visibleWidth(head) - visibleWidth(stats) - 1;
+		const target = truncateToWidth(flatten(record.summary), Math.max(MIN_TARGET, room), "...");
+		const gap = Math.max(
+			1,
+			width - visibleWidth(head) - visibleWidth(target) - visibleWidth(stats),
+		);
+
+		return (
+			`  ${this.theme.fg(tone, "\u25c8")} ` +
+			this.theme.fg(tone, action) +
+			this.theme.fg("muted", tool) +
+			this.theme.fg("text", target) +
+			" ".repeat(gap) +
+			this.theme.fg("dim", stats)
+		);
+	}
+}
+
+function toneFor(record: JudgeRecord): "success" | "error" | "warning" {
+	if (record.error) return "warning";
+	if (record.action === "allow") return "success";
+	if (record.action === "deny") return "error";
+	return "warning";
+}

package/src/ui/paste.ts

@@ -0,0 +1,27 @@
+export const PASTE_START = "\x1b[200~";
+export const PASTE_END = "\x1b[201~";
+
+const MARKER = /\[paste #(\d+)(?:\s[^\]]*)?\]/g;
+const MAX_CHARS = 1000;
+
+export function cleanPaste(text: string): string {
+	return text
+		.replace(/\r\n?/g, "\n")
+		.replace(/\t/g, "    ")
+		.split("")
+		.filter((char) => char === "\n" || char.charCodeAt(0) >= 32)
+		.join("");
+}
+
+export function shouldCollapse(text: string): boolean {
+	return text.includes("\n") || text.length > MAX_CHARS;
+}
+
+export function pasteMarker(id: number, text: string): string {
+	const lines = text.split("\n").length;
+	return lines > 1 ? `[paste #${id} +${lines} lines]` : `[paste #${id} ${text.length} chars]`;
+}
+
+export function expandPastes(text: string, pastes: Map<number, string>): string {
+	return text.replace(MARKER, (match, id: string) => pastes.get(Number(id)) ?? match);
+}

package/src/ui/picker.ts

@@ -0,0 +1,90 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import {
+	type Component,
+	Key,
+	matchesKey,
+	truncateToWidth,
+	wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+
+export interface PickerItem {
+	id: string;
+	label: string;
+	description?: string;
+}
+
+export class PickerList implements Component {
+	private selected: number;
+
+	constructor(
+		private readonly title: string,
+		private readonly items: PickerItem[],
+		private readonly theme: Theme,
+		private readonly onChoose: (id: string) => void,
+		private readonly onCancel: () => void,
+		private readonly maxVisible = 8,
+		selectedId?: string,
+	) {
+		const index = items.findIndex((item) => item.id === selectedId);
+		this.selected = index < 0 ? 0 : index;
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, Key.up)) {
+			this.selected = Math.max(0, this.selected - 1);
+			return;
+		}
+		if (matchesKey(data, Key.down)) {
+			this.selected = Math.min(this.items.length - 1, this.selected + 1);
+			return;
+		}
+		if (matchesKey(data, Key.enter)) {
+			const item = this.items[this.selected];
+			if (item) this.onChoose(item.id);
+			return;
+		}
+		if (matchesKey(data, Key.escape)) this.onCancel();
+	}
+
+	invalidate(): void {}
+
+	render(width: number): string[] {
+		const inner = Math.max(1, width - 4);
+		const lines: string[] = [this.theme.fg("accent", this.theme.bold(this.title))];
+
+		const { start, end } = this.window();
+		for (let index = start; index < end; index++) {
+			const item = this.items[index];
+			if (!item) continue;
+
+			const active = index === this.selected;
+			const marker = active ? this.theme.fg("accent", "\u276f ") : "  ";
+			const label = this.theme.fg(active ? "accent" : "text", item.label);
+			lines.push(truncateToWidth(`${marker}${label}`, inner));
+		}
+
+		if (end < this.items.length) {
+			lines.push(this.theme.fg("dim", `  \u2026 ${this.items.length - end} more`));
+		}
+
+		const description = this.items[this.selected]?.description;
+		if (description) {
+			lines.push("");
+			for (const line of wrapTextWithAnsi(description, inner)) {
+				lines.push(this.theme.fg("muted", line));
+			}
+		}
+
+		lines.push("");
+		lines.push(this.theme.fg("dim", "\u2191\u2193 pick   enter select   esc back"));
+		return lines;
+	}
+
+	private window(): { start: number; end: number } {
+		if (this.items.length <= this.maxVisible) return { start: 0, end: this.items.length };
+
+		const half = Math.floor(this.maxVisible / 2);
+		const start = Math.min(Math.max(0, this.selected - half), this.items.length - this.maxVisible);
+		return { start, end: start + this.maxVisible };
+	}
+}

package/src/ui/selector.ts

@@ -0,0 +1,42 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { type Scope, SCOPE_LABEL, SCOPES } from "#core/always-yes.ts";
+import type { DialogAnswer } from "#core/answer.ts";
+import type { CallDescriptor } from "#core/tools.ts";
+import { FALLBACK_CHOICES } from "#ui/decision-options.ts";
+
+export async function askViaSelector(
+	ctx: ExtensionContext,
+	toolName: string,
+	target: CallDescriptor,
+): Promise<DialogAnswer> {
+	const labels = FALLBACK_CHOICES.map((option) => `${option.key}. ${option.label}`);
+	const choice = await ctx.ui.select(`Allow ${toolName}?\n${target.summary}`, labels);
+	const option = choice ? FALLBACK_CHOICES[labels.indexOf(choice)] : undefined;
+	if (!option) return { decision: "deny" };
+
+	let remember: string | undefined;
+	let scope: Scope | undefined;
+	if (option.always) {
+		if (target.levels.length === 1) {
+			remember = target.levels[0];
+		} else {
+			const level = await ctx.ui.select("Always yes for...", target.levels);
+			if (!level) return { decision: "deny" };
+			remember = level;
+		}
+
+		const scopeLabels = SCOPES.map((candidate) => SCOPE_LABEL[candidate]);
+		const picked = await ctx.ui.select("Remember for...", scopeLabels);
+		if (!picked) return { decision: "deny" };
+		scope = SCOPES[scopeLabels.indexOf(picked)];
+	}
+
+	let note: string | undefined;
+	if (option.note) {
+		const prompt = option.decision === "allow" ? "Note to the agent:" : "Reason for the agent:";
+		note = (await ctx.ui.input(prompt))?.trim() || undefined;
+	}
+
+	return { decision: option.decision, note, remember, scope };
+}