viberag 0.1.0

package/dist/common/commands/terminalSetup.d.ts

@@ -0,0 +1,2 @@
+export declare function setupTerminal(): Promise<string>;
+export { setupTerminal as setupVSCodeTerminal };

package/dist/common/commands/terminalSetup.js

@@ -0,0 +1,144 @@
+import { homedir, platform } from 'node:os';
+import { join, dirname } from 'node:path';
+import { readFile, writeFile, mkdir, access, constants } from 'node:fs/promises';
+const EDITORS = [
+    { name: 'VS Code', folder: 'Code' },
+    { name: 'VS Code Insiders', folder: 'Code - Insiders' },
+    { name: 'Cursor', folder: 'Cursor' },
+    { name: 'Windsurf', folder: 'Windsurf' },
+    { name: 'VSCodium', folder: 'VSCodium' },
+];
+// ESC + LF - actual control character bytes
+// \u001B = ESC (0x1B), \u000A = LF (0x0A)
+const KEYBINDING = {
+    key: 'shift+enter',
+    command: 'workbench.action.terminal.sendSequence',
+    args: { text: '\u001B\u000A' },
+    when: 'terminalFocus',
+};
+function detectTerminal() {
+    const termProgram = process.env['TERM_PROGRAM'];
+    const term = process.env['TERM'];
+    if (termProgram === 'vscode')
+        return 'vscode';
+    if (termProgram === 'iTerm.app')
+        return 'iterm';
+    if (termProgram === 'Apple_Terminal')
+        return 'apple_terminal';
+    if (termProgram === 'WezTerm')
+        return 'wezterm';
+    if (term?.includes('kitty'))
+        return 'kitty';
+    return 'unknown';
+}
+function getKeybindingsPath(folder) {
+    const home = homedir();
+    switch (platform()) {
+        case 'darwin':
+            return join(home, 'Library/Application Support', folder, 'User/keybindings.json');
+        case 'win32':
+            return join(process.env['APPDATA'] ?? home, folder, 'User/keybindings.json');
+        default:
+            return join(home, '.config', folder, 'User/keybindings.json');
+    }
+}
+async function setupVSCodeEditors() {
+    const configured = [];
+    for (const editor of EDITORS) {
+        const path = getKeybindingsPath(editor.folder);
+        const userDir = dirname(path);
+        try {
+            await access(userDir, constants.F_OK);
+        }
+        catch {
+            continue;
+        }
+        let keybindings = [];
+        try {
+            const content = await readFile(path, 'utf-8');
+            const parsed = JSON.parse(content);
+            if (Array.isArray(parsed)) {
+                keybindings = parsed;
+            }
+        }
+        catch {
+            await mkdir(dirname(path), { recursive: true });
+        }
+        keybindings = keybindings.filter((b) => {
+            if (typeof b !== 'object' || b === null)
+                return true;
+            const kb = b;
+            return !(kb['key'] === 'shift+enter' &&
+                kb['command'] === 'workbench.action.terminal.sendSequence');
+        });
+        keybindings.push(KEYBINDING);
+        await writeFile(path, JSON.stringify(keybindings, null, 2));
+        configured.push(editor.name);
+    }
+    if (configured.length === 0) {
+        return '';
+    }
+    return `Configured Shift+Enter for: ${configured.join(', ')}\n\nRestart your terminal to apply.`;
+}
+export async function setupTerminal() {
+    const terminal = detectTerminal();
+    switch (terminal) {
+        case 'vscode':
+            return setupVSCodeEditors();
+        case 'iterm':
+            return `iTerm2 detected.
+
+To enable Shift+Enter for newlines:
+
+1. Open iTerm2 → Settings (⌘,) → Profiles
+2. Select your profile → Keys tab → General sub-tab
+3. Under "Report modifiers using CSI u", select "Yes"
+4. Restart iTerm2
+
+Once enabled, Shift+Enter and Alt+Enter will insert newlines.
+
+Alternative methods that work now:
+- \\ + Enter (backslash then Enter)
+- Ctrl+J`;
+        case 'kitty':
+            return `Kitty detected - Shift+Enter should work natively.
+
+If not working, try:
+- \\ + Enter (backslash then Enter)
+- Ctrl+J`;
+        case 'wezterm':
+            return `WezTerm detected - Shift+Enter should work natively.
+
+If not working, try:
+- \\ + Enter (backslash then Enter)
+- Ctrl+J`;
+        case 'apple_terminal':
+            return `macOS Terminal detected.
+
+Shift+Enter is not supported in Terminal.app.
+
+Use these methods instead:
+- \\ + Enter (backslash then Enter)
+- Ctrl+J
+- Option+Enter
+
+Consider using iTerm2 or running in VS Code for Shift+Enter support.`;
+        default: {
+            // Try VS Code editors anyway
+            const vsResult = await setupVSCodeEditors();
+            if (vsResult) {
+                return vsResult;
+            }
+            return `Unknown terminal (TERM_PROGRAM=${process.env['TERM_PROGRAM'] ?? 'unset'}).
+
+Try these methods:
+- \\ + Enter (backslash then Enter)
+- Ctrl+J
+- Option+Enter
+
+Run /terminal-setup in VS Code to configure Shift+Enter.`;
+        }
+    }
+}
+// Keep old export for backward compatibility during transition
+export { setupTerminal as setupVSCodeTerminal };

