@underactive/pi-topping-moa-fusion 0.1.0

package/src/ui/opinionModelPicker.ts

@@ -0,0 +1,246 @@
+import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { Key, matchesKey, visibleWidth, type Component, type TUI } from "@earendil-works/pi-tui";
+import { loadMoaConfig, type MoaConfig } from "../config/settings.ts";
+import { modelRefLabel, type ModelRef, type ThinkingLevel } from "../shared/modelRefs.ts";
+import {
+	SELECTOR_POINTER,
+	SQUARE_SINGLE_BOX,
+	UNSELECTED_POINTER,
+	createFrame,
+	ratioViewport,
+} from "./chrome.ts";
+import { getAvailableModelRefs } from "./moaModelPicker.ts";
+import { smartTruncateModelLabel } from "./modelLabel.ts";
+import { TwoPaneModelThinking } from "./twoPaneModelThinking.ts";
+
+const HINT_BASE = "type filters models • ↑↓ navigate pane • tab panes/buttons • ←→ switch/select • enter select";
+
+export const MAX_OPINION_MODELS = 5;
+export const MIN_OPINION_MODELS = 1;
+export const START_ROW = MAX_OPINION_MODELS;
+export const OVERVIEW_ROW_COUNT = MAX_OPINION_MODELS + 1;
+const OVERVIEW_SCREEN = 0;
+const SLOT_TITLES = ["Opinion 1", "Opinion 2", "Opinion 3", "Opinion 4", "Opinion 5"];
+
+export interface OpinionPickerResult {
+	models: ModelRef[];
+	thinking: (ThinkingLevel | undefined)[];
+	thinkingSelections: Record<string, ThinkingLevel>;
+}
+
+export class OpinionModelPickerComponent implements Component {
+	private screen = OVERVIEW_SCREEN;
+	private overviewIndex = 0;
+	private readonly refs: (ModelRef | undefined)[] = Array.from({ length: MAX_OPINION_MODELS }, () => undefined);
+	private readonly thinking: (ThinkingLevel | undefined)[] = Array.from({ length: MAX_OPINION_MODELS }, () => undefined);
+	private readonly thinkingSelections: Record<string, ThinkingLevel> = {};
+	private readonly tui: TUI;
+	private readonly theme: Theme;
+	private readonly defaults: (ModelRef | undefined)[];
+	private readonly done: (result: OpinionPickerResult | undefined) => void;
+	private readonly twoPane: TwoPaneModelThinking;
+
+	constructor(
+		tui: TUI,
+		theme: Theme,
+		availableRefs: ModelRef[],
+		defaults: (ModelRef | undefined)[],
+		config: MoaConfig,
+		currentThinking: ThinkingLevel,
+		ctx: ExtensionContext,
+		done: (result: OpinionPickerResult | undefined) => void,
+	) {
+		this.tui = tui;
+		this.theme = theme;
+		this.defaults = defaults;
+		this.done = done;
+		this.twoPane = new TwoPaneModelThinking(tui, theme, availableRefs, config, currentThinking, ctx);
+	}
+
+	private assignedCount(): number {
+		return this.refs.reduce((count, ref) => count + (ref ? 1 : 0), 0);
+	}
+
+	private isReady(): boolean {
+		return this.assignedCount() >= MIN_OPINION_MODELS;
+	}
+
+	private openSlot(slot: number): void {
+		const committed = this.refs[slot];
+		if (committed) this.twoPane.reset(committed, this.thinking[slot]);
+		else this.twoPane.reset(this.defaults[slot]);
+		this.screen = slot + 1;
+		this.tui.requestRender();
+	}
+
+	private commitSlot(selection: { ref: ModelRef; thinking: ThinkingLevel }): void {
+		const slot = this.screen - 1;
+		this.refs[slot] = selection.ref;
+		this.thinking[slot] = selection.thinking;
+		this.thinkingSelections[modelRefLabel(selection.ref)] = selection.thinking;
+		this.screen = OVERVIEW_SCREEN;
+		this.tui.requestRender();
+	}
+
+	finish(): void {
+		if (!this.isReady()) return;
+		const models: ModelRef[] = [];
+		const thinking: (ThinkingLevel | undefined)[] = [];
+		for (let index = 0; index < MAX_OPINION_MODELS; index++) {
+			const ref = this.refs[index];
+			if (!ref) continue;
+			models.push(ref);
+			thinking.push(this.thinking[index]);
+		}
+		this.done({ models, thinking, thinkingSelections: { ...this.thinkingSelections } });
+	}
+
+	handleInput(data: string): void {
+		if (this.screen === OVERVIEW_SCREEN) {
+			if (matchesKey(data, Key.up)) {
+				if (this.overviewIndex > 0) {
+					this.overviewIndex--;
+					this.tui.requestRender();
+				}
+				return;
+			}
+			if (matchesKey(data, Key.down)) {
+				if (this.overviewIndex < OVERVIEW_ROW_COUNT - 1) {
+					this.overviewIndex++;
+					this.tui.requestRender();
+				}
+				return;
+			}
+			if (matchesKey(data, Key.enter)) {
+				if (this.overviewIndex < START_ROW) this.openSlot(this.overviewIndex);
+				else this.finish();
+				return;
+			}
+			if (matchesKey(data, Key.escape)) this.done(undefined);
+			return;
+		}
+
+		const action = this.twoPane.handleInput(data);
+		if (action === "confirm") this.commitSlot(this.twoPane.getSelected());
+		else if (action === "back") {
+			this.screen = OVERVIEW_SCREEN;
+			this.tui.requestRender();
+		}
+	}
+
+	render(width: number): string[] {
+		const th = this.theme;
+		const innerWidth = Math.max(20, width - 4);
+		const frame = createFrame(th, innerWidth, {
+			glyphs: SQUARE_SINGLE_BOX,
+			horizontalPadding: 0,
+			truncationMark: "...",
+			padToWidth: true,
+			minimumBodyWidth: 10,
+		});
+		const bodyWidth = frame.bodyWidth;
+		const row = (content: string) => frame.row(` ${content}`);
+		const viewport = ratioViewport(process.stdout.rows, {
+			fallbackRows: 24,
+			ratio: 0.7,
+			minimum: 6,
+		});
+
+		if (this.screen === OVERVIEW_SCREEN) {
+			const ready = this.isReady();
+			const slotRow = (label: string, detail: string, index: number, disabled = false) => {
+				const active = index === this.overviewIndex;
+				const pointer = active ? th.fg("accent", SELECTOR_POINTER) : UNSELECTED_POINTER;
+				const labelText = disabled
+					? (active ? th.bold(th.fg("muted", label)) : th.fg("dim", label))
+					: (active ? th.bold(th.fg("accent", label)) : th.bold(label));
+				return frame.row(` ${pointer}${labelText}${detail ? `  ${th.fg("muted", detail)}` : ""}`);
+			};
+			const detail = (label: string, ref: ModelRef | undefined, thinking: ThinkingLevel | undefined) => {
+				if (!ref) return "(none)";
+				const suffix = ` · thinking: ${thinking ?? "—"}`;
+				const modelWidth = Math.max(4, bodyWidth - 5 - visibleWidth(label) - visibleWidth(suffix));
+				return `${smartTruncateModelLabel(modelRefLabel(ref), modelWidth)}${suffix}`;
+			};
+			const slotRows = this.refs.map((ref, index) => {
+				const label = SLOT_TITLES[index] ?? `Opinion ${index + 1}`;
+				return slotRow(label, detail(label, ref, this.thinking[index]), index);
+			});
+			const action = slotRow("Get opinions", ready ? "" : "needs 1 opinion model", START_ROW, !ready);
+			const fullRows = [...slotRows, row(""), action];
+			const lines = [
+				frame.top(),
+				row(th.fg("accent", "Select Opinion Models")),
+				frame.separator(),
+				...fullRows,
+				frame.separator(),
+				row(th.fg("dim", "↑↓ navigate • enter select • esc cancel")),
+				frame.bottom(),
+			];
+			if (lines.length <= viewport) return lines;
+			const maxRows = Math.max(1, viewport - 4);
+			const compactRows = [...slotRows, action];
+			const start = Math.max(0, Math.min(this.overviewIndex - Math.floor(maxRows / 2), compactRows.length - maxRows));
+			return [
+				frame.top(),
+				row(th.fg("accent", "Select Opinion Models")),
+				frame.separator(),
+				...compactRows.slice(start, start + maxRows),
+				frame.bottom(),
+			].slice(0, viewport);
+		}
+
+		const slot = this.screen - 1;
+		const { actionRow, hintRows } = this.twoPane.renderFooter(bodyWidth, `${HINT_BASE} • esc back`);
+		this.twoPane.setMaxVisibleRows(Math.max(1, viewport - 8 - (hintRows.length - 1)));
+		const pane = this.twoPane.render(bodyWidth).map((line) => frame.row(line));
+		const lines = [
+			frame.top(),
+			row(th.fg("accent", `Opinion ${slot + 1} (${slot + 1}/${MAX_OPINION_MODELS})`)),
+			frame.separator(),
+			...pane,
+			frame.separator(),
+			frame.row(actionRow),
+			frame.separator(),
+			...hintRows.map((line) => frame.row(line)),
+			frame.bottom(),
+		];
+		if (lines.length <= viewport) return lines;
+		return [frame.top(), row(th.fg("accent", `Opinion ${slot + 1}`)), ...pane.slice(0, Math.max(1, viewport - 4)), frame.row(actionRow), frame.bottom()].slice(0, viewport);
+	}
+
+	invalidate(): void {
+		this.twoPane.invalidate();
+	}
+}
+
+export async function showOpinionModelPicker(
+	ctx: ExtensionContext,
+	currentThinking: ThinkingLevel,
+): Promise<OpinionPickerResult | undefined> {
+	if (!ctx.hasUI) return undefined;
+	const available = getAvailableModelRefs(ctx);
+	if (available.length === 0) return undefined;
+
+	const saved = loadMoaConfig();
+	const current = ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined;
+	const fallback = current ?? saved.opinionModels[0];
+	const defaults = Array.from({ length: MAX_OPINION_MODELS }, (_, index) =>
+		saved.opinionModels[index] ?? fallback,
+	);
+
+	return await ctx.ui.custom<OpinionPickerResult | undefined>(
+		(tui, theme, _keybindings, done) =>
+			new OpinionModelPickerComponent(tui, theme, available, defaults, saved, currentThinking, ctx, done),
+		{
+			overlay: true,
+			overlayOptions: {
+				anchor: "center",
+				width: "82%",
+				minWidth: 64,
+				maxHeight: "70%",
+				margin: 1,
+			},
+		},
+	);
+}

