my-pi-agent 0.1.0

package/tui/dist/components/theme-selector.js

@@ -0,0 +1,77 @@
+import { Container, matchesKey, SelectList, Spacer, Text, } from "@earendil-works/pi-tui";
+import { theme } from "../theme/theme.js";
+import { DynamicBorder } from "./dynamic-border.js";
+import { isEnterKey } from "./keys.js";
+const THEME_LAYOUT_OPTIONS = {
+    minPrimaryColumnWidth: 12,
+    maxPrimaryColumnWidth: 28,
+};
+export class ThemeSelectorComponent extends Container {
+    currentTheme;
+    availableThemes;
+    onSelect;
+    onCancel;
+    onPreview;
+    selectList;
+    _focused = false;
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+    }
+    constructor(currentTheme, availableThemes = ["dark", "light"], onSelect, onCancel, onPreview) {
+        super();
+        this.currentTheme = currentTheme;
+        this.availableThemes = availableThemes;
+        this.onSelect = onSelect;
+        this.onCancel = onCancel;
+        this.onPreview = onPreview;
+        const items = availableThemes.map((name) => ({
+            value: name,
+            label: name,
+            description: name === currentTheme ? "(current)" : undefined,
+        }));
+        const listTheme = {
+            selectedPrefix: (s) => theme.fg("accent", s),
+            selectedText: (s) => theme.bold(theme.fg("accent", s)),
+            description: (s) => theme.fg("muted", s),
+            scrollInfo: (s) => theme.dim(s),
+            noMatch: (_s) => theme.dim("无匹配主题"),
+        };
+        this.selectList = new SelectList(items, Math.max(1, items.length), listTheme, THEME_LAYOUT_OPTIONS);
+        const curIdx = availableThemes.indexOf(currentTheme);
+        if (curIdx !== -1) {
+            this.selectList.setSelectedIndex(curIdx);
+        }
+        this.selectList.onSelect = (item) => onSelect(item.value);
+        this.selectList.onCancel = () => onCancel();
+        this.selectList.onSelectionChange = (item) => onPreview?.(item.value);
+        this.addChild(new DynamicBorder());
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(theme.bold("Theme Selector"), 0, 0));
+        this.addChild(new Text(theme.fg("muted", "Enter: select · Up/Down: live preview · Esc: revert & exit"), 0, 0));
+        this.addChild(new Spacer(1));
+        this.addChild(this.selectList);
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(theme.fg("dim", "  Changes persist to settings.json · Escape to cancel"), 0, 0));
+        this.addChild(new DynamicBorder());
+    }
+    handleInput(data) {
+        if (matchesKey(data, "ctrl+c")) {
+            this.onCancel();
+            return;
+        }
+        if (matchesKey(data, "up") ||
+            matchesKey(data, "down") ||
+            isEnterKey(data) ||
+            matchesKey(data, "escape")) {
+            if (isEnterKey(data)) {
+                this.selectList.handleInput("\r");
+            }
+            else {
+                this.selectList.handleInput(data);
+            }
+        }
+    }
+}

package/tui/dist/components/thinking-selector.d.ts

@@ -0,0 +1,21 @@
+import { Container, Input, SelectList } from "@earendil-works/pi-tui";
+export declare const THINKING_LEVEL_DESCRIPTIONS: Record<string, string>;
+export declare class ThinkingSelectorComponent extends Container {
+    readonly currentLevel: string;
+    readonly availableLevels: string[];
+    readonly onSelect: (level: string) => void;
+    readonly onCancel: () => void;
+    readonly onSelectAsDefault?: ((level: string) => void) | undefined;
+    readonly defaultLevel?: string | undefined;
+    searchInput: Input;
+    selectList: SelectList;
+    private selectListChildIndex;
+    private allItems;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    constructor(currentLevel: string, availableLevels: string[], onSelect: (level: string) => void, onCancel: () => void, onSelectAsDefault?: ((level: string) => void) | undefined, defaultLevel?: string | undefined);
+    private buildSelectList;
+    private applyFilter;
+    handleInput(data: string): void;
+}

package/tui/dist/components/thinking-selector.js