package/dist/common/components/CommandSuggestions.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { CommandInfo } from '../types.js';
+type Props = {
+    suggestions: CommandInfo[];
+    selectedIndex: number;
+    visible: boolean;
+};
+export default function CommandSuggestions({ suggestions, selectedIndex, visible, }: Props): React.JSX.Element | null;
+export {};

package/dist/common/components/CommandSuggestions.js

@@ -0,0 +1,20 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+export default function CommandSuggestions({ suggestions, selectedIndex, visible, }) {
+    if (!visible || suggestions.length === 0) {
+        return null;
+    }
+    // Calculate max command width for alignment
+    const maxCmdWidth = Math.max(...suggestions.map(s => s.command.length));
+    return (React.createElement(Box, { flexDirection: "column", marginLeft: 2, marginTop: 0 }, suggestions.map((suggestion, index) => {
+        const isSelected = index === selectedIndex;
+        const paddedCmd = suggestion.command.padEnd(maxCmdWidth);
+        return (React.createElement(Box, { key: suggestion.command },
+            React.createElement(Text, { color: isSelected ? 'cyan' : undefined, inverse: isSelected },
+                ' ',
+                paddedCmd),
+            React.createElement(Text, { dimColor: !isSelected, color: isSelected ? 'gray' : undefined },
+                ' ',
+                suggestion.description)));
+    })));
+}

package/dist/common/components/StaticWithResize.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+export type StaticWithResizeProps<T extends {
+    id: string;
+}> = {
+    /**
+     * Items to render statically.
+     */
+    items: T[];
+    /**
+     * Render function for each item.
+     */
+    children: (item: T, index: number) => React.ReactNode;
+};
+/**
+ * Drop-in replacement for Ink's <Static> that handles terminal resize.
+ *
+ * On resize, clears the terminal and forces Static to remount,
+ * which causes Ink to re-render all items with proper formatting.
+ */
+export declare function StaticWithResize<T extends {
+    id: string;
+}>({ items, children, }: StaticWithResizeProps<T>): React.ReactElement;
+export default StaticWithResize;

package/dist/common/components/StaticWithResize.js

