gentle-pi 2.4.0 → 2.6.0

package/extensions/ask-user-choice.ts

@@ -1,7 +1,9 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { DynamicBorder } from "@earendil-works/pi-coding-agent";
-import { Container, type SelectItem, SelectList, Text } from "@earendil-works/pi-tui";
+import { Container, Input, isKeyRelease, matchesKey, Text, type KeybindingsManager, type TuiMouseEvent } from "@earendil-works/pi-tui";
 import { type Static, Type } from "typebox";
+import { NativeChoiceList } from "../lib/native-choice-list.ts";
+import { createNativeFullscreenInteraction } from "../lib/native-fullscreen-interaction.ts";
 
 const CHOICE_TOOL_NAME = "ask_user_choice";
 const ASK_USER_CHOICE_BLOCKED_EVENT = "gentle-pi:ask-user-choice:blocked";
@@ -23,6 +25,9 @@ const ChoiceParamsSchema = Type.Object(
 			maxItems: 4,
 			description: "Two to four ordered closed options",
 		}),
+		allowCustomResponse: Type.Optional(Type.Boolean({
+			description: "Opt in to an Other… free-text response. Never enable for provider-owned consent prompts, maintenance authorizations, or any exact opaque-token decision.",
+		})),
 	},
 	{ additionalProperties: false },
 );
@@ -40,9 +45,108 @@ interface ChoiceDetails {
 	question: string;
 	options: ChoiceOption[];
 	selection?: ChoiceSelection;
+	customResponse?: string;
 	cancelled?: true;
 }
 
