dexto 1.3.0 → 1.5.0

package/dist/cli/ink-cli/components/TextBufferInput.js

@@ -0,0 +1,471 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * TextBufferInput Component
+ *
+ * Buffer is passed as prop from parent.
+ * Uses direct useKeypress for input handling (no ref chain).
+ * Parent owns the buffer and can read values directly.
+ */
+import { useCallback, useRef, useEffect } from 'react';
+import { Box, Text, useStdout } from 'ink';
+import { useKeypress } from '../hooks/useKeypress.js';
+import { readClipboardImage } from '../utils/clipboardUtils.js';
+/** Threshold for collapsing pasted content */
+const PASTE_COLLAPSE_LINE_THRESHOLD = 3;
+const PASTE_COLLAPSE_CHAR_THRESHOLD = 150;
+/** Platform-aware keyboard shortcut labels */
+const isMac = process.platform === 'darwin';
+const KEY_LABELS = {
+    ctrlT: isMac ? '⌃T' : 'Ctrl+T',
+    altUp: isMac ? '⌥↑' : 'Alt+Up',
+    altDown: isMac ? '⌥↓' : 'Alt+Down',
+};
+function isBackspaceKey(key) {
+    return key.name === 'backspace' || key.sequence === '\x7f' || key.sequence === '\x08';
+}
+function isForwardDeleteKey(key) {
+    return key.name === 'delete';
+}
+/** Renders text with optional query highlighting in green */
+function HighlightedText({ text, query }) {
+    if (!query || !text) {
+        return _jsx(Text, { children: text });
+    }
+    const lowerText = text.toLowerCase();
+    const lowerQuery = query.toLowerCase();
+    const matchIndex = lowerText.indexOf(lowerQuery);
+    if (matchIndex === -1) {
+        return _jsx(Text, { children: text });
+    }
+    const before = text.slice(0, matchIndex);
+    const match = text.slice(matchIndex, matchIndex + query.length);
+    const after = text.slice(matchIndex + query.length);
+    return (_jsxs(Text, { children: [before, _jsx(Text, { color: "green", bold: true, children: match }), after] }));
+}
+export function TextBufferInput({ buffer, onSubmit, placeholder, isDisabled = false, onHistoryNavigate, onTriggerOverlay, maxViewportLines = 10, isActive, onKeyboardScroll, imageCount = 0, onImagePaste, images = [], onImageRemove, pastedBlocks = [], onPasteBlock, onPasteBlockUpdate, onPasteBlockRemove, highlightQuery, }) {
+    const { stdout } = useStdout();
+    const terminalWidth = stdout?.columns || 80;
+    // Use ref to track imageCount to avoid stale closure in async paste handler
+    const imageCountRef = useRef(imageCount);
+    useEffect(() => {
+        imageCountRef.current = imageCount;
+    }, [imageCount]);
+    // Use ref to track paste number for generating sequential IDs
+    const pasteCounterRef = useRef(pastedBlocks.length);
+    useEffect(() => {
+        // Update counter to be at least the current number of blocks
+        pasteCounterRef.current = Math.max(pasteCounterRef.current, pastedBlocks.length);
+    }, [pastedBlocks.length]);
+    // Check for removed image placeholders after text changes
+    const checkRemovedImages = useCallback(() => {
+        if (!onImageRemove || images.length === 0)
+            return;
+        const currentText = buffer.text;
+        for (const img of images) {
+            if (!currentText.includes(img.placeholder)) {
+                onImageRemove(img.id);
+            }
+        }
+    }, [buffer, images, onImageRemove]);
+    // Check for removed paste block placeholders after text changes
+    const checkRemovedPasteBlocks = useCallback(() => {
+        if (!onPasteBlockRemove || pastedBlocks.length === 0)
+            return;
+        const currentText = buffer.text;
+        for (const block of pastedBlocks) {
+            // Check if either the placeholder or the full text (when expanded) is present
+            const textToFind = block.isCollapsed ? block.placeholder : block.fullText;
+            if (!currentText.includes(textToFind)) {
+                onPasteBlockRemove(block.id);
+            }
+        }
+    }, [buffer, pastedBlocks, onPasteBlockRemove]);
+    // Find the currently expanded paste block (only one can be expanded at a time)
+    const findExpandedBlock = useCallback(() => {
+        return pastedBlocks.find((block) => !block.isCollapsed) || null;
+    }, [pastedBlocks]);
+    // Find which collapsed paste block the cursor is on (by placeholder)
+    const findCollapsedBlockAtCursor = useCallback(() => {
+        if (pastedBlocks.length === 0)
+            return null;
+        const currentText = buffer.text;
+        const [cursorRow, cursorCol] = buffer.cursor;
+        const cursorOffset = getCursorPosition(buffer.lines, cursorRow, cursorCol);
+        for (const block of pastedBlocks) {
+            if (!block.isCollapsed)
+                continue; // Skip expanded blocks
+            const startIdx = currentText.indexOf(block.placeholder);
+            if (startIdx === -1)
+                continue;
+            const endIdx = startIdx + block.placeholder.length;
+            if (cursorOffset >= startIdx && cursorOffset <= endIdx) {
+                return block;
+            }
+        }
+        return null;
+    }, [buffer, pastedBlocks]);
+    // Handle Ctrl+T toggle:
+    // - If something is expanded: collapse it
+    // - If cursor is on a collapsed paste: expand it
+    const handlePasteToggle = useCallback(() => {
+        if (!onPasteBlockUpdate)
+            return;
+        const expandedBlock = findExpandedBlock();
+        const currentText = buffer.text;
+        // If something is expanded, collapse it
+        if (expandedBlock) {
+            // Normalize for comparison (buffer might have different line endings)
+            const normalizedCurrent = currentText.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+            const normalizedFullText = expandedBlock.fullText
+                .replace(/\r\n/g, '\n')
+                .replace(/\r/g, '\n');
+            const startIdx = normalizedCurrent.indexOf(normalizedFullText);
+            if (startIdx === -1) {
+                // Fallback: just mark as collapsed without text replacement
+                // This handles edge cases where text was modified
+                onPasteBlockUpdate(expandedBlock.id, { isCollapsed: true });
+                return;
+            }
+            // Replace full text with placeholder
+            const before = currentText.slice(0, startIdx);
+            const after = currentText.slice(startIdx + normalizedFullText.length);
+            const newText = before + expandedBlock.placeholder + after;
+            // Adjust cursor
+            const [cursorRow, cursorCol] = buffer.cursor;
+            const cursorOffset = getCursorPosition(buffer.lines, cursorRow, cursorCol);
+            let newCursorOffset = cursorOffset;
+            if (cursorOffset > startIdx) {
+                // Cursor is after the start of expanded block - adjust
+                const lengthDiff = expandedBlock.placeholder.length - normalizedFullText.length;
+                newCursorOffset = Math.max(startIdx, cursorOffset + lengthDiff);
+            }
+            buffer.setText(newText);
+            buffer.moveToOffset(Math.min(newCursorOffset, newText.length));
+            onPasteBlockUpdate(expandedBlock.id, { isCollapsed: true });
+            return;
+        }
+        // Otherwise, check if cursor is on a collapsed paste to expand
+        const collapsedBlock = findCollapsedBlockAtCursor();
+        if (collapsedBlock) {
+            const startIdx = currentText.indexOf(collapsedBlock.placeholder);
+            if (startIdx === -1)
+                return;
+            // Replace placeholder with full text
+            const before = currentText.slice(0, startIdx);
+            const after = currentText.slice(startIdx + collapsedBlock.placeholder.length);
+            const newText = before + collapsedBlock.fullText + after;
+            buffer.setText(newText);
+            // Move cursor to start of expanded content
+            buffer.moveToOffset(startIdx);
+            onPasteBlockUpdate(collapsedBlock.id, { isCollapsed: false });
+        }
+    }, [buffer, findExpandedBlock, findCollapsedBlockAtCursor, onPasteBlockUpdate]);
+    // Handle keyboard input directly - reads buffer state fresh each time
+    const handleKeypress = useCallback((key) => {
+        if (isDisabled)
+            return;
+        // Read buffer state directly - always fresh, no stale closures
+        const currentText = buffer.text;
+        const cursorVisualRow = buffer.visualCursor[0];
+        const visualLines = buffer.allVisualLines;
+        // === KEYBOARD SCROLL (PageUp/PageDown, Shift+arrows) ===
+        if (onKeyboardScroll) {
+            if (key.name === 'pageup' || (key.shift && key.name === 'up')) {
+                onKeyboardScroll('up');
+                return;
+            }
+            if (key.name === 'pagedown' || (key.shift && key.name === 'down')) {
+                onKeyboardScroll('down');
+                return;
+            }
+        }
+        // === IMAGE PASTE (Ctrl+V) ===
+        // Check clipboard for image before letting normal paste through
+        if (key.ctrl && key.name === 'v' && onImagePaste) {
+            // Async clipboard check - fire and forget, don't block input
+            void (async () => {
+                try {
+                    const clipboardImage = await readClipboardImage();
+                    if (clipboardImage) {
+                        // Use ref to get current count (avoids stale closure issue)
+                        const currentCount = imageCountRef.current;
+                        const imageNumber = currentCount + 1;
+                        // Immediately increment ref to handle rapid pastes
+                        imageCountRef.current = imageNumber;
+                        const placeholder = `[Image ${imageNumber}]`;
+                        const pendingImage = {
+                            id: `img-${Date.now()}-${imageNumber}`,
+                            data: clipboardImage.data,
+                            mimeType: clipboardImage.mimeType,
+                            placeholder,
+                        };
+                        onImagePaste(pendingImage);
+                        buffer.insert(placeholder);
+                    }
+                }
+                catch {
+                    // Clipboard read failed, ignore
+                }
+            })();
+            return;
+        }
+        // === NEWLINE DETECTION ===
+        const isCtrlJ = key.sequence === '\n';
+        const isShiftEnter = key.sequence === '\\\r' ||
+            (key.name === 'return' && key.shift) ||
+            key.sequence === '\x1b[13;2u' ||
+            key.sequence === '\x1bOM';
+        const isPasteReturn = key.name === 'return' && key.paste;
+        const wantsNewline = isCtrlJ || isShiftEnter || (key.name === 'return' && key.meta) || isPasteReturn;
+        if (wantsNewline) {
+            buffer.newline();
+            return;
+        }
+        // === SUBMIT (Enter) ===
+        if (key.name === 'return' && !key.paste) {
+            if (currentText.trim()) {
+                onSubmit(currentText);
+            }
+            return;
+        }
+        // === UNDO/REDO ===
+        if (key.ctrl && key.name === 'z' && !key.shift) {
+            buffer.undo();
+            return;
+        }
+        if ((key.ctrl && key.name === 'y') || (key.ctrl && key.shift && key.name === 'z')) {
+            buffer.redo();
+            return;
+        }
+        // === PASTE BLOCK TOGGLE (Ctrl+T) ===
+        if (key.ctrl && key.name === 't') {
+            handlePasteToggle();
+            return;
+        }
+        // === BACKSPACE ===
+        if (isBackspaceKey(key) && !key.meta) {
+            const prevText = buffer.text;
+            const [cursorRow, cursorCol] = buffer.cursor;
+            const cursorPos = getCursorPosition(buffer.lines, cursorRow, cursorCol);
+            buffer.backspace();
+            checkRemovedImages();
+            checkRemovedPasteBlocks();
+            if (onTriggerOverlay && cursorPos > 0) {
+                const deletedChar = prevText[cursorPos - 1];
+                const newText = buffer.text;
+                if (deletedChar === '/' && cursorPos === 1) {
+                    onTriggerOverlay('close');
+                }
+                else if (deletedChar === '@' && !newText.includes('@')) {
+                    onTriggerOverlay('close');
+                }
+            }
+            return;
+        }
+        // === FORWARD DELETE ===
+        if (isForwardDeleteKey(key)) {
+            buffer.del();
+            checkRemovedImages();
+            checkRemovedPasteBlocks();
+            return;
+        }
+        // === WORD DELETE ===
+        if (key.ctrl && key.name === 'w') {
+            buffer.deleteWordLeft();
+            checkRemovedImages();
+            checkRemovedPasteBlocks();
+            return;
+        }
+        if (key.meta && isBackspaceKey(key)) {
+            buffer.deleteWordLeft();
+            checkRemovedImages();
+            checkRemovedPasteBlocks();
+            return;
+        }
+        // === ARROW NAVIGATION ===
+        if (key.name === 'left') {
+            buffer.move(key.meta || key.ctrl ? 'wordLeft' : 'left');
+            return;
+        }
+        if (key.name === 'right') {
+            buffer.move(key.meta || key.ctrl ? 'wordRight' : 'right');
+            return;
+        }
+        // Cmd+Up: Move to start of input
+        if (key.meta && key.name === 'up') {
+            buffer.moveToOffset(0);
+            return;
+        }
+        // Cmd+Down: Move to end of input
+        if (key.meta && key.name === 'down') {
+            buffer.moveToOffset(currentText.length);
+            return;
+        }
+        if (key.name === 'up') {
+            // Only trigger history navigation when at top visual line
+            if (cursorVisualRow === 0 && onHistoryNavigate) {
+                onHistoryNavigate('up');
+            }
+            else {
+                buffer.move('up');
+            }
+            return;
+        }
+        if (key.name === 'down') {
+            // Only trigger history navigation when at bottom visual line
+            if (cursorVisualRow >= visualLines.length - 1 && onHistoryNavigate) {
+                onHistoryNavigate('down');
+            }
+            else {
+                buffer.move('down');
+            }
+            return;
+        }
+        // === LINE NAVIGATION ===
+        if (key.ctrl && key.name === 'a') {
+            buffer.move('home');
+            return;
+        }
+        if (key.ctrl && key.name === 'e') {
+            buffer.move('end');
+            return;
+        }
+        if (key.ctrl && key.name === 'k') {
+            buffer.killLineRight();
+            checkRemovedImages();
+            checkRemovedPasteBlocks();
+            return;
+        }
+        if (key.ctrl && key.name === 'u') {
+            buffer.killLineLeft();
+            checkRemovedImages();
+            checkRemovedPasteBlocks();
+            return;
+        }
+        // === WORD NAVIGATION ===
+        if (key.meta && key.name === 'b') {
+            buffer.move('wordLeft');
+            return;
+        }
+        if (key.meta && key.name === 'f') {
+            buffer.move('wordRight');
+            return;
+        }
+        // === CHARACTER INPUT ===
+        if (key.insertable && !key.ctrl && !key.meta) {
+            const [cursorRow, cursorCol] = buffer.cursor;
+            const cursorPos = getCursorPosition(buffer.lines, cursorRow, cursorCol);
+            // Check if this is a large paste that should be collapsed
+            if (key.paste && onPasteBlock) {
+                // Normalize line endings to \n for consistent handling
+                const pastedText = key.sequence.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+                const lineCount = (pastedText.match(/\n/g)?.length ?? 0) + 1;
+                if (lineCount >= PASTE_COLLAPSE_LINE_THRESHOLD ||
+                    pastedText.length > PASTE_COLLAPSE_CHAR_THRESHOLD) {
+                    // Create collapsed paste block
+                    pasteCounterRef.current += 1;
+                    const pasteNumber = pasteCounterRef.current;
+                    const placeholder = `[Paste ${pasteNumber}: ~${lineCount} lines]`;
+                    const pasteBlock = {
+                        id: `paste-${Date.now()}-${pasteNumber}`,
+                        number: pasteNumber,
+                        fullText: pastedText,
+                        lineCount,
+                        isCollapsed: true,
+                        placeholder,
+                    };
+                    // Insert placeholder instead of full text
+                    buffer.insert(placeholder);
+                    onPasteBlock(pasteBlock);
+                    return;
+                }
+            }
+            buffer.insert(key.sequence, { paste: key.paste });
+            if (onTriggerOverlay) {
+                if (key.sequence === '/' && cursorPos === 0) {
+                    onTriggerOverlay('slash-autocomplete');
+                }
+                else if (key.sequence === '@') {
+                    onTriggerOverlay('resource-autocomplete');
+                }
+            }
+        }
+    }, [
+        buffer,
+        isDisabled,
+        onSubmit,
+        onHistoryNavigate,
+        onTriggerOverlay,
+        onKeyboardScroll,
+        // imageCount intentionally omitted - callback uses imageCountRef which is synced via useEffect
+        onImagePaste,
+        checkRemovedImages,
+        checkRemovedPasteBlocks,
+        handlePasteToggle,
+        onPasteBlock,
+    ]);
+    // Subscribe to keypress events when active
+    useKeypress(handleKeypress, { isActive: isActive && !isDisabled });
+    // === RENDERING ===
+    // Read buffer state for rendering
+    const bufferText = buffer.text;
+    const visualCursor = buffer.visualCursor;
+    const visualLines = buffer.allVisualLines;
+    const cursorVisualRow = visualCursor[0];
+    const cursorVisualCol = visualCursor[1];
+    const separator = '─'.repeat(terminalWidth);
+    const totalLines = visualLines.length;
+    // Calculate visible window
+    let startLine = 0;
+    let endLine = totalLines;
+    if (totalLines > maxViewportLines) {
+        const halfViewport = Math.floor(maxViewportLines / 2);
+        startLine = Math.max(0, cursorVisualRow - halfViewport);
+        endLine = Math.min(totalLines, startLine + maxViewportLines);
+        if (endLine === totalLines) {
+            startLine = Math.max(0, totalLines - maxViewportLines);
+        }
+    }
+    const visibleLines = visualLines.slice(startLine, endLine);
+    // Empty state
+    if (bufferText === '') {
+        return (_jsxs(Box, { flexDirection: "column", width: terminalWidth, children: [_jsx(Text, { color: "gray", children: separator }), _jsxs(Box, { width: terminalWidth, children: [_jsx(Text, { color: "green", bold: true, children: '> ' }), _jsx(Text, { inverse: true, children: " " }), placeholder && _jsx(Text, { color: "gray", children: placeholder }), _jsx(Text, { children: ' '.repeat(Math.max(0, terminalWidth - 3 - (placeholder?.length || 0))) })] }), _jsx(Text, { color: "gray", children: separator })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", width: terminalWidth, children: [_jsx(Text, { color: "gray", children: separator }), startLine > 0 && (_jsxs(Text, { color: "gray", children: ['  ', "\u2191 ", startLine, " more line", startLine > 1 ? 's' : '', " above (", KEY_LABELS.altUp, " to jump)"] })), visibleLines.map((line, idx) => {
+                const absoluteRow = startLine + idx;
+                const isFirst = absoluteRow === 0;
+                const prefix = isFirst ? '> ' : '  ';
+                const isCursorLine = absoluteRow === cursorVisualRow;
+                if (!isCursorLine) {
+                    return (_jsxs(Box, { width: terminalWidth, children: [_jsx(Text, { color: "green", bold: isFirst, children: prefix }), _jsx(HighlightedText, { text: line, query: highlightQuery }), _jsx(Text, { children: ' '.repeat(Math.max(0, terminalWidth - prefix.length - line.length)) })] }, absoluteRow));
+                }
+                const before = line.slice(0, cursorVisualCol);
+                const atCursor = line.charAt(cursorVisualCol) || ' ';
+                const after = line.slice(cursorVisualCol + 1);
+                return (_jsxs(Box, { width: terminalWidth, children: [_jsx(Text, { color: "green", bold: isFirst, children: prefix }), _jsx(HighlightedText, { text: before, query: highlightQuery }), _jsx(Text, { inverse: true, children: atCursor }), _jsx(HighlightedText, { text: after, query: highlightQuery }), _jsx(Text, { children: ' '.repeat(Math.max(0, terminalWidth - prefix.length - before.length - 1 - after.length)) })] }, absoluteRow));
+            }), endLine < totalLines && (_jsxs(Text, { color: "gray", children: ['  ', "\u2193 ", totalLines - endLine, " more line", totalLines - endLine > 1 ? 's' : '', ' ', "below (", KEY_LABELS.altDown, " to jump)"] })), pastedBlocks.length > 0 && (_jsx(PasteBlockHint, { pastedBlocks: pastedBlocks, expandedBlock: findExpandedBlock(), cursorOnCollapsed: findCollapsedBlockAtCursor() })), _jsx(Text, { color: "gray", children: separator })] }));
+}
+/** Hint component for paste blocks */
+function PasteBlockHint({ pastedBlocks, expandedBlock, cursorOnCollapsed, }) {
+    const collapsedCount = pastedBlocks.filter((b) => b.isCollapsed).length;
+    // If something is expanded, always show collapse hint
+    if (expandedBlock) {
+        return (_jsxs(Text, { color: "cyan", children: ['  ', KEY_LABELS.ctrlT, " to collapse expanded paste"] }));
+    }
+    // If cursor is on a collapsed paste, show expand hint
+    if (cursorOnCollapsed) {
+        return (_jsxs(Text, { color: "cyan", children: ['  ', KEY_LABELS.ctrlT, " to expand paste"] }));
+    }
+    // Otherwise show count of collapsed pastes
+    if (collapsedCount > 0) {
+        return (_jsxs(Text, { color: "gray", children: ['  ', collapsedCount, " collapsed paste", collapsedCount > 1 ? 's' : '', " (", KEY_LABELS.ctrlT, ' ', "on placeholder to expand)"] }));
+    }
+    return null;
+}
+function getCursorPosition(lines, cursorRow, cursorCol) {
+    let pos = 0;
+    for (let i = 0; i < cursorRow; i++) {
+        pos += (lines[i]?.length ?? 0) + 1;
+    }
+    return pos + cursorCol;
+}