@@ -0,0 +1,62 @@
+import React, { useState, useRef, useEffect, useCallback } from 'react';
+import { Static, useStdout } from 'ink';
+import { useTerminalResize } from '../hooks/useTerminalResize.js';
+/**
+ * ANSI escape sequences for terminal control.
+ */
+const ANSI = {
+    /** Clear visible screen */
+    CLEAR_SCREEN: '\x1B[2J',
+    /** Clear scrollback buffer */
+    CLEAR_SCROLLBACK: '\x1B[3J',
+    /** Move cursor to top-left */
+    CURSOR_HOME: '\x1B[H',
+};
+/**
+ * Drop-in replacement for Ink's <Static> that handles terminal resize.
+ *
+ * On resize, clears the terminal and forces Static to remount,
+ * which causes Ink to re-render all items with proper formatting.
+ */
+export function StaticWithResize({ items, children, }) {
+    const { stdout } = useStdout();
+    const [generation, setGeneration] = useState(0);
+    const resizeTimerRef = useRef(null);
+    // Debounced resize handler that clears terminal and forces remount
+    const handleResize = useCallback(() => {
+        if (resizeTimerRef.current) {
+            clearTimeout(resizeTimerRef.current);
+        }
+        resizeTimerRef.current = setTimeout(() => {
+            if (stdout && items.length > 0) {
+                // Clear terminal
+                stdout.write(ANSI.CLEAR_SCREEN + ANSI.CLEAR_SCROLLBACK + ANSI.CURSOR_HOME);
+                // Force Static to remount by changing key - this re-renders all items
+                setGeneration(g => g + 1);
+            }
+            resizeTimerRef.current = null;
+        }, 150); // Wait for resize to fully settle
+    }, [stdout, items.length]);
+    // Cleanup timer on unmount
+    useEffect(() => {
+        return () => {
+            if (resizeTimerRef.current) {
+                clearTimeout(resizeTimerRef.current);
+            }
+        };
+    }, []);
+    // Handle resize events
+    useTerminalResize({
+        onResize: (dimensions, previousDimensions) => {
+            if (previousDimensions &&
+                (dimensions.rows !== previousDimensions.rows ||
+                    dimensions.columns !== previousDimensions.columns)) {
+                handleResize();
+            }
+        },
+        debounceMs: 100,
+    });
+    // Key forces remount of Static, causing all items to re-render
+    return (React.createElement(Static, { key: generation, items: items }, (item, index) => children(item, index)));
+}
+export default StaticWithResize;

package/dist/common/components/StatusBar.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { AppStatus, IndexDisplayStats } from '../types.js';
+type Props = {
+    status: AppStatus;
+    stats: IndexDisplayStats | null | undefined;
+};
+export default function StatusBar({ status, stats }: Props): React.JSX.Element;
+export {};

package/dist/common/components/StatusBar.js

@@ -0,0 +1,64 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+/** Braille dots spinner frames */
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+/**
+ * Simple spinner component using interval-based animation.
+ */
+function Spinner({ color }) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setFrame(f => (f + 1) % SPINNER_FRAMES.length);
+        }, 80);
+        return () => clearInterval(timer);
+    }, []);
+    return React.createElement(Text, { color: color },
+        SPINNER_FRAMES[frame],
+        " ");
+}
+/**
+ * Format status message for display.
+ */
+function formatStatus(status) {
+    switch (status.state) {
+        case 'ready':
+            return { text: 'Ready', color: 'green', showSpinner: false };
+        case 'indexing': {
+            if (status.total === 0) {
+                return { text: `${status.stage}`, color: 'cyan', showSpinner: true };
+            }
+            const percent = Math.round((status.current / status.total) * 100);
+            return {
+                text: `${status.stage} ${status.current}/${status.total} (${percent}%)`,
+                color: 'cyan',
+                showSpinner: true,
+            };
+        }
+        case 'searching':
+            return { text: 'Searching', color: 'cyan', showSpinner: true };
+        case 'warning':
+            return { text: status.message, color: 'yellow', showSpinner: false };
+    }
+}
+/**
+ * Format stats for display.
+ */
+function formatStats(stats) {
+    if (stats === undefined) {
+        return 'Loading...';
+    }
+    if (stats === null) {
+        return 'Not indexed';
+    }
+    return `${stats.totalFiles} files · ${stats.totalChunks} chunks`;
+}
+export default function StatusBar({ status, stats }) {
+    const { text, color, showSpinner } = formatStatus(status);
+    const statsText = formatStats(stats);
+    return (React.createElement(Box, { paddingX: 1, justifyContent: "space-between" },
+        React.createElement(Box, null,
+            showSpinner && React.createElement(Spinner, { color: color }),
+            React.createElement(Text, { color: color }, text)),
+        React.createElement(Text, { dimColor: true }, statsText)));
+}

