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

package/dist/integrations/pi/components/upstream/components/owned-editor.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.87.1 (MIT), commit f07218c4d4bbc12bef056a7058c3dd49dfe41abe,
+ * packages/coding-agent/src/modes/interactive/components/custom-editor.ts.
+ * Modifications: A1-owned class name and synchronized A1 keybinding contract replace the nominal
+ * private upstream keybinding constructor dependency; bare A1 injects the shared Settings/agent input
+ * frame, transient contextual-suggestion branch, and explicit body geometry for selection and
+ * above-prompt autocomplete. Bare A1 also clears a sole top-level slash-command search on Escape. Bare
+ * A1 also completes a selected tunnel command with `:` and reopens the menu on its tunnel rows.
+ * Deviations: owned-shared-input-frame, above-prompt-autocomplete-placement,
+ * clear-command-search-on-escape, command-tunnel-colon-completion.
+ */
+import { type EditorOptions, type EditorTheme, type TUI } from "@earendil-works/pi-tui";
+import type { AppKeybinding, KeybindingsManager } from "../adjacent/core/keybindings.js";
+import type { EditorSurface } from "../../editor-interaction.js";
+import type { PiShellPromptInputPresentation } from "../../prompt-input-port.js";
+export interface OwnedEditorOptions extends EditorOptions {
+    readonly persistentHistory?: boolean;
+    readonly styleHistoryLabel?: (text: string) => string;
+    readonly inputPresentation?: PiShellPromptInputPresentation;
+    readonly styleSuggestion?: (text: string) => string;
+    readonly styleSuggestionCaret?: (text: string) => string;
+    readonly terminalRows?: () => number;
+    /** Reuses the editor's established atomic-aware visual layout when available. */
+    readonly getVisualLineCount?: (width: number) => number | undefined;
+    /** Bare-A1 exception: Escape on a sole top-level slash-command search also clears the prompt. */
+    readonly clearCommandSearchOnEscape?: boolean;
+    /**
+     * Bare-A1 exception: the slash commands that own a `:` tunnel. Typing `:` while one of them is
+     * the selected row of a sole top-level search completes to `/<command>:` and reopens the menu.
+     */
+    readonly commandTunnels?: () => readonly string[];
+}
+export interface ShellEditorInstance extends EditorSurface {
+    readonly actionHandlers: Map<AppKeybinding, () => void>;
+    onEscape?: () => void;
+    onCtrlD?: () => void;
+    onPasteImage?: () => void;
+    onExtensionShortcut?: (data: string) => boolean;
+    onPromptSuggestionAccepted?: (text: string) => void;
+    /** Border-inclusive body height from the most recent render, excluding autocomplete. */
+    getRenderedBodyRowCount(): number;
+    setPromptSuggestion(text: string | null): void;
+    canPresentPromptSuggestion(): boolean;
+    onAction(action: AppKeybinding, handler: () => void): void;
+}
+type EditorConstructor = new (tui: TUI, theme: EditorTheme, options?: EditorOptions) => EditorSurface;
+type ShellEditorConstructor = new (tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager, options?: OwnedEditorOptions) => ShellEditorInstance;
+export declare function createOwnedEditorClass(Base: EditorConstructor): ShellEditorConstructor;
+declare const OwnedEditor_base: ShellEditorConstructor;
+export declare class OwnedEditor extends OwnedEditor_base {
+}
+export {};

package/dist/integrations/pi/components/upstream/components/owned-editor.js

