@andorra-labs/code 0.0.0-stage → 0.1.4

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/components/settings-submenu.d.ts

@@ -0,0 +1,71 @@
+import { AndorraContainer, type SelectItem, type SelectListLayoutOptions } from "../../../../tui/index.js";
+export interface SelectSubmenuOptions {
+    /** Enable type-to-search fuzzy filtering. */
+    searchable?: boolean;
+    /** Override the select list layout (column widths). */
+    layout?: SelectListLayoutOptions;
+}
+/**
+ * Single-step submenu that shows a titled select list.
+ * With `searchable: true`, typing filters the list using fuzzy matching.
+ */
+export declare class AndorraSelectSubmenu extends AndorraContainer {
+    private selectList;
+    private listChildIndex;
+    private allOptions;
+    private listLayout;
+    private searchInput;
+    private onSelectCb;
+    private onCancelCb;
+    private onSelectionChangeCb?;
+    constructor(title: string, description: string, options: SelectItem[], currentValue: string, onSelect: (value: string) => void, onCancel: () => void, onSelectionChange?: (value: string) => void, submenuOptions?: SelectSubmenuOptions);
+    private buildSelectList;
+    private applyFilter;
+    handleInput(data: string): void;
+}
+/** One step in a {@link SteppedSubmenu}. */
+export interface SteppedSubmenuStep {
+    /** Unique key \u2014 the selected value is stored in the result context under this key. */
+    key: string;
+    /** Title shown at the top of the step. Receives prior selections. */
+    title: string | ((context: Record<string, string>) => string);
+    /** Description shown below the title. Receives prior selections. */
+    description: string | ((context: Record<string, string>) => string);
+    /** Build the option list for this step. Called fresh each time the step is shown. */
+    options: (context: Record<string, string>) => SelectItem[];
+    /** Optionally pre-select a value when entering this step. */
+    preselect?: (context: Record<string, string>) => string | undefined;
+    /** Enable type-to-search fuzzy filtering for this step. */
+    searchable?: boolean;
+    /** Override the select list layout (column widths) for this step. */
+    layout?: SelectListLayoutOptions;
+}
+interface SteppedSubmenuOptions {
+    /** Start at this step index (0-based), skipping earlier steps. Requires initialContext for skipped keys. */
+    startAtStep?: number;
+    /** Pre-fill selections for skipped steps. */
+    initialContext?: Record<string, string>;
+    /** After completing the last step, loop back to step 0 instead of closing. */
+    loop?: boolean;
+}
+/**
+ * Generic N-step submenu built on top of {@link SelectSubmenu}.
+ *
+ * Each step's options can depend on prior selections via the shared context.
+ * Esc goes back one step; Esc at step 0 cancels.
+ * With `loop: true`, completing the final step invokes `onComplete` then returns to step 0.
+ */
+export declare class AndorraSteppedSubmenu extends AndorraContainer {
+    private readonly steps;
+    private readonly onComplete;
+    private readonly onCancel;
+    private readonly opts;
+    private activeComponent;
+    private context;
+    constructor(steps: SteppedSubmenuStep[], onComplete: (context: Record<string, string>) => void, onCancel: () => void, opts?: SteppedSubmenuOptions);
+    private buildStep;
+    render(width: number): string[];
+    handleInput(data: string): void;
+    invalidate(): void;
+}
+export {};

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/components/settings-submenu.js