package/dist/common/components/TextInput.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { CommandInfo } from '../types.js';
+type Props = {
+    onSubmit: (text: string) => void;
+    onCtrlC: () => void;
+    commands?: CommandInfo[];
+    navigateHistoryUp?: () => string | null;
+    navigateHistoryDown?: () => string | null;
+    resetHistoryIndex?: () => void;
+};
+export default function TextInput({ onSubmit, onCtrlC, commands, navigateHistoryUp, navigateHistoryDown, resetHistoryIndex, }: Props): React.JSX.Element;
+export {};

package/dist/common/components/TextInput.js

@@ -0,0 +1,239 @@
+import React, { useState, useMemo, useRef } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { useTextBuffer } from '../hooks/useTextBuffer.js';
+import CommandSuggestions from './CommandSuggestions.js';
+function filterCommands(input, commands) {
+    if (!input.startsWith('/'))
+        return [];
+    const lower = input.toLowerCase();
+    return commands.filter(cmd => cmd.command.toLowerCase().startsWith(lower));
+}
+export default function TextInput({ onSubmit, onCtrlC, commands = [], navigateHistoryUp, navigateHistoryDown, resetHistoryIndex, }) {
+    const { state, insertChar, insertNewline, deleteChar, deleteCharBefore, moveCursor, clear, setText, getText, isEmpty, } = useTextBuffer();
+    const [selectedSuggestionIndex, setSelectedSuggestionIndex] = useState(0);
+    // Track ESC key timing for ESC+Enter newline detection
+    // (used by /terminal-setup which sends \u001b\r for Shift+Enter)
+    const escPressedTimeRef = useRef(0);
+    // Filter commands based on current input
+    const currentText = getText();
+    const suggestions = useMemo(() => filterCommands(currentText, commands), [currentText, commands]);
+    const suggestionsVisible = suggestions.length > 0;
+    useInput((input, key) => {
+        // Reset history index when user types
+        if (input && !key.ctrl && !key.meta) {
+            resetHistoryIndex?.();
+        }
+        // Ctrl+C handling
+        if (key.ctrl && input === 'c') {
+            if (!isEmpty()) {
+                clear();
+                setSelectedSuggestionIndex(0);
+            }
+            // Always call onCtrlC so the quit timer starts even when clearing text
+            onCtrlC();
+            return;
+        }
+        // === CSI u detection for iTerm2/Kitty with enhanced keyboard mode ===
+        // When "Report modifiers using CSI u" is enabled:
+        //   Shift+Enter sends: \x1b[13;2u (keycode=13/Enter, modifier=2/Shift)
+        //   Alt+Enter sends: \x1b[13;3u (modifier=3/Alt)
+        // Ink strips the ESC prefix, leaving: [13;2u or [13;3u
+        if (input === '[13;2u' || input === '[13;3u') {
+            insertNewline();
+            setSelectedSuggestionIndex(0);
+            escPressedTimeRef.current = 0;
+            return;
+        }
+        // === ESC+LF/CR detection for VS Code (via /terminal-setup) ===
+        // VS Code keybinding sends ESC (0x1B) + LF (0x0A) or ESC + CR (0x0D)
+        // Ink's parseKeypress doesn't recognize this 2-byte sequence, so:
+        // - keypress.name stays empty → key.return = false
+        // - ESC is stripped → input = '\n' or '\r'
+        // Detection: input is newline char BUT key.return is false (unrecognized sequence)
+        if ((input === '\n' || input === '\r') &&
+            !key.return &&
+            !key.ctrl &&
+            !key.shift) {
+            insertNewline();
+            setSelectedSuggestionIndex(0);
+            escPressedTimeRef.current = 0;
+            return;
+        }
+        // Also handle when escape/meta flag is set (fallback for terminals that do parse it)
+        if ((key.escape || key.meta) && (input === '\n' || input === '\r')) {
+            insertNewline();
+            setSelectedSuggestionIndex(0);
+            escPressedTimeRef.current = 0;
+            return;
+        }
+        // Ctrl+J - explicit handling for terminals that report it as ctrl+j
+        // (Most terminals send raw LF which is caught by the ESC+LF detection above)
+        if (key.ctrl && input === 'j') {
+            insertNewline();
+            setSelectedSuggestionIndex(0);
+            return;
+        }
+        // Tab - accept suggestion
+        if (key.tab && suggestionsVisible) {
+            const selected = suggestions[selectedSuggestionIndex];
+            if (selected) {
+                setText(selected.command);
+                setSelectedSuggestionIndex(0);
+            }
+            return;
+        }
+        // Submit on Enter (without shift) - but check for ESC+Enter and backslash first
+        if (key.return && !key.shift && !key.meta) {
+            // Timing-based ESC+Enter detection (for terminals that send separately)
+            if (Date.now() - escPressedTimeRef.current < 150) {
+                insertNewline();
+                setSelectedSuggestionIndex(0);
+                escPressedTimeRef.current = 0;
+                return;
+            }
+            // Method 1: Backslash + Enter (universal newline)
+            const currentLine = state.lines[state.cursorLine] ?? '';
+            const charBeforeCursor = currentLine[state.cursorCol - 1];
+            if (charBeforeCursor === '\\') {
+                // Remove backslash and insert newline
+                deleteCharBefore();
+                insertNewline();
+                setSelectedSuggestionIndex(0);
+                return;
+            }
+            let text = getText();
+            // If suggestions visible, complete AND submit in one action
+            if (suggestionsVisible) {
+                const selected = suggestions[selectedSuggestionIndex];
+                if (selected) {
+                    text = selected.command;
+                }
+            }
+            // Submit
+            if (text.trim()) {
+                onSubmit(text);
+                clear();
+                setSelectedSuggestionIndex(0);
+            }
+            return;
+        }
+        // Method 2: Shift+Enter for newline (Kitty terminals)
+        if (key.return && key.shift) {
+            insertNewline();
+            setSelectedSuggestionIndex(0);
+            return;
+        }
+        // Method 4: Alt/Option+Enter for newline (most terminals)
+        if (key.return && key.meta) {
+            insertNewline();
+            setSelectedSuggestionIndex(0);
+            return;
+        }
+        // Backspace
+        if (key.backspace) {
+            deleteChar();
+            setSelectedSuggestionIndex(0);
+            return;
+        }
+        // Delete key
+        if (key.delete) {
+            deleteChar();
+            setSelectedSuggestionIndex(0);
+            return;
+        }
+        // Up arrow
+        if (key.upArrow) {
+            if (suggestionsVisible) {
+                // Navigate suggestions
+                setSelectedSuggestionIndex(i => Math.max(0, i - 1));
+            }
+            else if (isEmpty() && navigateHistoryUp) {
+                // Navigate history when input is empty
+                const prev = navigateHistoryUp();
+                if (prev !== null) {
+                    setText(prev);
+                }
+            }
+            else {
+                // Move cursor in multi-line
+                moveCursor('up');
+            }
+            return;
+        }
+        // Down arrow
+        if (key.downArrow) {
+            if (suggestionsVisible) {
+                // Navigate suggestions
+                setSelectedSuggestionIndex(i => Math.min(suggestions.length - 1, i + 1));
+            }
+            else if (isEmpty() && navigateHistoryDown) {
+                // Navigate history when input is empty
+                const next = navigateHistoryDown();
+                if (next !== null) {
+                    setText(next);
+                }
+                else {
+                    clear();
+                }
+            }
+            else {
+                // Move cursor in multi-line
+                moveCursor('down');
+            }
+            return;
+        }
+        // Left/Right arrows
+        if (key.leftArrow) {
+            moveCursor('left');
+            return;
+        }
+        if (key.rightArrow) {
+            moveCursor('right');
+            return;
+        }
+        // Plain ESC key - clear input after a delay
+        // (ESC+LF for Shift+Enter is already handled above)
+        if (key.escape && !input) {
+            escPressedTimeRef.current = Date.now();
+            setTimeout(() => {
+                if (escPressedTimeRef.current !== 0) {
+                    clear();
+                    setSelectedSuggestionIndex(0);
+                    escPressedTimeRef.current = 0;
+                }
+            }, 150);
+            return;
+        }
+        // Regular character input (ignore control sequences and newlines)
+        if (input &&
+            !key.ctrl &&
+            !key.meta &&
+            !key.escape &&
+            input !== '\n' &&
+            input !== '\r') {
+            insertChar(input);
+            setSelectedSuggestionIndex(0);
+        }
+    });
+    // Render lines with cursor
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "blue", paddingX: 1 }, state.lines.map((line, lineIdx) => {
+            const isCurrentLine = lineIdx === state.cursorLine;
+            const prefix = lineIdx === 0 ? '> ' : '  ';
+            if (!isCurrentLine) {
+                return (React.createElement(Box, { key: lineIdx },
+                    React.createElement(Text, { color: "blue" }, prefix),
+                    React.createElement(Text, null, line || ' ')));
+            }
+            // Current line with cursor - render as three parts on same line
+            const beforeCursor = line.slice(0, state.cursorCol);
+            const cursorChar = line[state.cursorCol] ?? ' ';
+            const afterCursor = line.slice(state.cursorCol + 1);
+            return (React.createElement(Box, { key: lineIdx },
+                React.createElement(Text, { color: "blue" }, prefix),
+                React.createElement(Text, null, beforeCursor),
+                React.createElement(Text, { inverse: true }, cursorChar),
+                React.createElement(Text, null, afterCursor)));
+        })),
+        React.createElement(CommandSuggestions, { suggestions: suggestions, selectedIndex: selectedSuggestionIndex, visible: suggestionsVisible })));
+}

