@adeildo/pi-ask-permission 4.0.0 → 5.0.0

package/src/ui/dialog.ts

@@ -1,4 +1,4 @@
-import { renderDiff, type Theme } from "@earendil-works/pi-coding-agent";
+import { renderDiff, type Theme, type ToolAnnotations } from "@earendil-works/pi-coding-agent";
 import {
 	type Component,
 	type Focusable,
@@ -12,10 +12,11 @@ import {
 } 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 { DialogAnswer, FolderOffer } from "#core/answer.ts";
+import { describeHints, type McpCall } from "#core/mcp.ts";
 import type { CallDescriptor } from "#core/tools.ts";
 import { readClipboard } from "#ui/clipboard.ts";
-import { CHOICES, type Choice } from "#ui/decision-options.ts";
+import { type Choice, choicesFor, openLabel } from "#ui/decision-options.ts";
 import {
 	cleanPaste,
 	expandPastes,
@@ -39,7 +40,16 @@ interface AskDialogOptions {
 	theme: Theme;
 	toolName: string;
 	target: CallDescriptor;
+	/** Set for a call to an MCP server. */
+	mcp?: McpCall;
+	/** What the tool declares about itself, whatever registered it. */
+	hints?: ToolAnnotations;
+	/** Issued by another tool, as in a codemode script. */
+	nested?: boolean;
 	diff?: string;
+	/** Why the call asks, when a layer said. */
+	reason?: string;
+	offer?: FolderOffer;
 	keybindings: KeybindingsManager;
 	requestRender: () => void;
 	complete: (answer: DialogAnswer) => void;
@@ -47,9 +57,15 @@ interface AskDialogOptions {
 
 export class AskDialog implements Component, Focusable {
 	private readonly theme: Theme;
-	private readonly toolName: string;
+	private readonly title: string;
+	private readonly mcp: McpCall | undefined;
+	private readonly hints: ToolAnnotations;
+	private readonly nested: boolean;
 	private readonly target: CallDescriptor;
 	private readonly diff: string | undefined;
+	private readonly reason: string | undefined;
+	private readonly offer: FolderOffer | undefined;
+	private readonly choices: Choice[];
 	private readonly requestRender: () => void;
 	private readonly complete: (answer: DialogAnswer) => void;
 	private readonly keybindings: KeybindingsManager;
@@ -66,6 +82,8 @@ export class AskDialog implements Component, Focusable {
 	private scopeIndex = 0;
 	private pending: Choice | null = null;
 	private noteIndex: number | null = null;
+	private folderIndex = 0;
+	private openScope: "session" | "project" = "session";
 
 	private pendingNote: string | undefined;
 
@@ -84,14 +102,23 @@ export class AskDialog implements Component, Focusable {
 
 	constructor(options: AskDialogOptions) {
 		this.theme = options.theme;
-		this.toolName = options.toolName;
+		this.title = options.mcp ? `${options.mcp.server}:${options.mcp.tool}` : options.toolName;
+		this.mcp = options.mcp;
+		this.hints = options.hints ?? {};
+		this.nested = options.nested === true;
 		this.target = options.target;
 		this.diff = options.diff;
+		this.reason = options.reason;
+		this.offer = options.offer;
+		this.choices = choicesFor(options.offer);
+		this.folderIndex = options.offer?.suggested ?? 0;
+		// Reading a sibling folder is the common case, so its answer is where the cursor starts.
+		if (options.offer?.access === "read") this.selected = 1;
 		this.requestRender = options.requestRender;
 		this.complete = options.complete;
 		this.keybindings = options.keybindings;
 
-		this.noteInputs = [...CHOICES.keys()].map((index) => {
+		this.noteInputs = [...this.choices.keys()].map((index) => {
 			const input = new Input({ prompt: "", placeholder: "" });
 			input.onSubmit = () => this.choose(index);
 			input.onEscape = () => {
@@ -115,27 +142,25 @@ export class AskDialog implements Component, Focusable {
 
 	render(width: number): string[] {
 		const inner = Math.max(1, width - 4);
-		const lines: string[] = [...this.summaryLines(inner), ...this.diffLines()];
+		const lines: string[] = [
+			...this.summaryLines(inner),
+			...this.sourceLines(),
+			...this.reasonLines(),
+			...this.diffLines(),
+		];
 		lines.push("");
 
 		if (this.phase === "levels") {
 			lines.push(...this.levelLines());
 		} else {
-			for (const [index, option] of CHOICES.entries()) {
+			for (const [index, option] of this.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",
-				),
-			);
+			lines.push(this.theme.fg("dim", this.hint()));
 		}
 
-		return this.frame(lines, width, inner, `permission \u00b7 ${this.toolName}`);
+		return this.frame(lines, width, inner, this.title);
 	}
 
 	private dispatch(data: string): void {
@@ -177,13 +202,51 @@ export class AskDialog implements Component, Focusable {
 			this.complete({ decision: "deny" });
 			return;
 		}
+		if (this.onOpenChoice && this.adjustFolder(data)) return;
 
-		const picked = CHOICES.findIndex((option) => option.key === data);
+		const picked = this.choices.findIndex((option) => option.key === data);
 		if (picked >= 0) this.selected = picked;
 	}
 
+	private get folder(): string | undefined {
+		return this.offer?.folders[this.folderIndex];
+	}
+
+	private get onOpenChoice(): boolean {
+		return this.choices[this.selected]?.open === true;
+	}
+
+	// Left goes up toward the root, right back down toward the paths.
+	private adjustFolder(data: string): boolean {
+		const last = (this.offer?.folders.length ?? 1) - 1;
+		if (matchesKey(data, Key.left)) {
+			this.folderIndex = Math.max(0, this.folderIndex - 1);
+			return true;
+		}
+		if (matchesKey(data, Key.right)) {
+			this.folderIndex = Math.min(last, this.folderIndex + 1);
+			return true;
+		}
+		if (data === "s") {
+			this.openScope = this.openScope === "session" ? "project" : "session";
+			return true;
+		}
+		return false;
+	}
+
+	private hint(): string {
+		if (this.noteIndex !== null) return "\u2191\u2193 pick   enter confirm   esc back";
+
+		const pick = `\u2191\u2193 or 1-${this.choices.length} pick`;
+		if (!this.onOpenChoice) return `${pick}   enter confirm   tab note   esc deny`;
+
+		const folders = (this.offer?.folders.length ?? 0) > 1 ? "\u2190\u2192 folder   " : "";
+		const scope = this.openScope === "session" ? "keep for this project" : "only this session";
+		return `${folders}s ${scope}   tab note   esc deny`;
+	}
+
 	private moveSelection(delta: number): void {
-		const count = CHOICES.length;
+		const count = this.choices.length;
 		this.selected = (this.selected + delta + count) % count;
 	}
 
@@ -194,10 +257,20 @@ export class AskDialog implements Component, Focusable {
 	}
 
 	private choose(index: number): void {
-		const option = CHOICES[index];
+		const option = this.choices[index];
 		if (!option) return;
 		this.selected = index;
 
+		const folder = this.folder;
+		if (option.open && this.offer && folder !== undefined) {
+			this.complete({
+				decision: "allow",
+				note: this.draftNote(),
+				open: { path: folder, access: this.offer.access, scope: this.openScope },
+			});
+			return;
+		}
+
 		if (option.always) {
 			this.pending = option;
 			this.pendingNote = this.draftNote();
@@ -327,13 +400,15 @@ export class AskDialog implements Component, Focusable {
 		const marker = active ? this.theme.fg("accent", "\u276f ") : "  ";
 		const key = this.theme.fg(active ? "accent" : "dim", option.key);
 		const prefix = `${marker}${key}  `;
+		const text = this.labelOf(option);
 
 		if (!editing && !draft) {
-			return `${prefix}${this.theme.fg(active ? option.tone : "text", option.label)}`;
+			const head = this.theme.fg(active ? option.tone : "text", text);
+			return truncateToWidth(`${prefix}${head}${this.openTags(option, active)}`, inner);
 		}
 
 		const room = Math.max(1, inner - visibleWidth(prefix));
-		const label = truncateToWidth(`${option.label}, `, room);
+		const label = truncateToWidth(`${text}, `, room);
 		const noteRoom = Math.max(1, room - visibleWidth(label));
 		const note = editing
 			? (input?.render(noteRoom)[0] ?? "")
@@ -342,6 +417,38 @@ export class AskDialog implements Component, Focusable {
 		return truncateToWidth(`${prefix}${head}${note}`, inner);
 	}
 
+	private labelOf(option: Choice): string {
+		const folder = this.folder;
+		if (!option.open || !this.offer || folder === undefined) return option.label;
+		return openLabel(this.offer, folder);
+	}
+
+	// The scope shows only when it is not the default, and the repo tag only on the focused row.
+	private openTags(option: Choice, active: boolean): string {
+		if (!option.open || !this.offer) return "";
+		const tags: string[] = [];
+		if (this.openScope === "project") tags.push(this.theme.fg("accent", "for this project"));
+		if (active && this.folder !== undefined && this.folder === this.offer.repoRoot)
+			tags.push(this.theme.fg("dim", "repo root"));
+		return tags.length === 0 ? "" : `  ${tags.join("  ")}`;
+	}
+
+	// Where the call comes from, when that is worth saying: the server's own hint about the tool, and
+	// the script that issued it.
+	private sourceLines(): string[] {
+		const parts: string[] = [];
+		if (this.mcp) parts.push(`${this.mcp.server}: ${describeHints(this.hints)}`);
+		if (this.nested) parts.push("from a codemode script");
+		return parts.length === 0 ? [] : [this.theme.fg("dim", parts.join("   "))];
+	}
+
+	private reasonLines(): string[] {
+		let text = this.reason;
+		if (this.offer?.access === "read") text = "reads outside the workspace";
+		if (this.offer?.access === "write") text = "writes outside the workspace";
+		return text === undefined ? [] : [this.theme.fg("warning", `\u25b2 ${text}`)];
+	}
+
 	private diffLines(): string[] {
 		if (!this.diff) return [];
 
@@ -383,7 +490,12 @@ export class AskDialog implements Component, Focusable {
 
 	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), "..."));
+		// The colour tells the dialog from the call, so the two words need nothing between them.
+		const label = truncateToWidth(
+			this.theme.fg("muted", "permission ") + this.theme.fg("accent", title),
+			Math.max(0, room - 3),
+			"...",
+		);
 		const dashes = Math.max(0, room - visibleWidth(label));
 
 		return (

package/src/ui/judge-entry.ts

@@ -23,7 +23,7 @@ export function registerJudgeEntry(scope: FeatureScope): void {
 	});
 }
 
-/** Early versions persisted one record per entry; now a turn's records share one. */
+/** Old sessions hold one record per entry, newer ones an array. */
 export function toRecords(data: unknown): JudgeRecord[] {
 	const list = Array.isArray(data) ? data : [data];
 	return list.filter(isJudgeRecord);
@@ -35,12 +35,7 @@ function isJudgeRecord(value: unknown): value is 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.
- */
+/** Written when the judge answers, so the card shows before the call runs. */
 export function appendJudgeEntry(pi: ExtensionAPI, record: JudgeRecord): void {
 	pi.appendEntry(JUDGE_ENTRY, [record]);
 }
@@ -59,7 +54,7 @@ class JudgeEntry implements Component {
 		try {
 			return this.build(width);
 		} catch {
-			return [this.theme.fg("dim", `${NAME} \u00b7 judge \u00b7 unreadable entry`)];
+			return [this.theme.fg("dim", `${NAME} judge: unreadable entry`)];
 		}
 	}
 
@@ -69,8 +64,8 @@ class JudgeEntry implements Component {
 
 		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`),
+				this.theme.fg("accent", this.theme.bold(`${NAME} judge`)) +
+					this.theme.fg("dim", `  ${this.records.length} decisions`),
 			);
 		}
 
@@ -84,12 +79,7 @@ class JudgeEntry implements Component {
 		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.
-	 */
+	/** From this card's records only, plus one column so a field never touches the next. */
 	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));

package/src/ui/questions.ts

@@ -0,0 +1,170 @@
+// The permission ask, drawn by the questions feature so both dialogs are the same one. The call
+// becomes a question, and the answer becomes the decision the gate already knows how to apply.
+import { type AskAnswer, type AskOption, type AskQuestion, askQuestions } from "@adeildo/pi-kit";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { SCOPE_LABEL, SCOPES, type Scope } from "#core/always-yes.ts";
+import type { DialogAnswer, FolderOffer } from "#core/answer.ts";
+import type { Call } from "#core/decide.ts";
+import { describeHints } from "#core/mcp.ts";
+import { openLabel } from "#ui/decision-options.ts";
+
+const YES = "yes, run it";
+const ALWAYS = "always yes";
+const DENY = "no";
+
+export interface AskExtras {
+	diff?: string;
+	reason?: string;
+	offer?: FolderOffer;
+}
+
+/** Undefined when the questions feature is not there to draw, or failed: the caller falls back. */
+export async function askThroughQuestions(
+	events: ExtensionAPI["events"],
+	call: Call,
+	extras: AskExtras,
+): Promise<DialogAnswer | undefined> {
+	const first = await askQuestions(events, [firstQuestion(call, extras)]);
+	if (first.error !== undefined) return undefined;
+	if (first.cancelled) return { decision: "deny" };
+
+	const answer = first.answers[0];
+	const note = noteOf(answer);
+	// A typed answer instead of a pick: the user is telling the model what to do instead.
+	if (answer === undefined || answer.picked.length === 0) return { decision: "deny", note };
+
+	const picked = answer.picked[0] ?? "";
+	if (picked === DENY) return { decision: "deny", note };
+	if (picked === ALWAYS) return remember(events, call, note);
+
+	const folder = folderOf(extras.offer, picked);
+	if (folder === undefined) return { decision: "allow", note };
+	const scope = await askScope(events, "Open the folder for how long?");
+	return { decision: "allow", note, open: { path: folder, access: extras.offer!.access, scope } };
+}
+
+function firstQuestion(call: Call, extras: AskExtras): AskQuestion {
+	const options: AskOption[] = [
+		{ label: YES, description: "Run this call now, and ask again next time." },
+		...(levelsOf(call).length > 0
+			? [
+					{
+						label: ALWAYS,
+						description: "Run this call, and stop asking for the calls you pick next.",
+					},
+				]
+			: []),
+		...offerOptions(extras.offer),
+		{ label: DENY, description: "Block it. Anything you type becomes the reason the model reads." },
+	];
+
+	// Every option offers the same preview, whichever row the cursor is on.
+	if (extras.diff !== undefined) for (const option of options) option.preview = extras.diff;
+
+	return { header: "permission", question: questionText(call, extras.reason), options };
+}
+
+function offerOptions(offer: FolderOffer | undefined): { label: string; description: string }[] {
+	if (offer === undefined) return [];
+	const reads = offer.access === "read";
+	return [
+		{
+			label: openLabel(offer, offer.folders[offer.suggested] ?? ""),
+			description: reads
+				? "Run it, and let later calls read there without asking."
+				: "Run it, and treat that folder as part of the workspace.",
+		},
+	];
+}
+
+function questionText(call: Call, reason: string | undefined): string {
+	const lines = [`${whereOf(call)} wants to run:`, "", `  ${call.target.summary}`];
+	if (reason !== undefined) lines.push("", `\u25b2 ${reason}`);
+	return lines.join("\n");
+}
+
+// The tool name, plus what it does not say: the server behind an MCP tool and what it declares, and
+// a call a script issued rather than the model.
+function whereOf(call: Call): string {
+	const parts: string[] = [];
+	if (call.mcp !== undefined)
+		parts.push(`${call.mcp.server}:${call.mcp.tool} (${describeHints(call.hints)})`);
+	else parts.push(call.toolName);
+	if (call.nested) parts.push("(from a codemode script)");
+	return parts.join(" ");
+}
+
+function levelsOf(call: Call): string[] {
+	return [...call.target.levels].toReversed();
+}
+
+/** The always-yes path: which calls to remember, then for how long. */
+async function remember(
+	events: ExtensionAPI["events"],
+	call: Call,
+	note: string | undefined,
+): Promise<DialogAnswer | undefined> {
+	const levels = levelsOf(call);
+	if (levels.length === 0) return { decision: "allow", note };
+
+	const picked = await askQuestions(events, [
+		{
+			header: "remember",
+			question: `Always say yes to which calls, from ${call.toolName}?`,
+			options: levels.map((level, index) => ({
+				label: level,
+				description:
+					index === 0
+						? "Only this exact call."
+						: "This call, and anything else that starts with it.",
+			})),
+		},
+	]);
+	if (picked.error !== undefined || picked.cancelled) return { decision: "allow", note };
+
+	const level = picked.answers[0]?.picked[0];
+	if (level === undefined || level === "") return { decision: "allow", note };
+	const scope = await askScope(events, "Remember it for how long?");
+	return { decision: "allow", note, remember: level, scope };
+}
+
+async function askScope(events: ExtensionAPI["events"], question: string): Promise<Scope> {
+	const result = await askQuestions(events, [
+		{
+			header: "where",
+			question,
+			options: SCOPES.map((scope) => ({
+				label: SCOPE_LABEL[scope],
+				description:
+					scope === "session"
+						? "Gone when this session ends."
+						: scope === "project"
+							? "Saved for this project, in its own file."
+							: "Saved for every project.",
+			})),
+		},
+	]);
+	const picked = result.answers[0]?.picked[0];
+	const scope = SCOPES.find((candidate) => SCOPE_LABEL[candidate] === picked);
+	return scope ?? "session";
+}
+
+function folderOf(offer: FolderOffer | undefined, picked: string): string | undefined {
+	if (offer === undefined) return undefined;
+	return offer.folders.find((folder) => openLabel(offer, folder) === picked);
+}
+
+/** Every note the user left, the picked option's first. */
+function noteOf(answer: AskAnswer | undefined): string | undefined {
+	if (answer === undefined) return undefined;
+	const parts: string[] = [];
+	const picked = answer.notes.find((note) => answer.picked.includes(note.option));
+	if (picked !== undefined) parts.push(picked.note);
+	for (const note of answer.notes)
+		if (!answer.picked.includes(note.option)) parts.push(`on "${note.option}": ${note.note}`);
+	const typed = answer.typed?.trim();
+	if (typed !== undefined && typed !== "") parts.push(typed);
+
+	return parts.length === 0 ? undefined : parts.join("\n");
+}

package/src/ui/selector.ts

@@ -1,20 +1,28 @@
 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 { DialogAnswer, FolderOffer } from "#core/answer.ts";
 import type { CallDescriptor } from "#core/tools.ts";
-import { FALLBACK_CHOICES } from "#ui/decision-options.ts";
+import { fallbackChoices } from "#ui/decision-options.ts";
 
 export async function askViaSelector(
 	ctx: ExtensionContext,
 	toolName: string,
 	target: CallDescriptor,
+	offer?: FolderOffer,
 ): Promise<DialogAnswer> {
-	const labels = FALLBACK_CHOICES.map((option) => `${option.key}. ${option.label}`);
+	const choices = fallbackChoices(offer);
+	const labels = 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;
+	const option = choice ? choices[labels.indexOf(choice)] : undefined;
 	if (!option) return { decision: "deny" };
 
+	const folder = offer?.folders[offer.suggested];
+	const open =
+		option.open && offer && folder !== undefined
+			? { path: folder, access: offer.access, scope: "session" as const }
+			: undefined;
+
 	let remember: string | undefined;
 	let scope: Scope | undefined;
 	if (option.always) {
@@ -38,5 +46,5 @@ export async function askViaSelector(
 		note = (await ctx.ui.input(prompt))?.trim() || undefined;
 	}
 
-	return { decision: option.decision, note, remember, scope };
+	return { decision: option.decision, note, remember, scope, open };
 }

package/src/ui/picker.ts

@@ -1,90 +0,0 @@
-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 };
-	}
-}