@timurproko/a1 0.1.8-dev.49ff83a → 0.1.8-dev.508

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

@@ -0,0 +1,187 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.85.1 (MIT), commit d981de1229ef899957bbe968bc8dcda02a21f477,
+ * 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.
+ * Deviations: owned-shared-input-frame, above-prompt-autocomplete-placement,
+ * clear-command-search-on-escape.
+ */
+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;
+        #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;
+        }
+        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;
+        }
+        setText(text) {
+            if (text.length > 0)
+                this.#promptSuggestion = null;
+            super.setText(text);
+        }
+        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 (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);
+        }
+        #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) {
+}

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

@@ -0,0 +1,59 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.85.1 (MIT), commit d981de1229ef899957bbe968bc8dcda02a21f477,
+ * 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.
+ * Deviations: none.
+ */
+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,346 @@
+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 { piTheme } from "../theme/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
+        this.addChild(new DynamicBorder());
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(theme.fg("accent", theme.bold("Model Configuration")), 0, 0));
+        this.addChild(new Text(theme.fg("muted", `Session-only. ${keyDisplayText("app.models.save")} 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());
+        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 parts = [
+            `${keyDisplayText("tui.select.confirm")} toggle`,
+            `${keyDisplayText("app.models.enableAll")} all`,
+            `${keyDisplayText("app.models.clearAll")} clear`,
+            `${keyDisplayText("app.models.toggleProvider")} provider`,
+            `${keyDisplayText("app.models.reorderUp")}/${keyDisplayText("app.models.reorderDown")} reorder`,
+            `${keyDisplayText("app.models.save")} save`,
+            countText,
+        ];
+        return this.isDirty
+            ? theme.fg("dim", `  ${parts.join(" · ")} `) + theme.fg("warning", "(unsaved)")
+            : theme.fg("dim", `  ${parts.join(" · ")}`);
+    }
+    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;
+    }
+}

package/dist/integrations/pi/components/upstream/components/session-footer.d.ts

@@ -0,0 +1,11 @@
+import { type Component } from "@earendil-works/pi-tui";
+import type { OwnedUiSessionViewModel } from "../../../../../contracts/owned-ui/index.js";
+export declare class SessionFooter implements Component {
+    private readonly getView;
+    private readonly cwd;
+    private readonly profile;
+    constructor(getView: () => OwnedUiSessionViewModel, cwd: string, profile?: "pi" | "a1");
+    invalidate(): void;
+    dispose(): void;
+    render(width: number): string[];
+}