package/dist/common/components/index.d.ts

@@ -0,0 +1,3 @@
+export { default as TextInput } from './TextInput.js';
+export { default as StatusBar } from './StatusBar.js';
+export { default as CommandSuggestions } from './CommandSuggestions.js';

package/dist/common/components/index.js

@@ -0,0 +1,3 @@
+export { default as TextInput } from './TextInput.js';
+export { default as StatusBar } from './StatusBar.js';
+export { default as CommandSuggestions } from './CommandSuggestions.js';

package/dist/common/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export { useCtrlC } from './useCtrlC.js';
+export { useCommandHistory } from './useCommandHistory.js';
+export { useTextBuffer } from './useTextBuffer.js';
+export { useKittyKeyboard } from './useKittyKeyboard.js';

package/dist/common/hooks/index.js

@@ -0,0 +1,4 @@
+export { useCtrlC } from './useCtrlC.js';
+export { useCommandHistory } from './useCommandHistory.js';
+export { useTextBuffer } from './useTextBuffer.js';
+export { useKittyKeyboard } from './useKittyKeyboard.js';

package/dist/common/hooks/useCommandHistory.d.ts

@@ -0,0 +1,7 @@
+export declare function useCommandHistory(): {
+    history: string[];
+    addToHistory: (command: string) => void;
+    navigateUp: () => string | null;
+    navigateDown: () => string | null;
+    resetIndex: () => void;
+};