@@ -0,0 +1,128 @@
+import { Container, fuzzyFilter, Input, matchesKey, SelectList, Spacer, Text, } from "@earendil-works/pi-tui";
+import { theme } from "../theme/theme.js";
+import { DynamicBorder } from "./dynamic-border.js";
+import { isEnterKey } from "./keys.js";
+export const THINKING_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",
+};
+export class ThinkingSelectorComponent extends Container {
+    currentLevel;
+    availableLevels;
+    onSelect;
+    onCancel;
+    onSelectAsDefault;
+    defaultLevel;
+    searchInput;
+    selectList;
+    selectListChildIndex;
+    allItems;
+    _focused = false;
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+        this.searchInput.focused = value;
+    }
+    constructor(currentLevel, availableLevels, onSelect, onCancel, onSelectAsDefault, defaultLevel) {
+        super();
+        this.currentLevel = currentLevel;
+        this.availableLevels = availableLevels;
+        this.onSelect = onSelect;
+        this.onCancel = onCancel;
+        this.onSelectAsDefault = onSelectAsDefault;
+        this.defaultLevel = defaultLevel;
+        this.allItems = availableLevels.map((level) => {
+            const isCurrent = level.toLowerCase() === currentLevel.toLowerCase();
+            const isDefault = level.toLowerCase() === (defaultLevel || "").toLowerCase();
+            const desc = THINKING_LEVEL_DESCRIPTIONS[level] || "Reasoning level";
+            return {
+                value: level,
+                label: `${isCurrent ? "✓ " : "  "}${level}`,
+                description: isDefault ? `${desc} · default` : desc,
+            };
+        });
+        this.addChild(new DynamicBorder());
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(theme.bold("Thinking Level"), 0, 0));
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(theme.fg("muted", "Shift+Tab cycles thinking levels in-session"), 0, 0));
+        this.addChild(new Spacer(1));
+        this.searchInput = new Input();
+        this.searchInput.onSubmit = () => {
+            const item = this.selectList.getSelectedItem();
+            if (item) {
+                this.onSelect(item.value);
+            }
+        };
+        this.addChild(this.searchInput);
+        this.addChild(new Spacer(1));
+        this.selectList = this.buildSelectList(this.allItems, currentLevel);
+        this.selectListChildIndex = this.children.length;
+        this.addChild(this.selectList);
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(theme.fg("dim", "  Enter to select · Ctrl+S to set as default · Escape to cancel"), 0, 0));
+        this.addChild(new DynamicBorder());
+    }
+    buildSelectList(items, preselect) {
+        const listTheme = {
+            selectedPrefix: (s) => theme.fg("accent", s),
+            selectedText: (s) => theme.bold(theme.fg("accent", s)),
+            description: (s) => theme.fg("muted", s),
+            scrollInfo: (s) => theme.dim(s),
+            noMatch: (_s) => theme.dim("无匹配等级"),
+        };
+        const list = new SelectList(items, Math.max(1, items.length), listTheme, {
+            minPrimaryColumnWidth: 12,
+            maxPrimaryColumnWidth: 32,
+        });
+        const curIdx = items.findIndex((i) => i.value === preselect);
+        if (curIdx !== -1) {
+            list.setSelectedIndex(curIdx);
+        }
+        list.onSelect = (item) => this.onSelect(item.value);
+        list.onCancel = () => this.onCancel();
+        return list;
+    }
+    applyFilter(query) {
+        const filtered = query
+            ? fuzzyFilter(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(data) {
+        if (matchesKey(data, "ctrl+c")) {
+            this.onCancel();
+            return;
+        }
+        if (matchesKey(data, "ctrl+s") && this.onSelectAsDefault) {
+            const item = this.selectList.getSelectedItem();
+            if (item)
+                this.onSelectAsDefault(item.value);
+            return;
+        }
+        if (matchesKey(data, "up") ||
+            matchesKey(data, "down") ||
+            isEnterKey(data) ||
+            matchesKey(data, "escape")) {
+            if (isEnterKey(data)) {
+                this.selectList.handleInput("\r");
+            }
+            else {
+                this.selectList.handleInput(data);
+            }
+            return;
+        }
+        this.searchInput.handleInput(data);
+        this.applyFilter(this.searchInput.getValue());
+    }
+}

package/tui/dist/components/tool-execution.d.ts

@@ -0,0 +1,31 @@
+import { Container } from "@earendil-works/pi-tui";
+export declare const SPINNER_FRAMES: string[];
+export declare class ToolExecutionComponent extends Container {
+    readonly toolName: string;
+    readonly toolCallId: string;
+    args: Record<string, unknown>;
+    private readonly onRequestRender?;
+    private box;
+    private isFinished;
+    private isError;
+    private isExpanded;
+    private resultText;
+    private partialOutput;
+    private elapsedSeconds;
+    private startTime;
+    private spinnerFrame;
+    private animInterval;
+    constructor(toolName: string, toolCallId: string, args?: Record<string, unknown>, onRequestRender?: (() => void) | undefined);
+    private startAnimation;
+    private stopAnimation;
+    dispose(): void;
+    get finished(): boolean;
+    get elapsed(): number;
+    updateArgs(args: Record<string, unknown>): void;
+    updatePartialResult(partial: unknown): void;
+    updateResult(result: unknown, isError: boolean, elapsedSeconds?: number): void;
+    toggleExpanded(): void;
+    render(width: number): string[];
+    private formatArgs;
+    private updateDisplay;
+}

package/tui/dist/components/tool-execution.js

@@ -0,0 +1,206 @@
+import { Box, Container, Spacer, Text } from "@earendil-works/pi-tui";
+import { theme } from "../theme/theme.js";
+export const SPINNER_FRAMES = [
+    "⠋",
+    "⠙",
+    "⠹",
+    "⠸",
+    "⠼",
+    "⠴",
+    "⠦",
+    "⠧",
+    "⠇",
+    "⠏",
+];
+const SPINNER_INTERVAL_MS = 80;
+const MAX_PREVIEW_LINES = 15;
+export class ToolExecutionComponent extends Container {
+    toolName;
+    toolCallId;
+    args;
+    onRequestRender;
+    box;
+    isFinished = false;
+    isError = false;
+    isExpanded = false;
+    resultText = "";
+    partialOutput = "";
+    elapsedSeconds = 0;
+    startTime = Date.now();
+    spinnerFrame = 0;
+    animInterval = null;
+    constructor(toolName, toolCallId, args = {}, onRequestRender) {
+        super();
+        this.toolName = toolName;
+        this.toolCallId = toolCallId;
+        this.args = args;
+        this.onRequestRender = onRequestRender;
+        this.addChild(new Spacer(1));
+        this.box = new Box(1, 1, (t) => theme.bg("toolPendingBg", t));
+        this.addChild(this.box);
+        this.updateDisplay();
+        this.startAnimation();
+    }
+    startAnimation() {
+        if (this.isFinished || this.animInterval)
+            return;
+        this.animInterval = setInterval(() => {
+            if (this.isFinished) {
+                this.stopAnimation();
+                return;
+            }
+            this.spinnerFrame = (this.spinnerFrame + 1) % SPINNER_FRAMES.length;
+            this.updateDisplay();
+            if (this.onRequestRender) {
+                this.onRequestRender();
+            }
+        }, SPINNER_INTERVAL_MS);
+        if (typeof this.animInterval?.unref === "function") {
+            this.animInterval.unref();
+        }
+    }
+    stopAnimation() {
+        if (this.animInterval) {
+            clearInterval(this.animInterval);
+            this.animInterval = null;
+        }
+    }
+    dispose() {
+        this.stopAnimation();
+    }
+    get finished() {
+        return this.isFinished;
+    }
+    get elapsed() {
+        if (this.isFinished) {
+            return this.elapsedSeconds;
+        }
+        return Math.max(0, (Date.now() - this.startTime) / 1000);
+    }
+    updateArgs(args) {
+        this.args = args;
+        this.updateDisplay();
+    }
+    updatePartialResult(partial) {
+        if (this.isFinished)
+            return;
+        if (typeof partial === "string") {
+            this.partialOutput = partial;
+        }
+        else if (partial && typeof partial === "object") {
+            const data = partial.data;
+            this.partialOutput = String(data || JSON.stringify(partial));
+        }
+        else {
+            this.partialOutput = String(partial ?? "");
+        }
+        this.updateDisplay();
+        if (this.onRequestRender) {
+            this.onRequestRender();
+        }
+    }
+    updateResult(result, isError, elapsedSeconds) {
+        this.stopAnimation();
+        this.isFinished = true;
+        this.isError = isError;
+        this.partialOutput = "";
+        this.elapsedSeconds =
+            elapsedSeconds !== undefined && elapsedSeconds >= 0
+                ? elapsedSeconds
+                : Math.max(0, (Date.now() - this.startTime) / 1000);
+        if (typeof result === "string") {
+            this.resultText = result;
+        }
+        else if (result && typeof result === "object") {
+            const data = result.data;
+            const error = result.error;
+            this.resultText = String(data || error || JSON.stringify(result));
+        }
+        else {
+            this.resultText = String(result ?? "");
+        }
+        this.box.setBgFn((t) => theme.bg(this.isError ? "toolErrorBg" : "toolSuccessBg", t));
+        this.updateDisplay();
+    }
+    toggleExpanded() {
+        this.isExpanded = !this.isExpanded;
+        this.updateDisplay();
+    }
+    render(width) {
+        if (!this.isFinished) {
+            this.updateDisplay();
+        }
+        return super.render(width);
+    }
+    formatArgs() {
+        const keys = Object.keys(this.args);
+        if (keys.length === 0) {
+            return "";
+        }
+        const parts = keys.map((k) => {
+            const val = this.args[k];
+            let s = typeof val === "object" ? JSON.stringify(val) : String(val);
+            if (s.length > 50) {
+                s = s.slice(0, 47) + "...";
+            }
+            return `${k}=${s}`;
+        });
+        return `(${parts.join(", ")})`;
+    }
+    updateDisplay() {
+        this.box.clear();
+        // 1. Header
+        const spinnerChar = SPINNER_FRAMES[this.spinnerFrame] || "⠋";
+        let icon = theme.fg("warning", spinnerChar);
+        let statusSuffix = "";
+        if (this.isFinished) {
+            if (this.isError) {
+                icon = theme.fg("error", "✗");
+                statusSuffix = theme.fg("error", "(失败)");
+            }
+            else {
+                icon = theme.fg("success", "✓");
+                statusSuffix = theme.fg("dim", `(${this.elapsedSeconds.toFixed(1)}s)`);
+            }
+        }
+        else {
+            statusSuffix = theme.fg("dim", `Elapsed ${this.elapsed.toFixed(1)}s`);
+        }
+        const argsStr = this.formatArgs();
+        const parts = [icon, theme.bold(theme.fg("toolTitle", this.toolName))];
+        if (argsStr) {
+            parts.push(theme.fg("dim", argsStr));
+        }
+        if (statusSuffix) {
+            parts.push(statusSuffix);
+        }
+        const titleText = parts.join(" ");
+        this.box.addChild(new Text(titleText, 0, 0));
+        // 2. Result Output (if finished)
+        if (this.isFinished && this.resultText.trim()) {
+            this.box.addChild(new Spacer(1));
+            const lines = this.resultText.trim().split("\n");
+            let renderedText = "";
+            if (this.isExpanded || lines.length <= MAX_PREVIEW_LINES) {
+                renderedText = lines.map((l) => theme.fg("toolOutput", l)).join("\n");
+            }
+            else {
+                const preview = lines.slice(0, MAX_PREVIEW_LINES);
+                const remaining = lines.length - MAX_PREVIEW_LINES;
+                renderedText = preview.map((l) => theme.fg("toolOutput", l)).join("\n");
+                renderedText += `\n${theme.dim(`... (剩余 ${remaining} 行，按 Ctrl+O 展开查看)`)}`;
+            }
+            this.box.addChild(new Text(renderedText, 0, 0));
+        }
+        else if (!this.isFinished && this.partialOutput.trim()) {
+            // 正在运行中的实时流式输出预览 (对标 Pi bash renderer options.isPartial)
+            this.box.addChild(new Spacer(1));
+            const lines = this.partialOutput.trim().split("\n");
+            const previewLines = lines.slice(-MAX_PREVIEW_LINES);
+            const renderedText = previewLines
+                .map((l) => theme.fg("dim", l))
+                .join("\n");
+            this.box.addChild(new Text(renderedText, 0, 0));
+        }
+    }
+}

package/tui/dist/components/tree-selector.d.ts

@@ -0,0 +1,40 @@
+import { Container } from "@earendil-works/pi-tui";
+export interface TreeNode {
+    id: string;
+    parent_id: string | null;
+    role: string;
+    type: string;
+    preview: string;
+    is_leaf: boolean;
+    is_active: boolean;
+    timestamp: number;
+}
+export interface FlattenedTreeNode {
+    node: TreeNode;
+    depth: number;
+    isLast: boolean;
+    ancestorContinues: boolean[];
+}
+export declare function buildDAGTree(nodes: TreeNode[]): FlattenedTreeNode[];
+export declare function buildDAGTreePrefix(item: FlattenedTreeNode): string;
+export declare class TreeSelectorComponent extends Container {
+    private loadNodes;
+    readonly onSelect: (node: TreeNode) => void;
+    readonly onCancel: () => void;
+    readonly activeLeafId?: string | undefined;
+    private requestRender?;
+    private listContainer;
+    private allNodes;
+    private displayNodes;
+    private selectedIndex;
+    private maxVisible;
+    private lastWidth;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    constructor(loadNodes: () => Promise<TreeNode[]>, onSelect: (node: TreeNode) => void, onCancel: () => void, activeLeafId?: string | undefined, requestRender?: (() => void) | undefined);
+    render(width: number): string[];
+    reload(): Promise<void>;
+    updateList(): void;
+    handleInput(data: string): void;
+}

package/tui/dist/components/tree-selector.js

@@ -0,0 +1,173 @@
+import { Container, matchesKey, Spacer, Text, visibleWidth, } from "@earendil-works/pi-tui";
+import { theme } from "../theme/theme.js";
+import { DynamicBorder } from "./dynamic-border.js";
+import { isEnterKey } from "./keys.js";
+export function buildDAGTree(nodes) {
+    const byId = new Map();
+    for (const n of nodes) {
+        byId.set(n.id, { node: n, children: [] });
+    }
+    const roots = [];
+    for (const n of nodes) {
+        const item = byId.get(n.id);
+        if (n.parent_id && byId.has(n.parent_id)) {
+            byId.get(n.parent_id).children.push(item);
+        }
+        else {
+            roots.push(item);
+        }
+    }
+    const result = [];
+    const walk = (item, depth, ancestorContinues, isLast) => {
+        result.push({ node: item.node, depth, isLast, ancestorContinues });
+        for (let i = 0; i < item.children.length; i++) {
+            const childIsLast = i === item.children.length - 1;
+            const continues = depth > 0 ? !isLast : false;
+            walk(item.children[i], depth + 1, [...ancestorContinues, continues], childIsLast);
+        }
+    };
+    for (let i = 0; i < roots.length; i++) {
+        walk(roots[i], 0, [], i === roots.length - 1);
+    }
+    return result;
+}
+export function buildDAGTreePrefix(item) {
+    if (item.depth === 0) {
+        return "■ ";
+    }
+    const parts = item.ancestorContinues.map((c) => (c ? "│  " : "   "));
+    const branch = item.isLast ? "└─ " : "├─ ";
+    return parts.join("") + branch;
+}
+export class TreeSelectorComponent extends Container {
+    loadNodes;
+    onSelect;
+    onCancel;
+    activeLeafId;
+    requestRender;
+    listContainer;
+    allNodes = [];
+    displayNodes = [];
+    selectedIndex = 0;
+    maxVisible = 12;
+    lastWidth = 80;
+    _focused = false;
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+    }
+    constructor(loadNodes, onSelect, onCancel, activeLeafId, requestRender) {
+        super();
+        this.loadNodes = loadNodes;
+        this.onSelect = onSelect;
+        this.onCancel = onCancel;
+        this.activeLeafId = activeLeafId;
+        this.requestRender = requestRender;
+        this.listContainer = new Container();
+        this.addChild(new DynamicBorder());
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(theme.bold("Session Tree (DAG Explorer)"), 0, 0));
+        this.addChild(new Text(theme.fg("muted", "Enter: switch to branch · Up/Down: navigate · Esc: exit"), 0, 0));
+        this.addChild(new Spacer(1));
+        this.addChild(this.listContainer);
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(theme.fg("dim", "  Enter to switch branch · Up/Down to navigate · Escape to cancel"), 0, 0));
+        this.addChild(new DynamicBorder());
+        void this.reload();
+    }
+    render(width) {
+        this.lastWidth = width;
+        return super.render(width);
+    }
+    async reload() {
+        try {
+            this.allNodes = await this.loadNodes();
+        }
+        catch {
+            this.allNodes = [];
+        }
+        this.displayNodes = buildDAGTree(this.allNodes);
+        // Default to currently active leaf or the last item
+        const initialIdx = this.displayNodes.findIndex((item) => item.node.id === this.activeLeafId ||
+            (item.node.is_active && item.node.is_leaf));
+        this.selectedIndex =
+            initialIdx >= 0 ? initialIdx : Math.max(0, this.displayNodes.length - 1);
+        this.updateList();
+        if (this.requestRender) {
+            this.requestRender();
+        }
+    }
+    updateList() {
+        this.listContainer.clear();
+        if (this.displayNodes.length === 0) {
+            this.listContainer.addChild(new Text(theme.fg("muted", "  当前会话暂无节点记录。"), 0, 0));
+            return;
+        }
+        const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.displayNodes.length - this.maxVisible));
+        const endIndex = Math.min(startIndex + this.maxVisible, this.displayNodes.length);
+        for (let i = startIndex; i < endIndex; i++) {
+            const item = this.displayNodes[i];
+            if (!item)
+                continue;
+            const node = item.node;
+            const isSelected = i === this.selectedIndex;
+            const cursor = isSelected ? theme.fg("accent", "› ") : "  ";
+            const activeMarker = node.is_active ? theme.fg("accent", "* ") : "  ";
+            const branchPrefix = buildDAGTreePrefix(item);
+            let roleBadge = `[${node.role}]`;
+            if (node.role === "user") {
+                roleBadge = theme.fg("accent", roleBadge);
+            }
+            else if (node.role === "assistant") {
+                roleBadge = theme.fg("success", roleBadge);
+            }
+            else {
+                roleBadge = theme.fg("muted", roleBadge);
+            }
+            let lineText = `${cursor}${activeMarker}${theme.fg("dim", branchPrefix)}${roleBadge} ${node.preview}`;
+            if (node.id === this.activeLeafId || (node.is_active && node.is_leaf)) {
+                lineText += theme.fg("accent", " [ACTIVE LEAF]");
+            }
+            if (isSelected) {
+                // Pad dynamically to viewport width
+                const pad = Math.max(0, this.lastWidth - 4 - visibleWidth(lineText));
+                lineText = theme.bg("selectedBg", lineText + " ".repeat(pad));
+            }
+            this.listContainer.addChild(new Text(lineText, 0, 0));
+        }
+        if (startIndex > 0 || endIndex < this.displayNodes.length) {
+            const scrollInfo = theme.fg("muted", `  (${this.selectedIndex + 1}/${this.displayNodes.length})`);
+            this.listContainer.addChild(new Text(scrollInfo, 0, 0));
+        }
+    }
+    handleInput(data) {
+        if (matchesKey(data, "up")) {
+            if (this.displayNodes.length === 0)
+                return;
+            this.selectedIndex =
+                this.selectedIndex === 0
+                    ? this.displayNodes.length - 1
+                    : this.selectedIndex - 1;
+            this.updateList();
+        }
+        else if (matchesKey(data, "down")) {
+            if (this.displayNodes.length === 0)
+                return;
+            this.selectedIndex =
+                this.selectedIndex === this.displayNodes.length - 1
+                    ? 0
+                    : this.selectedIndex + 1;
+            this.updateList();
+        }
+        else if (isEnterKey(data)) {
+            const selected = this.displayNodes[this.selectedIndex]?.node;
+            if (selected)
+                this.onSelect(selected);
+        }
+        else if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+            this.onCancel();
+        }
+    }
+}