package/dist/cli/ink-cli/components/base/BaseAutocomplete.js

@@ -82,17 +82,17 @@ export function BaseAutocomplete({ items, query, isVisible, isLoading = false, o
     if (!isVisible)
         return null;
     if (isLoading) {
-        return (_jsx(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, paddingY: 1, children: _jsx(Text, { dimColor: true, children: loadingMessage }) }));
+        return (_jsx(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, paddingY: 1, children: _jsx(Text, { color: "gray", children: loadingMessage }) }));
     }
     if (filteredItems.length === 0) {
-        return (_jsx(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, paddingY: 1, children: _jsx(Text, { dimColor: true, children: emptyMessage }) }));
+        return (_jsx(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, paddingY: 1, children: _jsx(Text, { color: "gray", children: emptyMessage }) }));
     }
     const hasMoreAbove = scrollOffset > 0;
     const hasMoreBelow = scrollOffset + maxVisibleItems < filteredItems.length;
     const totalItems = filteredItems.length;
-    return (_jsxs(Box, { borderStyle: "single", borderColor: borderColor, flexDirection: "column", height: Math.min(maxVisibleItems + 3, totalItems + 3), children: [_jsx(Box, { paddingX: 1, paddingY: 0, children: _jsxs(Text, { dimColor: true, children: [title, " (", selectedIndex + 1, "/", totalItems, ") - \u2191\u2193 navigate", onLoadIntoInput && ', Tab load', ', Enter select, Esc close'] }) }), hasMoreAbove && (_jsx(Box, { paddingX: 1, paddingY: 0, children: _jsxs(Text, { dimColor: true, children: ["... \u2191 (", scrollOffset, " more above)"] }) })), visibleItems.map((item, visibleIndex) => {
+    return (_jsxs(Box, { borderStyle: "single", borderColor: borderColor, flexDirection: "column", height: Math.min(maxVisibleItems + 3, totalItems + 3), children: [_jsx(Box, { paddingX: 1, paddingY: 0, children: _jsxs(Text, { color: "gray", children: [title, " (", selectedIndex + 1, "/", totalItems, ") - \u2191\u2193 navigate", onLoadIntoInput && ', Tab load', ', Enter select, Esc close'] }) }), hasMoreAbove && (_jsx(Box, { paddingX: 1, paddingY: 0, children: _jsxs(Text, { color: "gray", children: ["... \u2191 (", scrollOffset, " more above)"] }) })), visibleItems.map((item, visibleIndex) => {
                 const actualIndex = scrollOffset + visibleIndex;
                 const isSelected = actualIndex === selectedIndex;
                 return (_jsx(Box, { paddingX: 1, paddingY: 0, children: formatItem(item, isSelected) }, actualIndex));
-            }), hasMoreBelow && (_jsx(Box, { paddingX: 1, paddingY: 0, children: _jsxs(Text, { dimColor: true, children: ["... \u2193 (", totalItems - scrollOffset - maxVisibleItems, " more below)"] }) }))] }));
+            }), hasMoreBelow && (_jsx(Box, { paddingX: 1, paddingY: 0, children: _jsxs(Text, { color: "gray", children: ["... \u2193 (", totalItems - scrollOffset - maxVisibleItems, " more below)"] }) }))] }));
 }