@@ -0,0 +1,222 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.87.1 (MIT), commit f07218c4d4bbc12bef056a7058c3dd49dfe41abe,
+ * packages/coding-agent/src/modes/interactive/components/custom-editor.ts.
+ * Modifications: A1-owned class name and synchronized A1 keybinding contract replace the nominal
+ * private upstream keybinding constructor dependency; bare A1 injects the shared Settings/agent input
+ * frame, transient contextual-suggestion branch, and explicit body geometry for selection and
+ * above-prompt autocomplete. Bare A1 also clears a sole top-level slash-command search on Escape. Bare
+ * A1 also completes a selected tunnel command with `:` and reopens the menu on its tunnel rows.
+ * Deviations: owned-shared-input-frame, above-prompt-autocomplete-placement,
+ * clear-command-search-on-escape, command-tunnel-colon-completion.
+ */
+import { CURSOR_MARKER, Editor, visibleWidth, wrapTextWithAnsi, } from "@earendil-works/pi-tui";
+const PROMPT_GRAPHEMES = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+export function createOwnedEditorClass(Base) {
+    return class extends Base {
+        actionHandlers = new Map();
+        onEscape;
+        onCtrlD;
+        onPasteImage;
+        onExtensionShortcut;
+        onPromptSuggestionAccepted;
+        #promptSuggestion = null;
+        #inputPresentation;
+        #styleSuggestion;
+        #styleSuggestionCaret;
+        #terminalRows;
+        #getVisualLineCount;
+        #clearCommandSearchOnEscape;
+        #commandTunnels;
+        #renderedBodyRowCount = 0;
+        keybindings;
+        constructor(tui, theme, keybindings, options = {}) {
+            super(tui, theme, options);
+            this.keybindings = keybindings;
+            this.#inputPresentation = options.inputPresentation;
+            this.#styleSuggestion = options.styleSuggestion ?? (text => text);
+            this.#styleSuggestionCaret = options.styleSuggestionCaret ?? (text => `\u001b[7m${text}\u001b[27m`);
+            this.#terminalRows = options.terminalRows ?? (() => 24);
+            this.#getVisualLineCount = options.getVisualLineCount;
+            this.#clearCommandSearchOnEscape = options.clearCommandSearchOnEscape === true;
+            this.#commandTunnels = options.commandTunnels ?? (() => []);
+        }
+        getRenderedBodyRowCount() { return this.#renderedBodyRowCount; }
+        setPromptSuggestion(text) {
+            this.#promptSuggestion = text;
+        }
+        canPresentPromptSuggestion() {
+            return this.#inputPresentation !== undefined
+                && this.focused
+                && !this.disableSubmit
+                && this.getText().length === 0
+                && !this.isShowingAutocomplete();
+        }
+        /** True when autocomplete is searching one space-free slash command that is the editor's only content. */
+        isTopLevelCommandSearch() {
+            if (!this.isShowingAutocomplete())
+                return false;
+            const text = this.getText();
+            if (!/^\/\S*$/.test(text))
+                return false;
+            const cursor = this.getCursor();
+            return cursor.line === 0 && cursor.col === text.length;
+        }
+        render(width) {
+            if (this.#inputPresentation === undefined) {
+                const rows = super.render(width);
+                this.#renderedBodyRowCount = this.#getVisualLineCount === undefined ? rows.length : this.#measureBodyRows(width);
+                return rows;
+            }
+            if (this.#promptSuggestion !== null && this.canPresentPromptSuggestion()) {
+                const rows = this.#renderSuggestion(width);
+                this.#renderedBodyRowCount = rows.length;
+                return rows;
+            }
+            return this.#renderPrefixedEditor(width);
+        }
+        onAction(action, handler) { this.actionHandlers.set(action, handler); }
+        handleInput(data) {
+            if (this.onExtensionShortcut?.(data))
+                return;
+            if (data === ":" && this.#completeSelectedCommandTunnel())
+                return;
+            if (this.#promptSuggestion !== null
+                && !this.isShowingAutocomplete()
+                && this.canPresentPromptSuggestion()
+                && this.keybindings.matches(data, "tui.input.submit")) {
+                return;
+            }
+            if (this.#promptSuggestion !== null
+                && !this.isShowingAutocomplete()
+                && this.canPresentPromptSuggestion()
+                && this.keybindings.matches(data, "tui.input.tab")) {
+                const accepted = this.#promptSuggestion;
+                this.#promptSuggestion = null;
+                super.setText(accepted);
+                this.onPromptSuggestionAccepted?.(accepted);
+                return;
+            }
+            if (this.keybindings.matches(data, "app.clipboard.pasteImage")) {
+                this.onPasteImage?.();
+                return;
+            }
+            if (this.keybindings.matches(data, "app.interrupt")) {
+                if (!this.isShowingAutocomplete()) {
+                    const handler = this.onEscape ?? this.actionHandlers.get("app.interrupt");
+                    if (handler) {
+                        handler();
+                        return;
+                    }
+                }
+                else if (this.#clearCommandSearchOnEscape && this.isTopLevelCommandSearch()) {
+                    // Escape on a bare slash-command search restores the empty prompt instead of only closing the menu.
+                    this.setText("");
+                    return;
+                }
+                super.handleInput(data);
+                return;
+            }
+            if (this.keybindings.matches(data, "app.exit") && this.getText().length === 0) {
+                const handler = this.onCtrlD ?? this.actionHandlers.get("app.exit");
+                if (handler)
+                    handler();
+                return;
+            }
+            if (this.keybindings.matches(data, "tui.editor.historyPrevious") || this.keybindings.matches(data, "tui.editor.historyNext")) {
+                super.handleInput(data);
+                return;
+            }
+            for (const [action, handler] of this.actionHandlers) {
+                if (action !== "app.interrupt" && action !== "app.exit" && this.keybindings.matches(data, action)) {
+                    handler();
+                    return;
+                }
+            }
+            super.handleInput(data);
+        }
+        /**
+         * Replace a sole top-level slash search whose selected row is a tunnel command with `/<command>:`
+         * and reopen the menu on the tunnel rows. The replacement goes through the public setText, which
+         * records the undo snapshot; every other colon stays ordinary text.
+         */
+        #completeSelectedCommandTunnel() {
+            if (!this.isTopLevelCommandSearch())
+                return false;
+            const selected = selectedAutocompleteValue(this);
+            if (selected === undefined || !this.#commandTunnels().includes(selected))
+                return false;
+            this.setText(`/${selected}:`);
+            triggerAutocomplete(this);
+            return true;
+        }
+        #renderSuggestion(width) {
+            const presentation = this.#inputPresentation;
+            const { paddingX, contentWidth, layoutWidth } = presentation.geometry(width, this.getPaddingX());
+            const chunks = wrapTextWithAnsi(this.#promptSuggestion ?? "", layoutWidth).map(text => ({ text }));
+            const maxVisible = Math.max(5, Math.floor(this.#terminalRows() * 0.3));
+            const visible = chunks.slice(0, maxVisible);
+            const leftPadding = " ".repeat(paddingX);
+            const rightPadding = leftPadding;
+            const rows = visible.map((chunk, index) => {
+                let content;
+                if (index === 0) {
+                    const first = [...PROMPT_GRAPHEMES.segment(chunk.text)][0]?.segment ?? " ";
+                    const remaining = chunk.text.slice(first === " " && chunk.text.length === 0 ? 0 : first.length);
+                    const marker = this.focused ? CURSOR_MARKER : "";
+                    content = `${marker}${this.#styleSuggestionCaret(first)}${this.#styleSuggestion(remaining)}`;
+                }
+                else {
+                    content = this.#styleSuggestion(chunk.text);
+                }
+                const plainWidth = visibleWidth(chunk.text);
+                const padding = " ".repeat(Math.max(0, contentWidth - plainWidth));
+                return `${leftPadding}${content}${padding}${rightPadding}`;
+            });
+            return presentation.render(width, () => ({ rows }));
+        }
+        #renderPrefixedEditor(width) {
+            return this.#inputPresentation.render(width, innerWidth => {
+                const rows = super.render(innerWidth);
+                this.#renderedBodyRowCount = this.#measureBodyRows(innerWidth);
+                const bottomBorder = this.#renderedBodyRowCount - 1;
+                return {
+                    rows: rows.slice(1, bottomBorder),
+                    topRule: rows[0],
+                    bottomRule: rows[bottomBorder],
+                    after: rows.slice(bottomBorder + 1),
+                };
+            }, true, this.getPaddingX());
+        }
+        #measureBodyRows(width) {
+            const padding = Math.min(this.getPaddingX(), Math.max(0, Math.floor((width - 1) / 2)));
+            const contentWidth = Math.max(1, width - padding * 2);
+            const layoutWidth = Math.max(1, contentWidth - (padding ? 0 : 1));
+            // Invariant: split by editor layout, never by styled border or completion text.
+            const lineCount = this.#getVisualLineCount?.(layoutWidth)
+                ?? this.getLines().reduce((count, line) => count + wrapTextWithAnsi(line, layoutWidth).length, 0);
+            return Math.min(Math.max(1, lineCount), Math.max(5, Math.floor(this.#terminalRows() * 0.3))) + 2;
+        }
+    };
+}
+export class OwnedEditor extends createOwnedEditorClass(Editor) {
+}
+/** The value of the row the open autocomplete list highlights, read from either editor's list. */
+function selectedAutocompleteValue(editor) {
+    const list = Reflect.get(editor, "autocompleteList");
+    if (typeof list !== "object" || list === null)
+        return undefined;
+    const getSelectedItem = Reflect.get(list, "getSelectedItem");
+    if (typeof getSelectedItem !== "function")
+        return undefined;
+    const item = getSelectedItem.call(list);
+    if (typeof item !== "object" || item === null)
+        return undefined;
+    const value = Reflect.get(item, "value");
+    return typeof value === "string" ? value : undefined;
+}
+/** Request the slash-command menu for the current text, as typing a command character would. */
+function triggerAutocomplete(editor) {
+    const trigger = Reflect.get(editor, "tryTriggerAutocomplete");
+    if (typeof trigger === "function")
+        trigger.call(editor);
+}

package/dist/integrations/pi/components/upstream/components/scoped-models-selector.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.87.1 (MIT), commit f07218c4d4bbc12bef056a7058c3dd49dfe41abe,
+ * packages/coding-agent/src/modes/interactive/components/scoped-models-selector.ts.
+ * Modifications: Source-synchronized scoped-model selector port: preserve session-only toggles,
+ * search, bulk/provider/reorder actions, dirty state, Ctrl+S persistence, refresh status,
+ * cancellation, and focus while remapping theme and public helper imports; local key labels preserve
+ * pinned platform formatting before layout without changing binding identities, and bare A1 uses the
+ * shared semantic modal shortcut row and compact padded modal frame.
+ * Deviations: owned-modal-shortcut-hints.
+ */
+interface ScopedModel {
+    readonly provider: string;
+    readonly id: string;
+    readonly name?: string;
+}
+import { Container, type Focusable, Input } from "@earendil-works/pi-tui";
+export interface ModelsConfig {
+    allModels: ScopedModel[];
+    enabledModelIds: string[] | null;
+    refreshStatus?: string;
+}
+export interface ModelsCallbacks {
+    /** Called whenever the enabled model set or order changes (session-only, no persist) */
+    onChange: (enabledModelIds: string[] | null) => void | Promise<void>;
+    /** Called when user wants to persist current selection to settings */
+    onPersist: (enabledModelIds: string[] | null) => void | Promise<void>;
+    onCancel: () => void;
+}
+/**
+ * Component for enabling/disabling models for Ctrl+P cycling.
+ * Changes are session-only until explicitly persisted with Ctrl+S.
+ */
+export declare class ScopedModelsSelectorComponent extends Container implements Focusable {
+    private modelsById;
+    private allIds;
+    private enabledIds;
+    private filteredItems;
+    private selectedIndex;
+    private searchInput;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    private listContainer;
+    private footerText;
+    private callbacks;
+    private maxVisible;
+    private isDirty;
+    private refreshStatusText?;
+    constructor(config: ModelsConfig, callbacks: ModelsCallbacks);
+    updateModels(models: readonly ScopedModel[], enabledModelIds?: string[] | null): void;
+    setRefreshStatus(message: string, kind: "muted" | "success" | "warning"): void;
+    private buildItems;
+    private getFooterText;
+    private refresh;
+    private notifyChange;
+    private updateList;
+    handleInput(data: string): void;
+    getSearchInput(): Input;
+}
+export {};

package/dist/integrations/pi/components/upstream/components/scoped-models-selector.js

@@ -0,0 +1,347 @@
+import { Container, fuzzyFilter, getKeybindings, Input, Key, matchesKey, Spacer, Text, } from "@earendil-works/pi-tui";
+import { DynamicBorder } from "../../../startup-public.js";
+import { getModelSearchText } from "../model-search.js";
+import { addPiModalHeader, adoptPiModalFrame } from "../../modal-frame.js";
+import { piTheme, renderPiModalShortcutHints } from "../../theme.js";
+// Rationale: upstream's capitalized hint formatter is private to the package; the same mapping lives here.
+function keyDisplayText(keybinding) {
+    return getKeybindings().getKeys(keybinding)
+        .map((key) => key.split("+").map((part) => {
+        const display = process.platform === "darwin" && part.toLowerCase() === "alt" ? "option" : part;
+        return display.charAt(0).toUpperCase() + display.slice(1);
+    }).join("+"))
+        .join("/");
+}
+const theme = new Proxy({}, {
+    get(_target, property) {
+        const active = piTheme();
+        const value = active[property];
+        return typeof value === "function" ? value.bind(active) : value;
+    },
+});
+function isEnabled(enabledIds, id) {
+    return enabledIds === null || enabledIds.includes(id);
+}
+/** Collapse an explicit list back to null (= all enabled) when it covers every available model. */
+function normalizeEnabled(result, allIds) {
+    return result.length === allIds.length && result.every((id) => allIds.includes(id)) ? null : result;
+}
+function toggle(enabledIds, allIds, id) {
+    if (enabledIds === null)
+        return allIds.filter((modelId) => modelId !== id);
+    const index = enabledIds.indexOf(id);
+    if (index >= 0)
+        return [...enabledIds.slice(0, index), ...enabledIds.slice(index + 1)];
+    return normalizeEnabled([...enabledIds, id], allIds);
+}
+function enableAll(enabledIds, allIds, targetIds) {
+    if (enabledIds === null)
+        return null; // Already all enabled
+    const targets = targetIds ?? allIds;
+    const result = [...enabledIds];
+    for (const id of targets) {
+        if (!result.includes(id))
+            result.push(id);
+    }
+    return normalizeEnabled(result, allIds);
+}
+function clearAll(enabledIds, allIds, targetIds) {
+    if (enabledIds === null) {
+        return targetIds ? allIds.filter((id) => !targetIds.includes(id)) : [];
+    }
+    const targets = new Set(targetIds ?? enabledIds);
+    return enabledIds.filter((id) => !targets.has(id));
+}
+function move(enabledIds, id, delta) {
+    if (enabledIds === null)
+        return null;
+    const list = [...enabledIds];
+    const index = list.indexOf(id);
+    if (index < 0)
+        return list;
+    const newIndex = index + delta;
+    if (newIndex < 0 || newIndex >= list.length)
+        return list;
+    const result = [...list];
+    const current = result[index];
+    result[index] = result[newIndex];
+    result[newIndex] = current;
+    return result;
+}
+function getSortedIds(enabledIds, allIds) {
+    if (enabledIds === null)
+        return allIds;
+    const enabledSet = new Set(enabledIds);
+    return [...enabledIds, ...allIds.filter((id) => !enabledSet.has(id))];
+}
+/**
+ * Component for enabling/disabling models for Ctrl+P cycling.
+ * Changes are session-only until explicitly persisted with Ctrl+S.
+ */
+export class ScopedModelsSelectorComponent extends Container {
+    modelsById = new Map();
+    allIds = [];
+    enabledIds = null;
+    filteredItems = [];
+    selectedIndex = 0;
+    searchInput;
+    // Focusable implementation - propagate to searchInput for IME cursor positioning
+    _focused = false;
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+        this.searchInput.focused = value;
+    }
+    listContainer;
+    footerText;
+    callbacks;
+    maxVisible = 8;
+    isDirty = false;
+    refreshStatusText;
+    constructor(config, callbacks) {
+        super();
+        this.callbacks = callbacks;
+        for (const model of config.allModels) {
+            const fullId = `${model.provider}/${model.id}`;
+            this.modelsById.set(fullId, model);
+            this.allIds.push(fullId);
+        }
+        this.enabledIds = config.enabledModelIds === null ? null : [...config.enabledModelIds];
+        this.filteredItems = this.buildItems();
+        // Header
+        const header = addPiModalHeader(this, new DynamicBorder(), new Text(theme.fg("accent", theme.bold("Model Configuration")), 0, 0));
+        const saveKey = keyDisplayText("app.models.save");
+        this.addChild(new Text(theme.fg("muted", "Session-only.")
+            + (saveKey ? ` ${renderPiModalShortcutHints([{ key: saveKey, action: "to save to settings." }])}` : ""), 0, 0));
+        this.addChild(new Spacer(1));
+        // Search input
+        this.searchInput = new Input();
+        this.addChild(this.searchInput);
+        this.addChild(new Spacer(1));
+        // List container
+        this.listContainer = new Container();
+        this.addChild(this.listContainer);
+        // Footer hint
+        this.addChild(new Spacer(1));
+        if (config.refreshStatus) {
+            this.refreshStatusText = new Text(theme.fg("muted", `  ${config.refreshStatus}`), 0, 0);
+            this.addChild(this.refreshStatusText);
+        }
+        this.footerText = new Text(this.getFooterText(), 0, 0);
+        this.addChild(this.footerText);
+        this.addChild(new DynamicBorder());
+        adoptPiModalFrame(this, { topIndex: 0, bottomIndex: this.children.length - 1, header });
+        this.updateList();
+    }
+    updateModels(models, enabledModelIds) {
+        const selectedId = this.filteredItems[this.selectedIndex]?.fullId;
+        if (enabledModelIds !== undefined)
+            this.enabledIds = enabledModelIds === null ? null : [...enabledModelIds];
+        this.modelsById.clear();
+        this.allIds = [];
+        for (const model of models) {
+            const fullId = `${model.provider}/${model.id}`;
+            this.modelsById.set(fullId, model);
+            this.allIds.push(fullId);
+        }
+        this.refresh();
+        const refreshedIndex = selectedId ? this.filteredItems.findIndex((item) => item.fullId === selectedId) : -1;
+        if (refreshedIndex >= 0) {
+            this.selectedIndex = refreshedIndex;
+            this.updateList();
+        }
+    }
+    setRefreshStatus(message, kind) {
+        this.refreshStatusText?.setText(theme.fg(kind, `  ${message}`));
+    }
+    buildItems() {
+        return getSortedIds(this.enabledIds, this.allIds).map((id) => ({
+            fullId: id,
+            model: this.modelsById.get(id),
+            enabled: isEnabled(this.enabledIds, id),
+        }));
+    }
+    getFooterText() {
+        const enabledCount = this.enabledIds?.filter((id) => this.modelsById.has(id)).length ?? this.allIds.length;
+        const unavailableCount = this.enabledIds?.filter((id) => !this.modelsById.has(id)).length ?? 0;
+        const allEnabled = this.enabledIds === null;
+        const countText = allEnabled
+            ? "all enabled"
+            : `${enabledCount}/${this.allIds.length} enabled${unavailableCount ? `, ${unavailableCount} unavailable` : ""}`;
+        const reorderKeys = [keyDisplayText("app.models.reorderUp"), keyDisplayText("app.models.reorderDown")].filter(Boolean).join("/");
+        const hint = renderPiModalShortcutHints([
+            { key: keyDisplayText("tui.select.confirm"), action: "toggle" },
+            { key: keyDisplayText("app.models.enableAll"), action: "all" },
+            { key: keyDisplayText("app.models.clearAll"), action: "clear" },
+            { key: keyDisplayText("app.models.toggleProvider"), action: "provider" },
+            { key: reorderKeys, action: "reorder" },
+            { key: keyDisplayText("app.models.save"), action: "save" },
+            { action: countText },
+        ]);
+        return this.isDirty ? `${hint} ${theme.fg("warning", "(unsaved)")}` : hint;
+    }
+    refresh() {
+        const query = this.searchInput.getValue();
+        const items = this.buildItems();
+        this.filteredItems = query
+            ? fuzzyFilter(items, query, (item) => item.model
+                ? getModelSearchText({
+                    id: item.model.id,
+                    provider: item.model.provider,
+                    ...(item.model.name === undefined ? {} : { name: item.model.name }),
+                })
+                : item.fullId)
+            : items;
+        this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredItems.length - 1));
+        this.updateList();
+        this.footerText.setText(this.getFooterText());
+    }
+    notifyChange() {
+        this.callbacks.onChange(this.enabledIds === null ? null : [...this.enabledIds]);
+    }
+    updateList() {
+        this.listContainer.clear();
+        if (this.filteredItems.length === 0) {
+            this.listContainer.addChild(new Text(theme.fg("muted", "  No matching models"), 0, 0));
+            return;
+        }
+        const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.filteredItems.length - this.maxVisible));
+        const endIndex = Math.min(startIndex + this.maxVisible, this.filteredItems.length);
+        for (let i = startIndex; i < endIndex; i++) {
+            const item = this.filteredItems[i];
+            const isSelected = i === this.selectedIndex;
+            const prefix = isSelected ? theme.fg("accent", "→ ") : "  ";
+            const id = item.model?.id ?? item.fullId;
+            const styledId = item.model ? id : theme.strikethrough(id);
+            const modelText = isSelected ? theme.fg("accent", styledId) : styledId;
+            const providerBadge = theme.fg("muted", item.model ? ` [${item.model.provider}]` : " [unavailable]");
+            const status = item.model && item.enabled ? theme.fg("accent", "✓ ") : "  ";
+            this.listContainer.addChild(new Text(`${prefix}${status}${modelText}${providerBadge}`, 0, 0));
+        }
+        // Add scroll indicator if needed
+        if (startIndex > 0 || endIndex < this.filteredItems.length) {
+            this.listContainer.addChild(new Text(theme.fg("muted", `  (${this.selectedIndex + 1}/${this.filteredItems.length})`), 0, 0));
+        }
+        if (this.filteredItems.length > 0) {
+            const selected = this.filteredItems[this.selectedIndex];
+            this.listContainer.addChild(new Spacer(1));
+            this.listContainer.addChild(new Text(theme.fg("muted", `  ${selected.model ? `Model Name: ${selected.model.name}` : "Model unavailable"}`), 0, 0));
+        }
+    }
+    handleInput(data) {
+        const kb = getKeybindings();
+        // Navigation
+        if (kb.matches(data, "tui.select.up")) {
+            if (this.filteredItems.length === 0)
+                return;
+            this.selectedIndex = this.selectedIndex === 0 ? this.filteredItems.length - 1 : this.selectedIndex - 1;
+            this.updateList();
+            return;
+        }
+        if (kb.matches(data, "tui.select.down")) {
+            if (this.filteredItems.length === 0)
+                return;
+            this.selectedIndex = this.selectedIndex === this.filteredItems.length - 1 ? 0 : this.selectedIndex + 1;
+            this.updateList();
+            return;
+        }
+        // Reorder enabled models
+        const reorderUp = kb.matches(data, "app.models.reorderUp");
+        const reorderDown = kb.matches(data, "app.models.reorderDown");
+        if (reorderUp || reorderDown) {
+            if (this.enabledIds === null)
+                return;
+            const item = this.filteredItems[this.selectedIndex];
+            if (item && isEnabled(this.enabledIds, item.fullId)) {
+                const delta = reorderUp ? -1 : 1;
+                const currentIndex = this.enabledIds.indexOf(item.fullId);
+                const newIndex = currentIndex + delta;
+                // Only move if within bounds
+                if (newIndex >= 0 && newIndex < this.enabledIds.length) {
+                    this.enabledIds = move(this.enabledIds, item.fullId, delta);
+                    this.isDirty = true;
+                    this.selectedIndex += delta;
+                    this.refresh();
+                    this.notifyChange();
+                }
+            }
+            return;
+        }
+        // Toggle on Enter
+        if (kb.matches(data, "tui.select.confirm")) {
+            const item = this.filteredItems[this.selectedIndex];
+            if (item) {
+                this.enabledIds = toggle(this.enabledIds, this.allIds, item.fullId);
+                this.isDirty = true;
+                this.refresh();
+                this.notifyChange();
+            }
+            return;
+        }
+        // Enable all (filtered if search active, otherwise all)
+        if (kb.matches(data, "app.models.enableAll")) {
+            const targetIds = this.searchInput.getValue() ? this.filteredItems.map((i) => i.fullId) : undefined;
+            this.enabledIds = enableAll(this.enabledIds, this.allIds, targetIds);
+            this.isDirty = true;
+            this.refresh();
+            this.notifyChange();
+            return;
+        }
+        // Clear all (filtered if search active, otherwise all)
+        if (kb.matches(data, "app.models.clearAll")) {
+            const targetIds = this.searchInput.getValue() ? this.filteredItems.map((i) => i.fullId) : undefined;
+            this.enabledIds = clearAll(this.enabledIds, this.allIds, targetIds);
+            this.isDirty = true;
+            this.refresh();
+            this.notifyChange();
+            return;
+        }
+        // Toggle provider of current item
+        if (kb.matches(data, "app.models.toggleProvider")) {
+            const item = this.filteredItems[this.selectedIndex];
+            if (item?.model) {
+                const provider = item.model.provider;
+                const providerIds = this.allIds.filter((id) => this.modelsById.get(id).provider === provider);
+                const allEnabled = providerIds.every((id) => isEnabled(this.enabledIds, id));
+                this.enabledIds = allEnabled
+                    ? clearAll(this.enabledIds, this.allIds, providerIds)
+                    : enableAll(this.enabledIds, this.allIds, providerIds);
+                this.isDirty = true;
+                this.refresh();
+                this.notifyChange();
+            }
+            return;
+        }
+        // Save/persist to settings
+        if (kb.matches(data, "app.models.save")) {
+            this.callbacks.onPersist(this.enabledIds === null ? null : [...this.enabledIds]);
+            this.isDirty = false;
+            this.footerText.setText(this.getFooterText());
+            return;
+        }
+        // Ctrl+C - clear search or cancel if empty
+        if (matchesKey(data, Key.ctrl("c"))) {
+            if (this.searchInput.getValue()) {
+                this.searchInput.setValue("");
+                this.refresh();
+            }
+            else {
+                this.callbacks.onCancel();
+            }
+            return;
+        }
+        // Escape - cancel
+        if (matchesKey(data, Key.escape)) {
+            this.callbacks.onCancel();
+            return;
+        }
+        // Pass everything else to search input
+        this.searchInput.handleInput(data);
+        this.refresh();
+    }
+    getSearchInput() {
+        return this.searchInput;
+    }
+}