package/src/ui/planReviewOverlay.ts

@@ -0,0 +1,315 @@
+import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+import { Key, Markdown, matchesKey, stripTerminalSequences, truncateToWidth, visibleWidth, type Component, type TUI } from "@earendil-works/pi-tui";
+import { shortModelName, type ModelRef } from "../shared/modelRefs.ts";
+import type { MfPlanInfo, PlanReviewDecision } from "../moa/planInfo.ts";
+import { ROUNDED_SINGLE_BOX, createFrame, ratioViewport, safeRenderWidth } from "./chrome.ts";
+import { saveRepoPlanFile } from "../planning/planFile.ts";
+
+const OVERLAY_HEIGHT_RATIO = 0.9;
+const OVERLAY_MARGIN = 1;
+/** Fixed chrome: top border, title, separator, separator, bottom border (help row(s) added separately). */
+const BASE_CHROME_LINES = 5;
+const MOA_META_LINES = 1; // proposing row
+
+function getChromeLines(moaInfo: MfPlanInfo | undefined, helpLines: number): number {
+	return BASE_CHROME_LINES + helpLines + (moaInfo ? MOA_META_LINES : 0);
+}
+
+function getViewportLines(moaInfo: MfPlanInfo | undefined, helpLines: number): number {
+	return ratioViewport(process.stdout.rows, {
+		fallbackRows: 24,
+		ratio: OVERLAY_HEIGHT_RATIO,
+		minimum: 6,
+		margin: OVERLAY_MARGIN,
+		chromeRows: getChromeLines(moaInfo, helpLines),
+	});
+}
+
+/**
+ * Wrap a `·`-delimited help/status line to fit within bodyWidth, spilling to a
+ * second line if needed instead of truncating the whole thing to an ellipsis.
+ */
+function wrapDimLine(text: string, bodyWidth: number): string[] {
+	if (visibleWidth(text) <= bodyWidth) return [text];
+
+	const parts = text.split(" · ");
+	const lines: string[] = [];
+	let current = "";
+	for (const part of parts) {
+		const candidate = current ? `${current} · ${part}` : part;
+		if (visibleWidth(candidate) <= bodyWidth) {
+			current = candidate;
+		} else {
+			if (current) lines.push(current);
+			current = part;
+		}
+	}
+	if (current) lines.push(current);
+
+	if (lines.length > 2) {
+		const first = lines[0];
+		const rest = lines.slice(1).join(" · ");
+		lines.length = 0;
+		lines.push(first, rest);
+	}
+
+	return lines.slice(0, 2).map((line) => truncateToWidth(line, bodyWidth, "…", false));
+}
+
+const MOA_SYNTHESIZED_PREFIX = "Synthesized by: ";
+
+function padRow(content: string, bodyWidth: number): string {
+	return truncateToWidth(content, bodyWidth, "…", true);
+}
+
+function formatProposersList(proposers: ModelRef[]): string {
+	const content = proposers
+		.map((ref, index) => `P${index + 1}: ${shortModelName(ref)}`)
+		.join(", ");
+	return `(${content})`;
+}
+
+function formatSplitRow(left: string, right: string | undefined, bodyWidth: number): string {
+	const leftText = left ?? "";
+	if (!right) {
+		return padRow(leftText, bodyWidth);
+	}
+
+	const minLeft = Math.min(visibleWidth(leftText), 18);
+	const maxRight = Math.max(1, bodyWidth - minLeft);
+	const rightPart = truncateToWidth(right, maxRight, "…", false);
+	const rightVis = visibleWidth(rightPart);
+	const leftPart = truncateToWidth(leftText, Math.max(1, bodyWidth - rightVis), "…", false);
+	const gap = bodyWidth - visibleWidth(leftPart) - visibleWidth(rightPart);
+	const row = gap > 0 ? leftPart + " ".repeat(gap) + rightPart : leftPart + rightPart;
+	return padRow(row, bodyWidth);
+}
+
+function formatRightRow(content: string, bodyWidth: number): string {
+	const truncated = truncateToWidth(content, bodyWidth, "…", false);
+	const gap = bodyWidth - visibleWidth(truncated);
+	return padRow(gap > 0 ? " ".repeat(gap) + truncated : truncated, bodyWidth);
+}
+
+export async function showPlanReview(
+	ctx: ExtensionContext,
+	planMarkdown: string,
+	moaInfo?: MfPlanInfo,
+	planName?: string,
+	allowChat = false,
+): Promise<PlanReviewDecision> {
+	const result = await ctx.ui.custom<PlanReviewDecision>(
+		(tui, theme, _keybindings, done) => new PlanReviewOverlay(tui, theme, planMarkdown, moaInfo, ctx.cwd, planName, allowChat, done),
+		{
+			overlay: true,
+			overlayOptions: {
+				anchor: "center",
+				width: "90%",
+				minWidth: 60,
+				maxHeight: "90%",
+				margin: OVERLAY_MARGIN,
+			},
+		},
+	);
+
+	return result ?? "keep";
+}
+
+class PlanReviewOverlay implements Component {
+	private readonly markdown: Markdown;
+	private readonly proposerMarkdown = new Map<number, Markdown>();
+	private readonly proposerLabels = new Map<number, string>();
+	private readonly verdictsMarkdown: Markdown | undefined;
+	private activeProposerIndex: number | undefined;
+	private showVerdicts = false;
+	private scrollOffset = 0;
+	/** Number of help-row lines the last render used; kept for scroll math between renders. */
+	private helpLineCount = 1;
+	private renderCache: { markdown: Markdown; width: number; rendered: string[] } | undefined;
+
+	constructor(
+		private readonly tui: TUI,
+		private readonly theme: Theme,
+		private readonly planMarkdown: string,
+		private readonly moaInfo: MfPlanInfo | undefined,
+		private readonly repoCwd: string,
+		private readonly planName: string | undefined,
+		private readonly allowChat: boolean,
+		private readonly done: (decision: PlanReviewDecision) => void,
+	) {
+		this.markdown = new Markdown(stripTerminalSequences(planMarkdown), 0, 0, getMarkdownTheme());
+		for (const proposal of moaInfo?.proposerPlans ?? []) {
+			this.proposerMarkdown.set(proposal.proposerIndex, new Markdown(stripTerminalSequences(proposal.markdown), 0, 0, getMarkdownTheme()));
+			this.proposerLabels.set(proposal.proposerIndex, shortModelName(proposal.model));
+		}
+		if (moaInfo?.verdictsMarkdown) {
+			this.verdictsMarkdown = new Markdown(stripTerminalSequences(moaInfo.verdictsMarkdown), 0, 0, getMarkdownTheme());
+		}
+	}
+
+	handleInput(data: string): void {
+		const proposerIndex = Number.parseInt(data, 10) - 1;
+		if (/^[1-9]$/.test(data) && this.proposerMarkdown.has(proposerIndex)) {
+			this.activeProposerIndex = proposerIndex;
+			this.showVerdicts = false;
+			this.scrollOffset = 0;
+			this.tui.requestRender();
+			return;
+		}
+		if (data === "0" || data === "`") {
+			this.activeProposerIndex = undefined;
+			this.showVerdicts = false;
+			this.scrollOffset = 0;
+			this.tui.requestRender();
+			return;
+		}
+		if (this.verdictsMarkdown && (data === "v" || data === "V")) {
+			this.showVerdicts = !this.showVerdicts;
+			this.activeProposerIndex = undefined;
+			this.scrollOffset = 0;
+			this.tui.requestRender();
+			return;
+		}
+
+		if (matchesKey(data, Key.enter) || data === "a" || data === "A") {
+			if (this.planName) {
+				try {
+					saveRepoPlanFile(this.planMarkdown, this.repoCwd, this.planName, "plan");
+				} catch {
+					// Don't block approval if the repo save fails.
+				}
+			}
+			this.done("approve");
+			return;
+		}
+		if (matchesKey(data, Key.escape) || data === "q" || data === "Q") {
+			this.done("keep");
+			return;
+		}
+		if (data === "e" || data === "E") {
+			this.done("edit");
+			return;
+		}
+		if (this.allowChat && (data === "c" || data === "C")) {
+			this.done("chat");
+			return;
+		}
+
+		let delta = 0;
+		if (matchesKey(data, Key.down) || data === "j") delta = 1;
+		else if (matchesKey(data, Key.up) || data === "k") delta = -1;
+		else if (matchesKey(data, Key.pageDown) || matchesKey(data, Key.ctrl("f")) || data === "d") delta = getViewportLines(this.moaInfo, this.helpLineCount) - 2;
+		else if (matchesKey(data, Key.pageUp) || matchesKey(data, Key.ctrl("b")) || data === "u") delta = -(getViewportLines(this.moaInfo, this.helpLineCount) - 2);
+		else if (matchesKey(data, Key.home)) this.scrollOffset = 0;
+		else if (matchesKey(data, Key.end)) this.scrollOffset = Number.MAX_SAFE_INTEGER;
+		else return;
+
+		this.scrollOffset += delta;
+		this.tui.requestRender();
+	}
+
+	render(width: number): string[] {
+		// Overlay re-renders can briefly receive a bogus width while handling input.
+		// Never pass an unbounded value to Markdown.render(), which pads via String.repeat().
+		const terminalWidth = Math.max(20, process.stdout.columns ?? 80);
+		const safeWidth = safeRenderWidth(width, terminalWidth);
+		const innerWidth = Math.max(20, safeWidth - 4);
+		const frame = createFrame(this.theme, innerWidth, {
+			glyphs: ROUNDED_SINGLE_BOX,
+			horizontalPadding: 1,
+			truncationMark: "…",
+			padToWidth: true,
+			minimumBodyWidth: 10,
+		});
+		const bodyWidth = frame.bodyWidth;
+		const activeMarkdown = this.showVerdicts && this.verdictsMarkdown
+			? this.verdictsMarkdown
+			: this.activeProposerIndex === undefined
+				? this.markdown
+				: this.proposerMarkdown.get(this.activeProposerIndex) ?? this.markdown;
+		const helpParts = [...this.proposerMarkdown.keys()]
+			.map((index) => index + 1)
+			.sort((a, b) => a - b)
+			.join(",");
+		const proposalHelp = helpParts ? ` · ${helpParts} proposer plans · \`/0 synthesized` : "";
+		const verdictsHelp = this.verdictsMarkdown ? " · v verdicts" : "";
+		const chatHelp = this.allowChat ? " · c chat" : "";
+		const helpLines = wrapDimLine(
+			`↑/↓ or j/k scroll · u/d page${proposalHelp}${verdictsHelp} · e edit${chatHelp} · a/Enter approve · q/Esc keep planning`,
+			bodyWidth,
+		);
+		this.helpLineCount = helpLines.length;
+
+		if (!this.renderCache || this.renderCache.markdown !== activeMarkdown || this.renderCache.width !== bodyWidth) {
+			this.renderCache = { markdown: activeMarkdown, width: bodyWidth, rendered: activeMarkdown.render(bodyWidth) };
+		}
+		const renderedPlan = this.renderCache.rendered;
+		const viewport = Math.min(getViewportLines(this.moaInfo, this.helpLineCount), Math.max(6, renderedPlan.length));
+		const maxOffset = Math.max(0, renderedPlan.length - viewport);
+		this.scrollOffset = Math.max(0, Math.min(this.scrollOffset, maxOffset));
+
+		const visible = renderedPlan.slice(this.scrollOffset, this.scrollOffset + viewport);
+		while (visible.length < viewport) visible.push("");
+
+		const th = this.theme;
+		const position = renderedPlan.length > viewport
+			? ` lines ${this.scrollOffset + 1}-${Math.min(this.scrollOffset + viewport, renderedPlan.length)}/${renderedPlan.length}`
+			: ` ${renderedPlan.length} lines`;
+
+		const showingVerdicts = this.showVerdicts && this.verdictsMarkdown !== undefined;
+		const planTitle = showingVerdicts
+			? "Proposer Verdicts"
+			: this.activeProposerIndex === undefined
+				? "Proposed Plan"
+				: `Proposer ${this.activeProposerIndex + 1} Plan`;
+		const proposerModel = this.activeProposerIndex === undefined
+			? undefined
+			: this.proposerLabels.get(this.activeProposerIndex);
+		const nameSuffix = this.planName && this.activeProposerIndex === undefined && !showingVerdicts
+			? th.fg("dim", ` · ${this.planName}`)
+			: "";
+		const leftTitle = th.fg("accent", planTitle)
+			+ nameSuffix
+			+ (proposerModel ? th.fg("dim", ` · ${proposerModel}`) : "")
+			+ th.fg("dim", position);
+		let rightTitle: string | undefined;
+		if (this.moaInfo && this.activeProposerIndex === undefined) {
+			rightTitle = th.fg("dim", MOA_SYNTHESIZED_PREFIX)
+				+ th.fg("text", shortModelName(this.moaInfo.synthesizer));
+		}
+
+		const lines: string[] = [
+			frame.top(),
+			frame.row(formatSplitRow(leftTitle, rightTitle, bodyWidth)),
+		];
+
+		if (this.moaInfo) {
+			const proposedLine = th.fg("text", formatProposersList(this.moaInfo.proposers));
+			lines.push(frame.row(formatRightRow(proposedLine, bodyWidth)));
+		}
+
+		lines.push(frame.separator());
+
+		for (const line of visible) {
+			lines.push(frame.row(line));
+		}
+
+		lines.push(frame.separator());
+		for (const helpLine of helpLines) {
+			lines.push(frame.row(th.fg("dim", helpLine)));
+		}
+		lines.push(frame.bottom());
+
+		return lines;
+	}
+
+	invalidate(): void {
+		this.markdown.invalidate();
+		this.verdictsMarkdown?.invalidate();
+		for (const markdown of this.proposerMarkdown.values()) markdown.invalidate();
+		this.renderCache = undefined;
+	}
+
+	dispose(): void {}
+}