package/dist/cli/ink-cli/components/base/BaseSelector.d.ts

@@ -4,6 +4,7 @@
  * Used by ModelSelector and SessionSelector
  */
 import { type ReactNode } from 'react';
+import type { Key } from '../../hooks/useInputOrchestrator.js';
 export interface BaseSelectorProps<T> {
     items: T[];
     isVisible: boolean;
@@ -18,9 +19,18 @@ export interface BaseSelectorProps<T> {
     loadingMessage?: string;
     emptyMessage?: string;
     borderColor?: string;
+    onTab?: (item: T) => void;
+    supportsTab?: boolean;
+}
+export interface BaseSelectorHandle {
+    handleInput: (input: string, key: Key) => boolean;
 }
 /**
  * Generic selector component with keyboard navigation and scrolling
  */
-export declare function BaseSelector<T>({ items, isVisible, isLoading, selectedIndex, onSelectIndex, onSelect, onClose, formatItem, title, maxVisibleItems, loadingMessage, emptyMessage, borderColor, }: BaseSelectorProps<T>): import("react/jsx-runtime").JSX.Element | null;
+declare function BaseSelectorInner<T>({ items, isVisible, isLoading, selectedIndex, onSelectIndex, onSelect, onClose, formatItem, title, maxVisibleItems, loadingMessage, emptyMessage, borderColor, onTab, supportsTab, }: BaseSelectorProps<T>, ref: React.Ref<BaseSelectorHandle>): import("react/jsx-runtime").JSX.Element | null;
+export declare const BaseSelector: <T>(props: BaseSelectorProps<T> & {
+    ref?: React.Ref<BaseSelectorHandle>;
+}) => ReturnType<typeof BaseSelectorInner>;
+export {};
 //# sourceMappingURL=BaseSelector.d.ts.map

package/dist/cli/ink-cli/components/base/BaseSelector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseSelector.d.ts","sourceRoot":"","sources":["../../../../../src/cli/ink-cli/components/base/BaseSelector.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAqD,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAG1F,MAAM,WAAW,iBAAiB,CAAC,CAAC;IAChC,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IAC5B,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,UAAU,EAAE,OAAO,KAAK,SAAS,CAAC;IACxD,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,EAC5B,KAAK,EACL,SAAS,EACT,SAAiB,EACjB,aAAa,EACb,aAAa,EACb,QAAQ,EACR,OAAO,EACP,UAAU,EACV,KAAK,EACL,eAAoB,EACpB,cAA6B,EAC7B,YAA+B,EAC/B,WAAoB,GACvB,EAAE,iBAAiB,CAAC,CAAC,CAAC,kDA+HtB"}
+{"version":3,"file":"BaseSelector.d.ts","sourceRoot":"","sources":["../../../../../src/cli/ink-cli/components/base/BaseSelector.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAQH,KAAK,SAAS,EACjB,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,qCAAqC,CAAC;AAE/D,MAAM,WAAW,iBAAiB,CAAC,CAAC;IAChC,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IAC5B,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,UAAU,EAAE,OAAO,KAAK,SAAS,CAAC;IACxD,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,kBAAkB;IAC/B,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC;CACrD;AAED;;GAEG;AACH,iBAAS,iBAAiB,CAAC,CAAC,EACxB,EACI,KAAK,EACL,SAAS,EACT,SAAiB,EACjB,aAAa,EACb,aAAa,EACb,QAAQ,EACR,OAAO,EACP,UAAU,EACV,KAAK,EACL,eAAmB,EACnB,cAA6B,EAC7B,YAA+B,EAC/B,WAAoB,EACpB,KAAK,EACL,WAAmB,GACtB,EAAE,iBAAiB,CAAC,CAAC,CAAC,EACvB,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,kBAAkB,CAAC,kDAyJrC;AAGD,eAAO,MAAM,YAAY,EAAoC,CAAC,CAAC,EAC3D,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG;IAAE,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAA;CAAE,KACpE,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC"}