@timurproko/a1 0.1.8-dev.ece8cef → 0.2.1-dev.590

package/dist/integrations/pi/components/shell-editor-autocomplete.js

@@ -0,0 +1,357 @@
+import { getSelectListTheme } from "../startup-public.js";
+import { CombinedAutocompleteProvider, matchesKey, setKeybindings, visibleWidth, } from "@earendil-works/pi-tui";
+import { PROMPT_HISTORY_EDITOR_REPLACEMENT } from "../../../contracts/owned-ui/index.js";
+import { KeybindingsManager } from "./upstream/adjacent/core/keybindings.js";
+import { OwnedEditor } from "./upstream/components/owned-editor.js";
+import { OwnedEditorUxInterception, createPromptSelectionInterceptor, editorVisualLineCount, } from "./owned-editor-ux.js";
+import { PINNED_PI_LAYOUT, piTheme, } from "./theme.js";
+import { createTuiFacade, ensureTheme, isAutocompleteProvider, } from "./shell-shared-facade.js";
+import { SKILLS_COMMAND_NAME, collapseSkillCommands, createSkillsTunnelProvider, } from "./skills-command.js";
+/** A selected autocomplete row: the accent primary column, then the aligned description. */
+const SELECTED_DESCRIBED_ROW = /^(→ .*?\S)(\s{2,}.*)$/u;
+const PINNED_THINKING_SLASH_COMMAND = { name: "thinking", description: "Set thinking level", argumentHint: "<level>" };
+const OWNED_THINKING_SLASH_COMMAND = { name: "thinking", description: "Set thinking level" };
+const OWNED_LOGIN_SLASH_COMMAND = { name: "login", description: "Configure provider authentication" };
+export const PINNED_PI_BUILTIN_SLASH_COMMANDS = [
+    { name: "settings", description: "Open settings menu" },
+    { name: "model", description: "Select model (opens selector UI)", argumentHint: "<provider/model>" },
+    { name: "tree", description: "Navigate session tree (switch branches)" },
+    PINNED_THINKING_SLASH_COMMAND,
+    { name: "scoped-models", description: "Enable/disable models for Ctrl+P cycling" },
+    { name: "export", description: "Export session (HTML default, or specify path: .html/.jsonl)" },
+    { name: "import", description: "Import and resume a session from a JSONL file" },
+    { name: "share", description: "Share session as a secret GitHub gist" },
+    { name: "copy", description: "Copy last agent message to clipboard" },
+    { name: "name", description: "Set session display name" },
+    { name: "session", description: "Show session info and stats" },
+    { name: "changelog", description: "Show changelog entries" },
+    { name: "hotkeys", description: "Show all keyboard shortcuts" },
+    { name: "fork", description: "Create a new fork from a previous user message" },
+    { name: "clone", description: "Duplicate the current session at the current position" },
+    { name: "trust", description: "Save project trust decision for future sessions" },
+    { name: "login", description: "Configure provider authentication", argumentHint: "<provider>" },
+    { name: "logout", description: "Remove provider authentication" },
+    { name: "new", description: "Start a new session" },
+    { name: "compact", description: "Manually compact the session context" },
+    { name: "resume", description: "Resume a different session" },
+    { name: "reload", description: "Reload keybindings, extensions, skills, prompts, themes, and context files" },
+    { name: "quit", description: "Quit" },
+];
+/** Bare A1's built-in catalog: `models` replaces the pinned pair and is followed by `thinking`. */
+export const OWNED_BUILTIN_SLASH_COMMANDS = PINNED_PI_BUILTIN_SLASH_COMMANDS.flatMap(command => {
+    if (command.name === "model") {
+        return [{ name: "models", description: "Switch models and manage scoped model cycling" }, OWNED_THINKING_SLASH_COMMAND];
+    }
+    if (command.name === "thinking" || command.name === "scoped-models")
+        return [];
+    if (command.name === "login")
+        return [OWNED_LOGIN_SLASH_COMMAND];
+    return [command];
+});
+export function createPiShellEditor(options) {
+    ensureTheme();
+    const tui = createTuiFacade(options);
+    const inputPresentation = options.keybindingProfile === "a1" ? options.promptPresentation?.input : undefined;
+    const keybindings = options.keybindingProfile === "a1"
+        ? KeybindingsManager.createForOwnedInput(options.agentDir)
+        : KeybindingsManager.create(options.agentDir);
+    setKeybindings(keybindings);
+    if (options.persistentHistory === true && options.keybindingProfile === "a1" && options.historyEditor === undefined) {
+        throw new Error("Persistent history requires the loaded owned editor");
+    }
+    const scrollInfo = { emitted: false, counter: undefined };
+    const selectListTheme = getSelectListTheme();
+    let tunnelSkills = [];
+    const EditorClass = options.keybindingProfile === "a1" && options.persistentHistory === true ? options.historyEditor : OwnedEditor;
+    const editor = new EditorClass(tui, {
+        borderColor: (value) => inputPresentation === undefined ? piTheme().fg("borderMuted", value) : inputPresentation.styleRule(value),
+        selectList: options.keybindingProfile !== "a1" ? selectListTheme : {
+            ...selectListTheme,
+            scrollInfo: text => {
+                // Protocol: the pinned list emits its final counter row through this callback.
+                scrollInfo.emitted = true;
+                scrollInfo.counter = /^  \((\d+\/\d+)\)$/u.exec(text)?.[1];
+                return selectListTheme.scrollInfo(text);
+            },
+            selectedText: text => {
+                // Rationale: the pinned list styles a whole selected row at once. Bare A1 keeps the
+                // actionable primary column accented while every aligned description remains muted.
+                const row = SELECTED_DESCRIBED_ROW.exec(text);
+                return row === null ? selectListTheme.selectedText(text) : selectListTheme.selectedText(row[1]) + selectListTheme.description(row[2]);
+            },
+        },
+    }, keybindings, {
+        paddingX: PINNED_PI_LAYOUT.editorPaddingX,
+        autocompleteMaxVisible: PINNED_PI_LAYOUT.autocompleteMaxVisible,
+        persistentHistory: options.persistentHistory === true,
+        styleHistoryLabel: text => piTheme().fg("dim", text),
+        ...(options.keybindingProfile === "a1" ? {
+            terminalRows: options.getRows,
+            getVisualLineCount: (width) => editorVisualLineCount(editor, width),
+            clearCommandSearchOnEscape: true,
+            commandTunnels: () => tunnelSkills.length === 0 ? [] : [SKILLS_COMMAND_NAME],
+        } : {}),
+        ...(options.keybindingProfile === "a1" && options.promptPresentation !== undefined ? {
+            ...(inputPresentation === undefined ? {} : { inputPresentation }),
+            styleSuggestion: options.promptPresentation.styleSuggestion,
+            styleSuggestionCaret: options.promptPresentation.styleSuggestionCaret,
+        } : {}),
+    });
+    const editorUx = options.keybindingProfile === "a1"
+        ? new OwnedEditorUxInterception([
+            createPromptSelectionInterceptor(editor, keybindings, {
+                copyText: options.onCopyText ?? (() => { }),
+                readClipboardContent: options.readClipboardContent ?? (async () => null),
+                ...(options.beginClipboardPaste === undefined ? {} : { beginClipboardPaste: options.beginClipboardPaste }),
+                ...(options.beginTextPaste === undefined ? {} : { beginTextPaste: options.beginTextPaste }),
+                ...(options.deferTextPaste === undefined ? {} : { deferTextPaste: options.deferTextPaste }),
+                ...(options.onPasteRejected === undefined ? {} : { onPasteRejected: options.onPasteRejected }),
+                ...(options.onPasteInput === undefined ? {} : { onPasteInput: options.onPasteInput }),
+                transformPastedContent: options.transformPastedContent ?? (content => content.kind === "text" ? content.text : ""),
+                atomicRanges: options.editorAtomicRanges ?? (() => []),
+                hiddenRanges: options.editorHiddenRanges ?? (() => []),
+                expandCopiedText: options.expandCopiedEditorText ?? (text => text),
+                paintSelection: options.paintEditorSelection ?? (line => line),
+                decorateRow: options.decorateEditorRow ?? (row => row),
+                requestRender: options.requestRender,
+                getRows: options.getRows,
+                ...(inputPresentation === undefined ? {} : { promptGeometry: (width, padding) => inputPresentation.geometry(width, padding) }),
+            }),
+        ], {
+            render: width => editor.render(width),
+            handleInput: data => editor.handleInput(data),
+        })
+        : undefined;
+    let thinkingLevel = "off";
+    let isBashMode = false;
+    const updateBorderColor = () => {
+        editor.borderColor = inputPresentation !== undefined
+            ? text => inputPresentation.styleRule(text)
+            : isBashMode ? piTheme().getBashModeBorderColor() : piTheme().getThinkingBorderColor(thinkingLevel);
+        tui.requestRender();
+    };
+    let autocompleteProvider;
+    const builtInCatalog = options.keybindingProfile === "a1" ? OWNED_BUILTIN_SLASH_COMMANDS : PINNED_PI_BUILTIN_SLASH_COMMANDS;
+    const setAutocompleteCommands = (installed) => {
+        // Invariant: collapse is a bare-A1 presentation; the comparison profile installs the pinned list.
+        const collapsed = options.keybindingProfile === "a1" && options.skillsPresentation?.() === "collapse"
+            ? collapseSkillCommands(installed)
+            : { commands: installed, skills: [] };
+        tunnelSkills = collapsed.skills;
+        const commands = collapsed.commands;
+        const additions = new Map(commands.map(command => [command.name, command]));
+        const builtInNames = new Set(builtInCatalog.map(command => command.name));
+        const builtIns = builtInCatalog.flatMap(command => [
+            autocompleteCommand(command, additions.get(command.name)),
+            // Rationale: the collapsed browser is a primary bare-A1 command, not a resource after quit.
+            ...(command.name === "settings" && collapsed.collapsedCommand !== undefined
+                ? [autocompleteCommand(collapsed.collapsedCommand)]
+                : []),
+        ]);
+        // Invariant: built-in additions and the promoted collapsed browser never reappear as resources.
+        const resources = commands
+            .filter(command => command.name !== collapsed.collapsedCommand?.name && command.source !== "builtin" && !builtInNames.has(command.name))
+            .map(command => autocompleteCommand(command));
+        const combined = new CombinedAutocompleteProvider([...builtIns, ...resources], options.cwd ?? process.cwd());
+        autocompleteProvider = tunnelSkills.length === 0 ? combined : createSkillsTunnelProvider(combined, tunnelSkills);
+        editor.setAutocompleteProvider(autocompleteProvider);
+    };
+    setAutocompleteCommands(options.autocompleteCommands ?? []);
+    let submitHandler = options.onSubmit;
+    let interruptHandler = options.onInterrupt ?? (() => { });
+    editor.onSubmit = text => submitHandler(text);
+    editor.onChange = text => {
+        const nextBashMode = text.trimStart().startsWith("!");
+        if (nextBashMode !== isBashMode) {
+            isBashMode = nextBashMode;
+            updateBorderColor();
+        }
+        options.onChange?.(text);
+    };
+    if (options.onInterrupt !== undefined) {
+        editor.onEscape = () => interruptHandler();
+        editor.onAction("app.interrupt", () => interruptHandler());
+    }
+    if (options.onClear !== undefined)
+        editor.onAction("app.clear", options.onClear);
+    if (options.onExit !== undefined) {
+        editor.onCtrlD = options.onExit;
+        editor.onAction("app.exit", options.onExit);
+    }
+    if (options.onSuspend !== undefined)
+        editor.onAction("app.suspend", options.onSuspend);
+    if (options.onExternalEditor !== undefined)
+        editor.onAction("app.editor.external", options.onExternalEditor);
+    if (options.onPasteImage !== undefined) {
+        editor.onPasteImage = options.onPasteImage;
+        editor.onAction("app.clipboard.pasteImage", options.onPasteImage);
+    }
+    if (options.onExtensionShortcut !== undefined)
+        editor.onExtensionShortcut = options.onExtensionShortcut;
+    if (options.onModelSelect !== undefined)
+        editor.onAction("app.model.select", options.onModelSelect);
+    if (options.onModelCycle !== undefined) {
+        editor.onAction("app.model.cycleForward", () => options.onModelCycle?.("forward"));
+        editor.onAction("app.model.cycleBackward", () => options.onModelCycle?.("backward"));
+    }
+    if (options.onThinkingCycle !== undefined)
+        editor.onAction("app.thinking.cycle", options.onThinkingCycle);
+    if (options.onThinkingToggle !== undefined)
+        editor.onAction("app.thinking.toggle", options.onThinkingToggle);
+    if (options.onToolsExpand !== undefined)
+        editor.onAction("app.tools.expand", options.onToolsExpand);
+    if (options.onMessageCopy !== undefined)
+        editor.onAction("app.message.copy", options.onMessageCopy);
+    if (options.onFollowUp !== undefined)
+        editor.onAction("app.message.followUp", options.onFollowUp);
+    if (options.onDequeue !== undefined)
+        editor.onAction("app.message.dequeue", options.onDequeue);
+    if (options.onPromptSuggestionAccepted !== undefined) {
+        editor.onPromptSuggestionAccepted = options.onPromptSuggestionAccepted;
+    }
+    let bodyGeometry = { rowOffset: 0, rowCount: 0 };
+    return {
+        ...(editorUx === undefined ? {} : { bodyGeometry: () => bodyGeometry }),
+        render: width => {
+            scrollInfo.emitted = false;
+            scrollInfo.counter = undefined;
+            const rows = editorUx?.render(width) ?? editor.render(width);
+            if (editorUx === undefined)
+                return rows;
+            const rowCount = editor.getRenderedBodyRowCount();
+            const menu = rows.slice(rowCount, scrollInfo.emitted ? -1 : undefined);
+            const label = scrollInfo.counter === undefined ? "" : `${scrollInfo.counter} `;
+            // Compatibility: match the history border's four-cell inset and dim label style.
+            const counterBorder = label.length > 0 && 4 + visibleWidth(label) <= width
+                ? editor.borderColor("─── ") + piTheme().fg("dim", label)
+                    + editor.borderColor("─".repeat(width - 4 - visibleWidth(label)))
+                : editor.borderColor("─".repeat(width));
+            // Rationale: when the menu is open, drop the plain top border above the
+            // menu and instead show the counter on the border directly above the input
+            // prompt (the body's own top border row), mirroring the history header.
+            const bodyRows = menu.length === 0
+                ? rows.slice(0, rowCount)
+                : [counterBorder, ...rows.slice(1, rowCount)];
+            bodyGeometry = { rowOffset: menu.length, rowCount };
+            // Invariant: decorate/select in body coordinates first, then move the whole menu.
+            // Completion state, sizing, styles, and pagination still belong to the editor.
+            return [...menu, ...bodyRows];
+        },
+        activateKeybindings: () => setKeybindings(keybindings),
+        keybindingConfig: () => keybindings.getEffectiveConfig(),
+        reloadKeybindings: () => { keybindings.reload(); setKeybindings(keybindings); },
+        matchesTerminalKey: (data, key) => matchesKey(data, key),
+        handleInput: data => {
+            // Compatibility: an unassigned reverse Tab must not clear selection or reach autocomplete fallback.
+            if (editorUx !== undefined && matchesKey(data, "shift+tab")
+                && !Object.values(keybindings.getEffectiveConfig()).some(keys => (Array.isArray(keys) ? keys : [keys]).some(key => key !== undefined && matchesKey(data, key))))
+                return;
+            const hadDraft = editor.getText().length > 0;
+            if (editorUx === undefined)
+                editor.handleInput(data);
+            else
+                editorUx.handleInput(data);
+            if (editorUx === undefined || !hadDraft || editor.getText().length > 0)
+                return;
+            // Invariant: Pi's deletion paths can leave a visible or debounced autocomplete request owned by
+            // the removed draft. Reapplying empty text cancels both forms without a duplicate change notice.
+            const onChange = editor.onChange;
+            delete editor.onChange;
+            try {
+                editor.setText("");
+            }
+            finally {
+                if (onChange === undefined)
+                    delete editor.onChange;
+                else
+                    editor.onChange = onChange;
+            }
+        },
+        invalidate: () => editor.invalidate(),
+        setFocused: focused => {
+            editor.focused = focused;
+        },
+        getText: () => editor.getExpandedText(),
+        setText: text => {
+            editorUx?.reset();
+            editor.setText(text);
+        },
+        insertText: text => {
+            editorUx?.reset();
+            editor.insertTextAtCursor(text);
+        },
+        addToHistory: text => editor.addToHistory(text),
+        ...(editor.recall === undefined ? {} : { recall: editor.recall, historyReplacement: PROMPT_HISTORY_EDITOR_REPLACEMENT }),
+        setSubmitEnabled: enabled => {
+            editor.disableSubmit = !enabled;
+        },
+        setSubmitHandler: handler => { submitHandler = handler; },
+        setInterruptHandler: handler => { interruptHandler = handler; },
+        setAutocompleteCommands,
+        setPaddingX(padding) {
+            editor.setPaddingX(padding);
+            editor.invalidate();
+            tui.requestRender();
+        },
+        setAutocompleteMaxVisible(maxVisible) {
+            editor.setAutocompleteMaxVisible(maxVisible);
+            editor.invalidate();
+            tui.requestRender();
+        },
+        addAutocompleteProvider(factory) {
+            if (typeof factory !== "function")
+                throw new TypeError("extension autocomplete factory must be a function");
+            const candidate = Reflect.apply(factory, undefined, [autocompleteProvider]);
+            if (!isAutocompleteProvider(candidate))
+                throw new TypeError("extension autocomplete factory returned a malformed provider");
+            autocompleteProvider = candidate;
+            editor.setAutocompleteProvider(autocompleteProvider);
+        },
+        setThinkingLevel(level) {
+            if (thinkingLevel === level)
+                return;
+            thinkingLevel = level;
+            updateBorderColor();
+        },
+        setPromptSuggestion(text) {
+            editor.setPromptSuggestion(text);
+            editor.invalidate();
+        },
+        canPresentPromptSuggestion: () => editor.canPresentPromptSuggestion(),
+        promptSuggestionBlockReason: () => {
+            if (!editor.focused)
+                return "not-focused";
+            if (editor.disableSubmit)
+                return "not-ready";
+            if (editor.getText().length > 0)
+                return "draft";
+            if (editor.isShowingAutocomplete())
+                return "autocomplete";
+            return editor.canPresentPromptSuggestion() ? null : "prompt-mode";
+        },
+        hasSelection: () => editorUx?.hasSelection() ?? false,
+        ownsPointer: () => editorUx?.ownsPointer() ?? false,
+        handlePointer: event => editorUx?.handlePointer(event) ?? false,
+        pasteClipboard: () => editorUx?.pasteClipboard() ?? false,
+        cancelPendingPastes: () => editorUx?.cancelPendingPastes(),
+    };
+}
+function autocompleteCommand(command, addition) {
+    const argumentOptions = addition?.argumentOptions ?? command.argumentOptions;
+    return {
+        ...command,
+        ...addition,
+        ...(argumentOptions === undefined ? {} : {
+            getArgumentCompletions: (prefix) => {
+                const normalized = prefix.toLowerCase();
+                return argumentOptions
+                    .filter(option => option.id.toLowerCase().includes(normalized) || option.label.toLowerCase().includes(normalized))
+                    .map(option => ({
+                    value: option.id,
+                    label: option.label,
+                    ...(option.description === undefined ? {} : { description: option.description }),
+                }));
+            },
+        }),
+    };
+}