package/src/ui/promptEditor.ts

@@ -0,0 +1,87 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+import { ExtensionEditorComponent, getAgentDir, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { CombinedAutocompleteProvider, Container, Editor, Text, type Focusable, type TUI } from "@earendil-works/pi-tui";
+
+type KeybindingsManager = ConstructorParameters<typeof ExtensionEditorComponent>[1];
+
+let fdPath: string | null | undefined;
+
+/** Find pi's bundled fd binary, then a compatible binary available on PATH. */
+export function resolveFdPath(): string | null {
+	if (fdPath !== undefined) return fdPath;
+
+	try {
+		const bundledPath = join(getAgentDir(), "bin", process.platform === "win32" ? "fd.exe" : "fd");
+		if (existsSync(bundledPath)) return fdPath = bundledPath;
+
+		for (const command of ["fd", "fdfind"]) {
+			if (spawnSync(command, ["--version"], { stdio: "ignore" }).status === 0) return fdPath = command;
+		}
+	} catch {
+		// Path lookup is an optional enhancement; regular path completion still works.
+	}
+
+	return fdPath = null;
+}
+
+export class PromptEditorComponent extends Container implements Focusable {
+	private readonly editor: Editor;
+	private readonly inner: ExtensionEditorComponent;
+
+	constructor(
+		tui: TUI,
+		keybindings: KeybindingsManager,
+		title: string,
+		prefill: string | undefined,
+		done: (value: string | undefined) => void,
+		cwd: string,
+	) {
+		super();
+		this.inner = new ExtensionEditorComponent(tui, keybindings, title, prefill, done, () => done(undefined));
+		this.addChild(this.inner);
+
+		// pi-coding-agent may resolve a nested pi-tui copy, so retain a structural
+		// fallback when the primary instanceof guard has a different class identity.
+		const editor = this.inner.children.find((child): child is Editor => (
+			child instanceof Editor
+			|| (
+				typeof (child as Editor).setAutocompleteProvider === "function"
+				&& typeof (child as Editor).isShowingAutocomplete === "function"
+				&& typeof (child as Editor).getText === "function"
+			)
+		));
+		if (!editor) throw new Error("ExtensionEditorComponent did not contain an Editor");
+		this.editor = editor;
+		this.editor.setAutocompleteProvider(new CombinedAutocompleteProvider([], cwd, resolveFdPath()));
+
+		this.addChild(new Text("Tab completes file paths · @name searches the repo", 1, 0));
+	}
+
+	get focused(): boolean {
+		return this.inner.focused;
+	}
+
+	set focused(value: boolean) {
+		this.inner.focused = value;
+	}
+
+	handleInput(data: string): void {
+		if (this.editor.isShowingAutocomplete()) {
+			this.editor.handleInput(data);
+			return;
+		}
+		this.inner.handleInput(data);
+	}
+
+	dispose(): void {}
+}
+
+export function showPromptEditor(ctx: ExtensionContext, title: string, prefill?: string): Promise<string | undefined> {
+	if (ctx.mode !== "tui") return ctx.ui.editor(title, prefill);
+	return ctx.ui.custom<string | undefined>((tui, _theme, keybindings, done) => (
+		new PromptEditorComponent(tui, keybindings, title, prefill, done, ctx.cwd)
+	));
+}