+type ChoiceResult = ChoiceSelection | { customResponse: string };
+
+class CustomResponseEditor extends Container {
+	private readonly input = new Input({ prompt: "> ", placeholder: "Type your response" });
+	private readonly validationText = new Text("", 1, 0);
+	private readonly keybindings: KeybindingsManager | undefined;
+	private readonly onSubmit: (value: string) => void;
+	private readonly onCancel: () => void;
+
+	constructor(
+		keybindings: KeybindingsManager | undefined,
+		onSubmit: (value: string) => void,
+		onCancel: () => void,
+	) {
+		super();
+		this.keybindings = keybindings;
+		this.onSubmit = onSubmit;
+		this.onCancel = onCancel;
+		this.input.focused = true;
+		this.addChild(new Text("Custom response", 1, 0));
+		this.addChild(this.input);
+		this.addChild(this.validationText);
+		this.addChild(new Text("Submit to continue • Cancel to return to choices", 1, 0));
+	}
+
+	handleInput(data: string): void {
+		if (isKeyRelease(data)) return;
+		if (this.matches(data, "tui.select.cancel")) {
+			this.onCancel();
+			return;
+		}
+		if (this.matches(data, "tui.input.submit")) {
+			const value = this.input.getValue();
+			if (value.trim().length > 0) this.onSubmit(value);
+			else this.validationText.setText("Response cannot be empty.");
+			this.invalidate();
+			return;
+		}
+		if (this.matches(data, "tui.editor.deleteCharBackward")) {
+			this.input.handleInput(data);
+			this.validationText.setText("");
+			this.invalidate();
+			return;
+		}
+		this.input.handleInput(data);
+		this.validationText.setText("");
+		this.invalidate();
+	}
+
+	private matches(
+		data: string,
+		binding: "tui.select.cancel" | "tui.input.submit" | "tui.editor.deleteCharBackward",
+	): boolean {
+		if (this.keybindings?.matches) return this.keybindings.matches(data, binding);
+		const key = binding === "tui.select.cancel" ? "escape"
+			: binding === "tui.input.submit" ? "enter" : "backspace";
+		return matchesKey(data, key);
+	}
+}
+
+class ChoiceModeView extends Container {
+	private editing = false;
+	private readonly list: NativeChoiceList<{ id: string; label: string; description: string }>;
+	private readonly editor: CustomResponseEditor;
+
+	constructor(
+		list: NativeChoiceList<{ id: string; label: string; description: string }>,
+		editor: CustomResponseEditor,
+	) {
+		super();
+		this.list = list;
+		this.editor = editor;
+	}
+
+	showEditor(): void {
+		this.editing = true;
+		this.invalidate();
+	}
+
+	showList(): void {
+		this.editing = false;
+		this.invalidate();
+	}
+
+	handleInput(data: string): void {
+		if (this.editing) this.editor.handleInput(data);
+		else this.list.handleInput(data);
+	}
+
+	override handleMouse(event: TuiMouseEvent) {
+		return this.editing ? undefined : this.list.handleMouse(event);
+	}
+
+	override render(width: number): string[] {
+		return (this.editing ? this.editor : this.list).render(width);
+	}
+}
+
 function reconcileToolAvailability(pi: ExtensionAPI, interactiveTui: boolean): void {
 	const active = pi.getActiveTools();
 	const isActive = active.includes(CHOICE_TOOL_NAME);
@@ -60,10 +164,12 @@ function resultDetails(params: ChoiceParams): ChoiceDetails {
 export default function askUserChoice(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: CHOICE_TOOL_NAME,
+		renderShell: "self",
 		label: "Ask User Choice",
-		description: "Ask one strictly closed single-select question with two to four ordered options. It never accepts free-text or multiple selections.",
+		description: "Ask one single-select question with two to four ordered options. A custom response is available only when allowCustomResponse is explicitly enabled.",
 		promptGuidelines: [
-			"Use ask_user_choice only for one exactly representable closed single-select question with 2-4 ordered options; never use it for free-text or multi-select input.",
+			"Use ask_user_choice only for one exactly representable single-select question with 2-4 ordered options. Enable allowCustomResponse only when free text is safe and intended.",
+			"Never enable allowCustomResponse for provider-owned consent prompts, maintenance authorizations, or any decision that requires an exact opaque token.",
 		],
 		parameters: ChoiceParamsSchema,
 		executionMode: "sequential",
@@ -72,41 +178,62 @@ export default function askUserChoice(pi: ExtensionAPI): void {
 				throw new Error("ask_user_choice is unavailable outside the interactive TUI");
 			}
 
-			const items: SelectItem[] = params.options.map((option) => ({
-				value: option.value,
+			const items = params.options.map((option, index) => ({
+				id: `choice-${index}`,
 				label: option.label,
 				description: option.description,
 			}));
-			let selection: ChoiceSelection | undefined;
+			const customItemId = "choice-custom-response";
+			if (params.allowCustomResponse === true) {
+				items.push({ id: customItemId, label: "Other…", description: "Provide a custom response" });
+			}
+			let selection: ChoiceResult | undefined;
 			try {
 				pi.events.emit(ASK_USER_CHOICE_BLOCKED_EVENT, { active: true });
-				selection = await ctx.ui.custom<ChoiceSelection | undefined>((tui, theme, _keybindings, done) => {
-					const container = new Container();
-					container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
-					container.addChild(new Text(theme.fg("accent", theme.bold(params.question)), 1, 0));
-					const list = new SelectList(items, items.length, {
+				selection = await ctx.ui.custom<ChoiceResult | undefined>((tui, theme, keybindings, done) => {
+					const list = new NativeChoiceList(items, {
 						selectedPrefix: (text) => theme.fg("accent", text),
 						selectedText: (text) => theme.fg("accent", text),
 						description: (text) => theme.fg("muted", text),
-						scrollInfo: (text) => theme.fg("dim", text),
-						noMatch: (text) => theme.fg("warning", text),
+						hoverBackground: (text) => theme.bg("toolPendingBg", text),
+					}, keybindings);
+					let completed = false;
+					const finish = (result: ChoiceResult | undefined) => {
+						if (completed) return;
+						completed = true;
+						list.setDisabled(true);
+						done(result);
+					};
+					let view: ChoiceModeView;
+					const editor = new CustomResponseEditor(
+						keybindings,
+						(value) => finish({ customResponse: value }),
+						() => view.showList(),
+					);
+					view = new ChoiceModeView(list, editor);
+					const container = createNativeFullscreenInteraction({
+						keyboardTarget: view,
+						requestRender: () => tui.requestRender(),
+						mouseObserver: list.createMouseObserver(() => tui.requestRender()),
 					});
 					list.onSelect = (item) => {
-						const index = items.indexOf(item);
-						done({ value: item.value, label: item.label, index: index + 1 });
+						if (item.id === customItemId) {
+							view.showEditor();
+							tui.requestRender();
+						}
+						else {
+							const index = items.indexOf(item);
+							const option = params.options[index];
+							if (option) finish({ value: option.value, label: option.label, index: index + 1 });
+						}
 					};
-					list.onCancel = () => done(undefined);
-					container.addChild(list);
+					list.onCancel = () => finish(undefined);
+					container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
+					container.addChild(new Text(theme.fg("accent", theme.bold(params.question)), 1, 0));
+					container.addChild(view);
 					container.addChild(new Text(theme.fg("dim", "↑↓ navigate • Enter select • Esc cancel"), 1, 0));
 					container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
-					return {
-						render: (width) => container.render(width),
-						invalidate: () => container.invalidate(),
-						handleInput: (data) => {
-							list.handleInput(data);
-							tui.requestRender();
-						},
-					};
+					return container;
 				});
 			} finally {
 				pi.events.emit(ASK_USER_CHOICE_BLOCKED_EVENT, { active: false });
@@ -118,6 +245,12 @@ export default function askUserChoice(pi: ExtensionAPI): void {
 					details: { ...resultDetails(params), cancelled: true },
 				};
 			}
+			if ("customResponse" in selection) {
+				return {
+					content: [{ type: "text", text: `User responded: ${selection.customResponse}` }],
+					details: { ...resultDetails(params), customResponse: selection.customResponse },
+				};
+			}
 			return {
 				content: [{ type: "text", text: `User selected: ${selection.index}. ${selection.label} (value: ${selection.value})` }],
 				details: { ...resultDetails(params), selection },
@@ -141,6 +274,7 @@ export default function askUserChoice(pi: ExtensionAPI): void {
 			if (details?.selection) {
 				return new Text(theme.fg("success", `✓ ${details.selection.index}. ${details.selection.label}`), 0, 0);
 			}
+			if (details?.customResponse !== undefined) return new Text(theme.fg("success", "✓ Custom response"), 0, 0);
 			return new Text(theme.fg("warning", "Cancelled"), 0, 0);
 		},
 	});

package/extensions/codegraph-tools.ts

@@ -1,7 +1,7 @@
 import { execFile, execFileSync } from "node:child_process";
-import { lstatSync, realpathSync } from "node:fs";
+import { existsSync, lstatSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { promisify } from "node:util";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 
@@ -177,18 +177,108 @@ function codeGraphFailureMessage(status: CodeGraphStatus): string {
 		: `CodeGraph failed to run. ${FALLBACK_INSTRUCTIONS}`;
 }
 
+function isEnoent(error: unknown): boolean {
+	return (
+		typeof error === "object" &&
+		error !== null &&
+		"code" in error &&
+		(error as { code?: unknown }).code === "ENOENT"
+	);
+}
+
+/** Find `codegraph.cmd` shims in Windows PATH order. */
+function* codeGraphCmdPathsOnPath(): Iterable<string> {
+	const pathEnv = process.env.Path ?? process.env.PATH ?? "";
+	for (const entry of pathEnv.split(";")) {
+		const dir = entry.length >= 2 && entry.startsWith('"') && entry.endsWith('"')
+			? entry.slice(1, -1)
+			: entry;
+		if (!dir) continue;
+		const candidate = join(dir, "codegraph.cmd");
+		if (existsSync(candidate)) yield candidate;
+	}
+}
+
+/**
+ * Resolve the actual JS entry of the `@colbymchenry/codegraph` package from the
+ * npm global bin dir (sibling of the `codegraph.cmd` shim) and run it with the
+ * current Node executable. No shell involvement, so args are never interpreted.
+ */
+export function codeGraphNodeScript(cmdPath: string): string | undefined {
+	const binDir = dirname(cmdPath);
+	const pkgRoot = join(binDir, "node_modules", "@colbymchenry", "codegraph");
+	const pkgJsonPath = join(pkgRoot, "package.json");
+	if (!existsSync(pkgJsonPath)) return undefined;
+	try {
+		const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf8")) as { bin?: unknown };
+		const bin = pkg.bin;
+		const target =
+			typeof bin === "string"
+				? bin
+				: bin &&
+						typeof bin === "object" &&
+						"codegraph" in bin &&
+						typeof (bin as Record<string, unknown>).codegraph === "string"
+					? (bin as Record<string, string>).codegraph
+					: undefined;
+		if (typeof target !== "string" || !target) return undefined;
+		const script = join(pkgRoot, target);
+		return statSync(script).isFile() ? script : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function* codeGraphNodeScriptsOnPath(): Iterable<string> {
+	for (const cmdPath of codeGraphCmdPathsOnPath()) {
+		const script = codeGraphNodeScript(cmdPath);
+		if (script) yield script;
+	}
+}
+
+/** Resolve the first valid CodeGraph npm entry point in Windows PATH order. */
+export function findCodeGraphNodeScriptOnPath(): string | undefined {
+	return codeGraphNodeScriptsOnPath().next().value;
+}
+
 const runCodeGraphCommand: CodeGraphRunner = async (args, options) => {
-	const result = await execFileAsync("codegraph", [...args], {
+	const runOptions = {
 		cwd: options.cwd,
 		signal: options.signal,
 		maxBuffer: options.maxBuffer,
-	});
-	return { stdout: result.stdout, stderr: result.stderr };
+	};
+	let unavailableError: unknown;
+
+	try {
+		const result = await execFileAsync("codegraph", [...args], runOptions);
+		return { stdout: result.stdout, stderr: result.stderr };
+	} catch (error) {
+		// Windows npm installs only shims (codegraph.cmd/.ps1 and a shell script)
+		// with no codegraph.exe, so plain execFile (CreateProcess, no shell)
+		// always fails with ENOENT even when the shim is on PATH.
+		if (process.platform !== "win32" || !isEnoent(error)) throw error;
+		unavailableError = error;
+	}
+
+	// Resolve the real package script from each npm global bin directory in PATH
+	// order and run it through the current Node executable. This remains
+	// shell-free, so argument boundaries are never interpreted by a shell.
+	for (const script of codeGraphNodeScriptsOnPath()) {
+		try {
+			const result = await execFileAsync(process.execPath, [script, ...args], runOptions);
+			return { stdout: result.stdout, stderr: result.stderr };
+		} catch (innerError) {
+			if (!isEnoent(innerError)) throw innerError;
+		}
+	}
+
+	throw unavailableError;
 };
 
 export function createCodeGraphTool(runner: CodeGraphRunner = runCodeGraphCommand) {
 	return {
 		name: "codegraph",
+		renderShell: "self" as const,
 		label: "CodeGraph",
 		description:
 			"Initialize, search, or explore the CodeGraph index for the current Pi workspace only. This tool never accepts a project path or shell command.",