package/dist/integrations/pi/components/shell-extension-ui.d.ts

@@ -0,0 +1,35 @@
+import { type ExtensionUIContext } from "../startup-public.js";
+import type { OwnedUiExtensionOverlayHandle, OwnedUiExtensionOverlayOptions } from "../../../contracts/owned-ui/index.js";
+import { type PiShellComponentPort, type PiShellEditorOptions } from "./shell-shared-facade.js";
+export interface PiExtensionUiBridgeHost {
+    readonly runtime: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender">;
+    readonly agentDir?: string;
+    setInputSurface(component: PiShellComponentPort | null): void;
+    showOverlay(component: PiShellComponentPort, options?: OwnedUiExtensionOverlayOptions): OwnedUiExtensionOverlayHandle;
+    listenInput(handler: (data: string) => {
+        readonly consume?: boolean;
+        readonly data?: string;
+    } | undefined): () => void;
+    replaceWidget(key: string, component: PiShellComponentPort | null, placement: "aboveEditor" | "belowEditor"): void;
+    replaceHeader(component: PiShellComponentPort | null): void;
+    replaceFooter(component: PiShellComponentPort | null): void;
+    setStatus(key: string, text: string | undefined): void;
+    setWorking(message: string | undefined, visible?: boolean): void;
+    notify(message: string, type: "info" | "warning" | "error"): void;
+    setTitle(title: string): void;
+    getEditorText(): string;
+    setEditorText(text: string): void;
+    pasteToEditor(text: string): void;
+    addAutocompleteProvider(factory: unknown): void;
+    setCustomEditor(component: PiShellComponentPort | null): void;
+    getFooterData(): unknown;
+    getToolsExpanded(): boolean;
+    setToolsExpanded(expanded: boolean): void;
+}
+export interface PiExtensionUiBridge {
+    readonly context: ExtensionUIContext;
+    reset(): void;
+    dispose(): void;
+}
+/** Public ExtensionUIContext ported from pinned InteractiveMode without constructing it. */
+export declare function createPiExtensionUiBridge(host: PiExtensionUiBridgeHost): PiExtensionUiBridge;