package/dist/common/hooks/useCommandHistory.js

@@ -0,0 +1,51 @@
+import { useState, useCallback, useRef } from 'react';
+export function useCommandHistory() {
+    const [history, setHistory] = useState([]);
+    const indexRef = useRef(-1);
+    const addToHistory = useCallback((command) => {
+        // Don't add empty or duplicate consecutive commands
+        setHistory(prev => {
+            if (!command.trim() || prev[prev.length - 1] === command) {
+                return prev;
+            }
+            return [...prev, command];
+        });
+        // Reset index when adding new command
+        indexRef.current = -1;
+    }, []);
+    const navigateUp = useCallback(() => {
+        if (history.length === 0)
+            return null;
+        // If not navigating yet, start from the end
+        if (indexRef.current === -1) {
+            indexRef.current = history.length - 1;
+        }
+        else if (indexRef.current > 0) {
+            indexRef.current -= 1;
+        }
+        return history[indexRef.current] ?? null;
+    }, [history]);
+    const navigateDown = useCallback(() => {
+        if (history.length === 0 || indexRef.current === -1)
+            return null;
+        if (indexRef.current < history.length - 1) {
+            indexRef.current += 1;
+            return history[indexRef.current] ?? null;
+        }
+        else {
+            // At the end, reset and return null to clear input
+            indexRef.current = -1;
+            return null;
+        }
+    }, [history]);
+    const resetIndex = useCallback(() => {
+        indexRef.current = -1;
+    }, []);
+    return {
+        history,
+        addToHistory,
+        navigateUp,
+        navigateDown,
+        resetIndex,
+    };
+}