@@ -0,0 +1,164 @@
+import { AndorraContainer, andorraFuzzyFilter, andorraGetKeybindings, AndorraInput, AndorraSelectList, AndorraSpacer, AndorraText, } from "../../../../tui/index.js";
+import { andorraGetSelectListTheme, theme } from "../theme/theme.js";
+const SUBMENU_SELECT_LIST_LAYOUT = {
+    minPrimaryColumnWidth: 12,
+    maxPrimaryColumnWidth: 32,
+};
+/**
+ * Single-step submenu that shows a titled select list.
+ * With `searchable: true`, typing filters the list using fuzzy matching.
+ */
+export class AndorraSelectSubmenu extends AndorraContainer {
+    selectList;
+    listChildIndex;
+    allOptions;
+    listLayout;
+    searchInput;
+    onSelectCb;
+    onCancelCb;
+    onSelectionChangeCb;
+    constructor(title, description, options, currentValue, onSelect, onCancel, onSelectionChange, submenuOptions) {
+        super();
+        this.allOptions = options;
+        this.listLayout = submenuOptions?.layout ?? SUBMENU_SELECT_LIST_LAYOUT;
+        this.onSelectCb = onSelect;
+        this.onCancelCb = onCancel;
+        this.onSelectionChangeCb = onSelectionChange;
+        // Title
+        this.addChild(new AndorraText(theme.bold(theme.fg("accent", title)), 0, 0));
+        // Description
+        if (description) {
+            this.addChild(new AndorraSpacer(1));
+            this.addChild(new AndorraText(theme.fg("muted", description), 0, 0));
+        }
+        // Search input
+        if (submenuOptions?.searchable) {
+            this.addChild(new AndorraSpacer(1));
+            this.searchInput = new AndorraInput();
+            this.searchInput.onSubmit = () => {
+                this.selectList.handleInput("\r");
+            };
+            this.addChild(this.searchInput);
+        }
+        // Spacer
+        this.addChild(new AndorraSpacer(1));
+        // Select list
+        this.selectList = this.buildSelectList(options, currentValue);
+        this.listChildIndex = this.children.length;
+        this.addChild(this.selectList);
+        // Hint
+        this.addChild(new AndorraSpacer(1));
+        const hint = submenuOptions?.searchable
+            ? "  Type to filter \u00b7 Enter to select \u00b7 Esc to go back"
+            : "  Enter to select \u00b7 Esc to go back";
+        this.addChild(new AndorraText(theme.fg("dim", hint), 0, 0));
+    }
+    buildSelectList(options, preselect) {
+        const list = new AndorraSelectList(options, Math.min(options.length, 10), andorraGetSelectListTheme(), this.listLayout);
+        const idx = options.findIndex((o) => o.value === preselect);
+        if (idx !== -1)
+            list.setSelectedIndex(idx);
+        list.onSelect = (item) => this.onSelectCb(item.value);
+        list.onCancel = this.onCancelCb;
+        if (this.onSelectionChangeCb) {
+            const cb = this.onSelectionChangeCb;
+            list.onSelectionChange = (item) => cb(item.value);
+        }
+        return list;
+    }
+    applyFilter(query) {
+        const filtered = query
+            ? andorraFuzzyFilter(this.allOptions, query, (item) => `${item.label} ${item.description ?? ""}`)
+            : this.allOptions;
+        const newList = this.buildSelectList(filtered, "");
+        this.children[this.listChildIndex] = newList;
+        this.selectList = newList;
+    }
+    handleInput(data) {
+        if (this.searchInput) {
+            const kb = andorraGetKeybindings();
+            const isNav = kb.matches(data, "tui.select.up") ||
+                kb.matches(data, "tui.select.down") ||
+                kb.matches(data, "tui.select.confirm") ||
+                kb.matches(data, "tui.select.cancel");
+            if (isNav) {
+                this.selectList.handleInput(data);
+            }
+            else {
+                this.searchInput.handleInput(data);
+                this.applyFilter(this.searchInput.getValue());
+            }
+        }
+        else {
+            this.selectList.handleInput(data);
+        }
+    }
+}
+/**
+ * Generic N-step submenu built on top of {@link SelectSubmenu}.
+ *
+ * Each step's options can depend on prior selections via the shared context.
+ * Esc goes back one step; Esc at step 0 cancels.
+ * With `loop: true`, completing the final step invokes `onComplete` then returns to step 0.
+ */
+export class AndorraSteppedSubmenu extends AndorraContainer {
+    steps;
+    onComplete;
+    onCancel;
+    opts;
+    activeComponent;
+    context;
+    constructor(steps, onComplete, onCancel, opts = {}) {
+        super();
+        this.steps = steps;
+        this.onComplete = onComplete;
+        this.onCancel = onCancel;
+        this.opts = opts;
+        this.context = { ...(opts.initialContext ?? {}) };
+        this.activeComponent = this.buildStep(opts.startAtStep ?? 0);
+    }
+    buildStep(stepIndex) {
+        const step = this.steps[stepIndex];
+        const total = this.steps.length;
+        const stepLabel = total > 1 ? `Step ${stepIndex + 1}/${total} \u00b7 ` : "";
+        const title = typeof step.title === "function" ? step.title(this.context) : step.title;
+        const desc = typeof step.description === "function" ? step.description(this.context) : step.description;
+        const items = step.options(this.context);
+        const preselect = step.preselect?.(this.context) ?? "";
+        return new AndorraSelectSubmenu(title, `${stepLabel}${desc}`, items, preselect, (value) => {
+            this.context[step.key] = value;
+            if (stepIndex < total - 1) {
+                // Advance to next step
+                this.activeComponent = this.buildStep(stepIndex + 1);
+            }
+            else {
+                // Final step \u2014 deliver result
+                this.onComplete({ ...this.context });
+                if (this.opts.loop) {
+                    this.context = {};
+                    this.activeComponent = this.buildStep(0);
+                }
+                else {
+                    this.onCancel();
+                }
+            }
+        }, () => {
+            if (stepIndex > 0) {
+                delete this.context[step.key];
+                this.activeComponent = this.buildStep(stepIndex - 1);
+            }
+            else {
+                this.onCancel();
+            }
+        }, undefined, step.searchable || step.layout ? { searchable: step.searchable, layout: step.layout } : undefined);
+    }
+    render(width) {
+        return this.activeComponent.render(width);
+    }
+    handleInput(data) {
+        this.activeComponent.handleInput?.(data);
+    }
+    invalidate() {
+        this.activeComponent.invalidate?.();
+    }
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/components/show-images-selector.d.ts

@@ -0,0 +1,9 @@
+import { AndorraContainer, AndorraSelectList } from "../../../../tui/index.js";
+/**
+ * Component that renders a show images selector with borders
+ */
+export declare class AndorraShowImagesSelectorComponent extends AndorraContainer {
+    private selectList;
+    constructor(currentValue: boolean, onSelect: (show: boolean) => void, onCancel: () => void);
+    getSelectList(): AndorraSelectList;
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/components/show-images-selector.js

@@ -0,0 +1,38 @@
+import { AndorraContainer, AndorraSelectList } from "../../../../tui/index.js";
+import { andorraGetSelectListTheme } from "../theme/theme.js";
+import { AndorraDynamicBorder } from "./dynamic-border.js";
+const SHOW_IMAGES_SELECT_LIST_LAYOUT = {
+    minPrimaryColumnWidth: 12,
+    maxPrimaryColumnWidth: 32,
+};
+/**
+ * Component that renders a show images selector with borders
+ */
+export class AndorraShowImagesSelectorComponent extends AndorraContainer {
+    selectList;
+    constructor(currentValue, onSelect, onCancel) {
+        super();
+        const items = [
+            { value: "yes", label: "Yes", description: "Show images inline in terminal" },
+            { value: "no", label: "No", description: "Show text placeholder instead" },
+        ];
+        // Add top border
+        this.addChild(new AndorraDynamicBorder());
+        // Create selector
+        this.selectList = new AndorraSelectList(items, 5, andorraGetSelectListTheme(), SHOW_IMAGES_SELECT_LIST_LAYOUT);
+        // Preselect current value
+        this.selectList.setSelectedIndex(currentValue ? 0 : 1);
+        this.selectList.onSelect = (item) => {
+            onSelect(item.value === "yes");
+        };
+        this.selectList.onCancel = () => {
+            onCancel();
+        };
+        this.addChild(this.selectList);
+        // Add bottom border
+        this.addChild(new AndorraDynamicBorder());
+    }
+    getSelectList() {
+        return this.selectList;
+    }
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/components/skill-invocation-message.d.ts

@@ -0,0 +1,16 @@
+import { AndorraBox, type MarkdownTheme } from "../../../../tui/index.js";
+import type { ParsedSkillBlock } from "../../../core/agent-session.js";
+/**
+ * Component that renders a skill invocation message with collapsed/expanded state.
+ * Uses same background color as custom messages for visual consistency.
+ * Only renders the skill block itself - user message is rendered separately.
+ */
+export declare class AndorraSkillInvocationMessageComponent extends AndorraBox {
+    private expanded;
+    private skillBlock;
+    private markdownTheme;
+    constructor(skillBlock: ParsedSkillBlock, markdownTheme?: MarkdownTheme);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+    private updateDisplay;
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/components/skill-invocation-message.js

@@ -0,0 +1,53 @@
+import { AndorraBox, AndorraContainer, AndorraMarkdown, AndorraMouseRegion, AndorraText } from "../../../../tui/index.js";
+import { andorraGetMarkdownTheme, theme } from "../theme/theme.js";
+import { andorraKeyText } from "./keybinding-hints.js";
+/**
+ * Component that renders a skill invocation message with collapsed/expanded state.
+ * Uses same background color as custom messages for visual consistency.
+ * Only renders the skill block itself - user message is rendered separately.
+ */
+export class AndorraSkillInvocationMessageComponent extends AndorraBox {
+    expanded = false;
+    skillBlock;
+    markdownTheme;
+    constructor(skillBlock, markdownTheme = andorraGetMarkdownTheme()) {
+        super(1, 1, (t) => theme.bg("customMessageBg", t));
+        this.skillBlock = skillBlock;
+        this.markdownTheme = markdownTheme;
+        this.updateDisplay();
+    }
+    setExpanded(expanded) {
+        this.expanded = expanded;
+        this.updateDisplay();
+    }
+    invalidate() {
+        super.invalidate();
+        this.updateDisplay();
+    }
+    updateDisplay() {
+        this.clear();
+        const content = new AndorraContainer();
+        if (this.expanded) {
+            // Expanded: label + skill name header + full content
+            const label = theme.fg("customMessageLabel", `\x1b[1m[skill]\x1b[22m`);
+            content.addChild(new AndorraText(label, 0, 0));
+            const header = `**${this.skillBlock.name}**\n\n`;
+            content.addChild(new AndorraMarkdown(header + this.skillBlock.content, 0, 0, this.markdownTheme, {
+                color: (text) => theme.fg("customMessageText", text),
+            }));
+        }
+        else {
+            // Collapsed: single line - [skill] name (hint to expand)
+            const line = theme.fg("customMessageLabel", `\x1b[1m[skill]\x1b[22m `) +
+                theme.fg("customMessageText", this.skillBlock.name) +
+                theme.fg("dim", ` (${andorraKeyText("app.tools.expand")} to expand)`);
+            content.addChild(new AndorraText(line, 0, 0));
+        }
+        this.addChild(new AndorraMouseRegion(content, (event) => {
+            if (event.type !== "click" || event.button !== "left")
+                return undefined;
+            this.setExpanded(!this.expanded);
+            return { handled: true };
+        }));
+    }
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/components/status-indicator.d.ts

@@ -0,0 +1,29 @@
+import { type Component, AndorraLoader, type TUI } from "../../../../tui/index.js";
+import type { WorkingIndicatorOptions } from "../../../core/extensions/index.js";
+export type StatusIndicatorKind = "working" | "retry" | "compaction" | "branchSummary";
+export declare class AndorraStatusIndicator extends AndorraLoader {
+    readonly kind: StatusIndicatorKind;
+    constructor(kind: StatusIndicatorKind, ui: TUI, spinnerColorFn: (str: string) => string, messageColorFn: (str: string) => string, message: string, indicator?: WorkingIndicatorOptions);
+    renderInBorder(width: number): string;
+    renderSpinnerInBorder(width: number): string;
+    dispose(): void;
+}
+export declare class AndorraWorkingStatusIndicator extends AndorraStatusIndicator {
+    constructor(ui: TUI, message: string, indicator?: WorkingIndicatorOptions, colorFn?: (text: string) => string);
+}
+export declare class AndorraRetryStatusIndicator extends AndorraStatusIndicator {
+    private countdown;
+    constructor(ui: TUI, attempt: number, maxAttempts: number, delayMs: number);
+    dispose(): void;
+}
+export type CompactionStatusReason = "manual" | "threshold" | "overflow";
+export declare class AndorraCompactionStatusIndicator extends AndorraStatusIndicator {
+    constructor(ui: TUI, reason: CompactionStatusReason);
+}
+export declare class AndorraBranchSummaryStatusIndicator extends AndorraStatusIndicator {
+    constructor(ui: TUI);
+}
+export declare class AndorraIdleStatus implements Component {
+    invalidate(): void;
+    render(width: number): string[];
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/components/status-indicator.js

@@ -0,0 +1,66 @@
+import { AndorraLoader, andorraTruncateToWidth } from "../../../../tui/index.js";
+import { theme } from "../theme/theme.js";
+import { AndorraCountdownTimer } from "./countdown-timer.js";
+import { andorraKeyText } from "./keybinding-hints.js";
+export class AndorraStatusIndicator extends AndorraLoader {
+    kind;
+    constructor(kind, ui, spinnerColorFn, messageColorFn, message, indicator) {
+        super(ui, spinnerColorFn, messageColorFn, message, indicator);
+        this.kind = kind;
+    }
+    renderInBorder(width) {
+        const line = super.render(width + 2)[1] ?? "";
+        return andorraTruncateToWidth(line.startsWith(" ") ? line.slice(1).trimEnd() : line.trimEnd(), width, "");
+    }
+    renderSpinnerInBorder(width) {
+        return andorraTruncateToWidth(this.getRenderedIndicator(), width, "");
+    }
+    dispose() {
+        this.stop();
+    }
+}
+export class AndorraWorkingStatusIndicator extends AndorraStatusIndicator {
+    constructor(ui, message, indicator, colorFn) {
+        super("working", ui, colorFn ?? ((text) => theme.fg("accent", text)), colorFn ?? ((text) => theme.fg("muted", text)), message, indicator);
+    }
+}
+export class AndorraRetryStatusIndicator extends AndorraStatusIndicator {
+    countdown;
+    constructor(ui, attempt, maxAttempts, delayMs) {
+        const andorraRetryMessage = (seconds) => `Retrying (${attempt}/${maxAttempts}) in ${seconds}s... (${andorraKeyText("app.interrupt")} to cancel)`;
+        super("retry", ui, (spinner) => theme.fg("warning", spinner), (text) => theme.fg("muted", text), andorraRetryMessage(Math.ceil(delayMs / 1000)));
+        this.countdown = new AndorraCountdownTimer(delayMs, ui, (seconds) => {
+            this.setMessage(andorraRetryMessage(seconds));
+        }, () => {
+            this.countdown = undefined;
+        });
+    }
+    dispose() {
+        this.countdown?.dispose();
+        this.countdown = undefined;
+        super.dispose();
+    }
+}
+export class AndorraCompactionStatusIndicator extends AndorraStatusIndicator {
+    constructor(ui, reason) {
+        const cancelHint = `(${andorraKeyText("app.interrupt")} to cancel)`;
+        const label = reason === "manual"
+            ? `Compacting context... ${cancelHint}`
+            : `${reason === "overflow" ? "Context overflow detected, " : ""}Auto-compacting... ${cancelHint}`;
+        super("compaction", ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), label);
+    }
+}
+export class AndorraBranchSummaryStatusIndicator extends AndorraStatusIndicator {
+    constructor(ui) {
+        super("branchSummary", ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), `Summarizing branch... (${andorraKeyText("app.interrupt")} to cancel)`);
+    }
+}
+export class AndorraIdleStatus {
+    invalidate() {
+        // No cached state to invalidate.
+    }
+    render(width) {
+        const emptyLine = " ".repeat(width);
+        return [emptyLine, emptyLine];
+    }
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/components/theme-selector.d.ts

@@ -0,0 +1,10 @@
+import { AndorraContainer, AndorraSelectList } from "../../../../tui/index.js";
+/**
+ * Component that renders a theme selector
+ */
+export declare class AndorraThemeSelectorComponent extends AndorraContainer {
+    private selectList;
+    private onPreview;
+    constructor(currentTheme: string, onSelect: (themeName: string) => void, onCancel: () => void, onPreview: (themeName: string) => void);
+    getSelectList(): AndorraSelectList;
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/components/theme-selector.js

@@ -0,0 +1,49 @@
+import { AndorraContainer, AndorraSelectList } from "../../../../tui/index.js";
+import { andorraGetAvailableThemes, andorraGetSelectListTheme } from "../theme/theme.js";
+import { AndorraDynamicBorder } from "./dynamic-border.js";
+const THEME_SELECT_LIST_LAYOUT = {
+    minPrimaryColumnWidth: 12,
+    maxPrimaryColumnWidth: 32,
+};
+/**
+ * Component that renders a theme selector
+ */
+export class AndorraThemeSelectorComponent extends AndorraContainer {
+    selectList;
+    onPreview;
+    constructor(currentTheme, onSelect, onCancel, onPreview) {
+        super();
+        this.onPreview = onPreview;
+        // Get available themes and create select items
+        const themes = andorraGetAvailableThemes();
+        const themeItems = themes.map((name) => ({
+            value: name,
+            label: name,
+            description: name === currentTheme ? "(current)" : undefined,
+        }));
+        // Add top border
+        this.addChild(new AndorraDynamicBorder());
+        // Create selector
+        this.selectList = new AndorraSelectList(themeItems, 10, andorraGetSelectListTheme(), THEME_SELECT_LIST_LAYOUT);
+        // Preselect current theme
+        const currentIndex = themes.indexOf(currentTheme);
+        if (currentIndex !== -1) {
+            this.selectList.setSelectedIndex(currentIndex);
+        }
+        this.selectList.onSelect = (item) => {
+            onSelect(item.value);
+        };
+        this.selectList.onCancel = () => {
+            onCancel();
+        };
+        this.selectList.onSelectionChange = (item) => {
+            this.onPreview(item.value);
+        };
+        this.addChild(this.selectList);
+        // Add bottom border
+        this.addChild(new AndorraDynamicBorder());
+    }
+    getSelectList() {
+        return this.selectList;
+    }
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/components/thinking-selector.d.ts

@@ -0,0 +1,22 @@
+import type { ThinkingLevel } from "../../../../agent/index.js";
+import { AndorraContainer, type Focusable, AndorraSelectList } from "../../../../tui/index.js";
+/**
+ * Component that renders a thinking level selector with borders
+ */
+export declare class AndorraThinkingSelectorComponent extends AndorraContainer implements Focusable {
+    private searchInput;
+    private selectList;
+    private selectListChildIndex;
+    private allItems;
+    private onSelect;
+    private onCancel;
+    private onSelectAsDefault?;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    constructor(currentLevel: ThinkingLevel, availableLevels: ThinkingLevel[], onSelect: (level: ThinkingLevel) => void, onCancel: () => void, onSelectAsDefault?: (level: ThinkingLevel) => void, defaultThinkingLevel?: ThinkingLevel);
+    private buildSelectList;
+    private applyFilter;
+    handleInput(keyData: string): void;
+    getSelectList(): AndorraSelectList;
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/components/thinking-selector.js

@@ -0,0 +1,108 @@
+import { AndorraContainer, andorraFuzzyFilter, andorraGetKeybindings, AndorraInput, AndorraSelectList, AndorraSpacer, AndorraText, } from "../../../../tui/index.js";
+import { andorraGetSelectListTheme, theme } from "../theme/theme.js";
+import { AndorraDynamicBorder } from "./dynamic-border.js";
+import { andorraKeyDisplayText } from "./keybinding-hints.js";
+const THINKING_SELECT_LIST_LAYOUT = {
+    minPrimaryColumnWidth: 12,
+    maxPrimaryColumnWidth: 32,
+};
+const LEVEL_DESCRIPTIONS = {
+    off: "No reasoning",
+    minimal: "Very brief reasoning (~1k tokens)",
+    low: "Light reasoning (~2k tokens)",
+    medium: "Moderate reasoning (~8k tokens)",
+    high: "Deep reasoning (~16k tokens)",
+    xhigh: "Extra-high reasoning (~32k tokens)",
+    max: "Maximum reasoning",
+};
+/**
+ * Component that renders a thinking level selector with borders
+ */
+export class AndorraThinkingSelectorComponent extends AndorraContainer {
+    searchInput;
+    selectList;
+    selectListChildIndex;
+    allItems;
+    onSelect;
+    onCancel;
+    onSelectAsDefault;
+    _focused = false;
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+        this.searchInput.focused = value;
+    }
+    constructor(currentLevel, availableLevels, onSelect, onCancel, onSelectAsDefault, defaultThinkingLevel) {
+        super();
+        this.onSelect = onSelect;
+        this.onCancel = onCancel;
+        this.onSelectAsDefault = onSelectAsDefault;
+        this.allItems = availableLevels.map((level) => ({
+            value: level,
+            label: `${level === currentLevel ? "✓ " : "  "}${level}`,
+            description: level === defaultThinkingLevel ? `${LEVEL_DESCRIPTIONS[level]} · default` : LEVEL_DESCRIPTIONS[level],
+        }));
+        // Add top border
+        this.addChild(new AndorraDynamicBorder());
+        this.addChild(new AndorraSpacer(1));
+        this.addChild(new AndorraText("Thinking Level", 0, 0));
+        this.addChild(new AndorraSpacer(1));
+        this.addChild(new AndorraText(`${andorraKeyDisplayText("app.thinking.cycle")} cycles thinking levels in-session`, 0, 0));
+        this.addChild(new AndorraSpacer(1));
+        this.searchInput = new AndorraInput();
+        this.searchInput.onSubmit = () => this.selectList.handleInput("\r");
+        this.addChild(this.searchInput);
+        this.addChild(new AndorraSpacer(1));
+        // Create selector
+        this.selectList = this.buildSelectList(this.allItems, currentLevel);
+        this.selectListChildIndex = this.children.length;
+        this.addChild(this.selectList);
+        this.addChild(new AndorraSpacer(1));
+        this.addChild(new AndorraText(theme.fg("dim", `  ${andorraKeyDisplayText("tui.select.confirm")} to select · ${andorraKeyDisplayText("app.thinking.save")} to set as default · ${andorraKeyDisplayText("tui.select.cancel")} to cancel`), 0, 0));
+        // Add bottom border
+        this.addChild(new AndorraDynamicBorder());
+    }
+    buildSelectList(items, preselect) {
+        const list = new AndorraSelectList(items, Math.max(1, items.length), andorraGetSelectListTheme(), THINKING_SELECT_LIST_LAYOUT);
+        const currentIndex = items.findIndex((item) => item.value === preselect);
+        if (currentIndex !== -1) {
+            list.setSelectedIndex(currentIndex);
+        }
+        list.onSelect = (item) => this.onSelect(item.value);
+        list.onCancel = () => this.onCancel();
+        return list;
+    }
+    applyFilter(query) {
+        const filtered = query
+            ? andorraFuzzyFilter(this.allItems, query, (item) => `${item.value} ${item.description ?? ""}`)
+            : this.allItems;
+        const selectedValue = this.selectList.getSelectedItem()?.value;
+        const newList = this.buildSelectList(filtered, selectedValue);
+        this.children[this.selectListChildIndex] = newList;
+        this.selectList = newList;
+    }
+    handleInput(keyData) {
+        const kb = andorraGetKeybindings();
+        if (kb.matches(keyData, "app.thinking.save") && this.onSelectAsDefault) {
+            const item = this.selectList.getSelectedItem();
+            if (item)
+                this.onSelectAsDefault(item.value);
+            return;
+        }
+        const isNav = kb.matches(keyData, "tui.select.up") ||
+            kb.matches(keyData, "tui.select.down") ||
+            kb.matches(keyData, "tui.select.confirm") ||
+            kb.matches(keyData, "tui.select.cancel");
+        if (isNav) {
+            this.selectList.handleInput(keyData);
+            return;
+        }
+        this.searchInput.handleInput(keyData);
+        this.applyFilter(this.searchInput.getValue());
+    }
+    getSelectList() {
+        return this.selectList;
+    }
+}