package/dist/integrations/pi/components/shell-extension-ui.js

@@ -0,0 +1,282 @@
+import { getSelectListTheme, } from "../startup-public.js";
+import { ExtensionEditorComponent } from "./upstream/components/extension-editor.js";
+import { ExtensionInputComponent } from "./upstream/components/extension-input.js";
+import { ExtensionSelectorComponent } from "./upstream/components/extension-selector.js";
+import { setKeybindings, Text, } from "@earendil-works/pi-tui";
+import { KeybindingsManager, } from "./upstream/adjacent/core/keybindings.js";
+import { PINNED_PI_LAYOUT, applyPiTheme, applyPiThemeInstance, getAvailablePiThemes, loadPiTheme, piTheme, } from "./theme.js";
+import { componentPort, createTuiFacade, ensureTheme, isRecord, } from "./shell-shared-facade.js";
+/** Public ExtensionUIContext ported from pinned InteractiveMode without constructing it. */
+export function createPiExtensionUiBridge(host) {
+    ensureTheme();
+    const tui = createTuiFacade(host.runtime);
+    const keybindings = KeybindingsManager.create(host.agentDir);
+    setKeybindings(keybindings);
+    const disposers = new Set();
+    let customEditorFactory;
+    let activeSurface;
+    let activeCancel;
+    const closeSurface = (surface) => {
+        if (surface !== undefined && activeSurface !== surface)
+            return;
+        activeSurface = undefined;
+        host.setInputSurface(null);
+        host.runtime.requestRender();
+    };
+    const mountSurface = (surface) => {
+        if (activeSurface !== undefined && activeSurface !== surface)
+            activeSurface.dispose?.();
+        activeSurface = surface;
+        host.setInputSurface(surface);
+        host.runtime.requestRender();
+    };
+    const trackAbort = (signal, cancel) => {
+        if (signal === undefined)
+            return () => { };
+        if (signal.aborted) {
+            cancel();
+            return () => { };
+        }
+        signal.addEventListener("abort", cancel, { once: true });
+        const dispose = () => signal.removeEventListener("abort", cancel);
+        disposers.add(dispose);
+        return () => {
+            dispose();
+            disposers.delete(dispose);
+        };
+    };
+    const showInput = (create, options) => new Promise(resolve => {
+        let settled = false;
+        let surface;
+        let untrack = () => { };
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            if (activeCancel === cancel)
+                activeCancel = undefined;
+            untrack();
+            closeSurface(surface);
+            resolve(value);
+        };
+        const cancel = () => finish(undefined);
+        surface = create(finish, cancel);
+        untrack = trackAbort(options?.signal, cancel);
+        if (!settled) {
+            activeCancel = cancel;
+            mountSurface(surface);
+        }
+    });
+    const createFactoryComponent = (factory, ...arguments_) => {
+        if (typeof factory !== "function")
+            throw new TypeError("extension component factory must be a function");
+        const component = factory(...arguments_);
+        if (isPromiseLike(component))
+            throw new TypeError("synchronous extension surface factory returned a promise");
+        if (!isComponent(component))
+            throw new TypeError("extension factory returned a malformed component");
+        return componentPort(component);
+    };
+    const context = {
+        select: (title, options, opts) => showInput((resolve, cancel) => componentPort(new ExtensionSelectorComponent(title, [...options], resolve, cancel, {
+            tui,
+            ...(opts?.timeout === undefined ? {} : { timeout: opts.timeout }),
+            onToggleToolsExpanded: () => host.setToolsExpanded(!host.getToolsExpanded()),
+        })), opts),
+        async confirm(title, message, opts) {
+            return (await context.select(`${title}\n${message}`, ["Yes", "No"], opts)) === "Yes";
+        },
+        input: (title, placeholder, opts) => showInput((resolve, cancel) => componentPort(new ExtensionInputComponent(title, placeholder, resolve, cancel, {
+            tui,
+            ...(opts?.timeout === undefined ? {} : { timeout: opts.timeout }),
+        })), opts),
+        notify: (message, type = "info") => host.notify(message, type),
+        onTerminalInput: handler => host.listenInput(handler),
+        setStatus: (key, text) => host.setStatus(key, text),
+        setWorkingMessage: message => host.setWorking(message),
+        setWorkingVisible: visible => host.setWorking(undefined, visible),
+        setWorkingIndicator: options => host.setWorking(options?.frames?.[0]),
+        setHiddenThinkingLabel: () => host.runtime.requestRender(),
+        setWidget(key, content, options) {
+            if (content === undefined) {
+                host.replaceWidget(key, null, options?.placement ?? "aboveEditor");
+                return;
+            }
+            try {
+                const component = Array.isArray(content)
+                    ? componentPort(new Text(content.join("\n"), PINNED_PI_LAYOUT.contentPaddingX, 0))
+                    : createFactoryComponent(content, tui, piTheme());
+                host.replaceWidget(key, component, options?.placement ?? "aboveEditor");
+            }
+            catch (error) {
+                host.notify(extensionError("widget", error), "error");
+            }
+        },
+        setFooter(factory) {
+            try {
+                host.replaceFooter(factory === undefined ? null : createFactoryComponent(factory, tui, piTheme(), host.getFooterData()));
+            }
+            catch (error) {
+                host.replaceFooter(null);
+                host.notify(extensionError("footer", error), "error");
+            }
+        },
+        setHeader(factory) {
+            try {
+                host.replaceHeader(factory === undefined ? null : createFactoryComponent(factory, tui, piTheme()));
+            }
+            catch (error) {
+                host.replaceHeader(null);
+                host.notify(extensionError("header", error), "error");
+            }
+        },
+        setTitle: title => host.setTitle(title),
+        custom: (factory, options) => new Promise((resolve, reject) => {
+            let settled = false;
+            let surface;
+            let overlay;
+            const done = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (activeCancel === cancelCustom)
+                    activeCancel = undefined;
+                overlay?.hide();
+                if (surface !== undefined)
+                    closeSurface(surface);
+                resolve(value);
+            };
+            const cancelCustom = () => {
+                if (settled)
+                    return;
+                settled = true;
+                if (activeCancel === cancelCustom)
+                    activeCancel = undefined;
+                overlay?.hide();
+                if (surface !== undefined)
+                    closeSurface(surface);
+                Reflect.apply(resolve, undefined, []);
+            };
+            let created;
+            try {
+                created = Reflect.apply(factory, undefined, [tui, piTheme(), keybindings, done]);
+            }
+            catch (error) {
+                reject(error);
+                return;
+            }
+            void Promise.resolve(created).then(component => {
+                if (!isComponent(component))
+                    throw new TypeError("extension custom factory returned a malformed component");
+                if (settled) {
+                    if ("dispose" in component && typeof component.dispose === "function")
+                        component.dispose();
+                    return;
+                }
+                surface = componentPort(component);
+                activeCancel = cancelCustom;
+                if (options?.overlay) {
+                    const overlayOptions = typeof options.overlayOptions === "function" ? options.overlayOptions() : options.overlayOptions;
+                    overlay = host.showOverlay(surface, overlayOptions);
+                    options.onHandle?.(publicOverlayHandle(overlay));
+                }
+                else
+                    mountSurface(surface);
+            }).catch(error => {
+                if (activeCancel === cancelCustom)
+                    activeCancel = undefined;
+                if (surface !== undefined)
+                    closeSurface(surface);
+                reject(error);
+            });
+        }),
+        pasteToEditor: text => host.pasteToEditor(text),
+        setEditorText: text => host.setEditorText(text),
+        getEditorText: () => host.getEditorText(),
+        editor: (title, prefill) => showInput((resolve, cancel) => componentPort(new ExtensionEditorComponent(tui, keybindings, title, prefill, resolve, cancel))),
+        addAutocompleteProvider: factory => host.addAutocompleteProvider(factory),
+        setEditorComponent(factory) {
+            customEditorFactory = factory;
+            if (factory === undefined) {
+                host.setCustomEditor(null);
+                return;
+            }
+            try {
+                const editor = Reflect.apply(factory, undefined, [tui, {
+                        borderColor: (text) => piTheme().fg("borderMuted", text),
+                        selectList: getSelectListTheme(),
+                    }, keybindings]);
+                if (!isComponent(editor))
+                    throw new TypeError("extension editor factory returned a malformed editor");
+                host.setCustomEditor(componentPort(editor));
+            }
+            catch (error) {
+                customEditorFactory = undefined;
+                host.setCustomEditor(null);
+                host.notify(extensionError("editor", error), "error");
+            }
+        },
+        getEditorComponent: () => customEditorFactory,
+        get theme() { return piTheme(); },
+        getAllThemes: () => getAvailablePiThemes().map(theme => ({ name: theme.name, path: theme.path })),
+        getTheme(name) {
+            try {
+                return loadPiTheme(name);
+            }
+            catch {
+                return undefined;
+            }
+        },
+        setTheme(theme) {
+            const result = typeof theme === "string" ? applyPiTheme(theme, true) : applyPiThemeInstance(theme);
+            host.runtime.requestRender();
+            return result.success
+                ? { success: true }
+                : { success: false, ...(result.error === undefined ? {} : { error: result.error }) };
+        },
+        getToolsExpanded: () => host.getToolsExpanded(),
+        setToolsExpanded: expanded => host.setToolsExpanded(expanded),
+    };
+    const reset = () => {
+        const cancel = activeCancel;
+        activeCancel = undefined;
+        cancel?.();
+        activeSurface?.dispose?.();
+        activeSurface = undefined;
+        host.setInputSurface(null);
+    };
+    return {
+        context,
+        reset,
+        dispose() {
+            reset();
+            for (const dispose of disposers)
+                dispose();
+            disposers.clear();
+            host.replaceHeader(null);
+            host.replaceFooter(null);
+        },
+    };
+}
+function extensionError(surface, error) {
+    return `Extension ${surface} failed: ${error instanceof Error ? error.message : String(error)}`;
+}
+function isPromiseLike(value) {
+    return isRecord(value) && typeof value.then === "function";
+}
+function isComponent(value) {
+    return isRecord(value) && typeof value.render === "function" && typeof value.invalidate === "function";
+}
+function publicOverlayHandle(handle) {
+    return {
+        hide: () => handle.hide(),
+        setHidden: hidden => handle.setHidden(hidden),
+        isHidden: () => handle.isHidden(),
+        focus: () => handle.focus(),
+        unfocus: options => handle.unfocus(options?.target === undefined
+            ? undefined
+            : { target: options.target === null ? null : componentPort(options.target) }),
+        isFocused: () => handle.isFocused(),
+        getBounds: () => handle.getBounds(),
+    };
+}