@quantum-ai/gemini-cli 0.45.8 → 0.45.10

package/dist/ui/hooks/useGitBranchName.js

@@ -0,0 +1,77 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { spawnAsync, getAbsoluteGitDir } from '@google/gemini-cli-core';
+import fs from 'node:fs';
+import fsPromises from 'node:fs/promises';
+export function useGitBranchName(cwd) {
+    const [branchName, setBranchName] = useState(undefined);
+    const timeoutRef = useRef(null);
+    const fetchBranchName = useCallback(async () => {
+        try {
+            const { stdout } = await spawnAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd });
+            const branch = stdout.toString().trim();
+            if (branch && branch !== 'HEAD') {
+                setBranchName(branch);
+            }
+            else {
+                const { stdout: hashStdout } = await spawnAsync('git', ['rev-parse', '--short', 'HEAD'], { cwd });
+                setBranchName(hashStdout.toString().trim());
+            }
+        }
+        catch {
+            setBranchName(undefined);
+        }
+    }, [cwd, setBranchName]);
+    useEffect(() => {
+        void fetchBranchName(); // Initial fetch
+        let watcher;
+        let cancelled = false;
+        const setupWatcher = async () => {
+            try {
+                const gitDir = await getAbsoluteGitDir(cwd);
+                if (!gitDir)
+                    return;
+                // Ensure we can access the git dir
+                await fsPromises.access(gitDir, fs.constants.F_OK);
+                if (cancelled)
+                    return;
+                const w = fs.watch(gitDir, (eventType, filename) => {
+                    // Changes to HEAD indicate branch checkout or detached commit.
+                    // On some platforms filename may be null, so we refresh in that case too.
+                    if (!filename || filename === 'HEAD') {
+                        if (timeoutRef.current) {
+                            clearTimeout(timeoutRef.current);
+                        }
+                        timeoutRef.current = setTimeout(() => {
+                            void fetchBranchName();
+                        }, 100);
+                    }
+                });
+                if (cancelled) {
+                    w.close();
+                }
+                else {
+                    watcher = w;
+                }
+            }
+            catch {
+                // Silently ignore watcher errors (e.g. permissions or file not existing),
+                // similar to how exec errors are handled.
+                // The branch name will simply not update automatically.
+            }
+        };
+        void setupWatcher();
+        return () => {
+            cancelled = true;
+            if (timeoutRef.current) {
+                clearTimeout(timeoutRef.current);
+            }
+            watcher?.close();
+        };
+    }, [cwd, fetchBranchName]);
+    return branchName;
+}

package/dist/ui/hooks/useHistoryManager.js

@@ -0,0 +1,113 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useRef, useCallback, useMemo } from 'react';
+/**
+ * Custom hook to manage the chat history state.
+ *
+ * Encapsulates the history array, message ID generation, adding items,
+ * updating items, and clearing the history.
+ */
+export function useHistory({ chatRecordingService, initialItems = [], } = {}) {
+    const [history, setHistory] = useState(initialItems);
+    const lastIdRef = useRef(initialItems.reduce((max, item) => Math.max(max, item.id), 0));
+    // Generates a unique message ID based on a timestamp, ensuring it is always
+    // greater than any previously assigned ID.
+    const getNextMessageId = useCallback((baseTimestamp) => {
+        const nextId = Math.max(baseTimestamp, lastIdRef.current + 1);
+        lastIdRef.current = nextId;
+        return nextId;
+    }, []);
+    const loadHistory = useCallback((newHistory) => {
+        setHistory(newHistory);
+        const maxId = newHistory.reduce((max, item) => Math.max(max, item.id), 0);
+        lastIdRef.current = Math.max(lastIdRef.current, maxId);
+    }, []);
+    // Adds a new item to the history state with a unique ID.
+    const addItem = useCallback((itemData, baseTimestamp = Date.now(), isResuming = false) => {
+        const id = getNextMessageId(baseTimestamp);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        const newItem = { ...itemData, id };
+        setHistory((prevHistory) => {
+            if (prevHistory.length > 0) {
+                const lastItem = prevHistory[prevHistory.length - 1];
+                // Prevent adding duplicate consecutive user messages
+                if (lastItem.type === 'user' &&
+                    newItem.type === 'user' &&
+                    lastItem.text === newItem.text) {
+                    return prevHistory; // Don't add the duplicate
+                }
+            }
+            return [...prevHistory, newItem];
+        });
+        // Record UI-specific messages, but don't do it if we're actually loading
+        // an existing session.
+        if (!isResuming && chatRecordingService) {
+            switch (itemData.type) {
+                case 'compression':
+                case 'info':
+                    chatRecordingService?.recordMessage({
+                        model: undefined,
+                        type: 'info',
+                        content: itemData.text ?? '',
+                    });
+                    break;
+                case 'warning':
+                    chatRecordingService?.recordMessage({
+                        model: undefined,
+                        type: 'warning',
+                        content: itemData.text ?? '',
+                    });
+                    break;
+                case 'error':
+                    chatRecordingService?.recordMessage({
+                        model: undefined,
+                        type: 'error',
+                        content: itemData.text ?? '',
+                    });
+                    break;
+                case 'user':
+                case 'gemini':
+                case 'gemini_content':
+                    // Core conversation recording handled by GeminiChat.
+                    break;
+                default:
+                    // Ignore the rest.
+                    break;
+            }
+        }
+        return id; // Return the generated ID (even if not added, to keep signature)
+    }, [getNextMessageId, chatRecordingService]);
+    /**
+     * Updates an existing history item identified by its ID.
+     * @deprecated Prefer not to update history item directly as we are currently
+     * rendering all history items in <Static /> for performance reasons. Only use
+     * if ABSOLUTELY NECESSARY
+     */
+    //
+    const updateItem = useCallback((id, updates) => {
+        setHistory((prevHistory) => prevHistory.map((item) => {
+            if (item.id === id) {
+                // Apply updates based on whether it's an object or a function
+                const newUpdates = typeof updates === 'function' ? updates(item) : updates;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                return { ...item, ...newUpdates };
+            }
+            return item;
+        }));
+    }, []);
+    // Clears the entire history state and resets the ID counter.
+    const clearItems = useCallback(() => {
+        setHistory([]);
+        lastIdRef.current = 0;
+    }, []);
+    return useMemo(() => ({
+        history,
+        addItem,
+        updateItem,
+        clearItems,
+        loadHistory,
+    }), [history, addItem, updateItem, clearItems, loadHistory]);
+}

package/dist/ui/hooks/useHookDisplayState.js

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useEffect, useRef } from 'react';
+import { coreEvents, CoreEvent, } from '@google/gemini-cli-core';
+import { WARNING_PROMPT_DURATION_MS } from '../constants.js';
+export const useHookDisplayState = () => {
+    const [activeHooks, setActiveHooks] = useState([]);
+    // Track start times independently of render state to calculate duration in event handlers
+    // Key: `${hookName}:${eventName}` -> Stack of StartTimes (FIFO)
+    const hookStartTimes = useRef(new Map());
+    // Track active timeouts to clear them on unmount
+    const timeouts = useRef(new Set());
+    useEffect(() => {
+        const activeTimeouts = timeouts.current;
+        const startTimes = hookStartTimes.current;
+        const handleHookStart = (payload) => {
+            const key = `${payload.hookName}:${payload.eventName}`;
+            const now = Date.now();
+            // Add start time to ref
+            if (!startTimes.has(key)) {
+                startTimes.set(key, []);
+            }
+            startTimes.get(key).push(now);
+            setActiveHooks((prev) => [
+                ...prev,
+                {
+                    name: payload.hookName,
+                    eventName: payload.eventName,
+                    source: payload.source,
+                    index: payload.hookIndex,
+                    total: payload.totalHooks,
+                },
+            ]);
+        };
+        const handleHookEnd = (payload) => {
+            const key = `${payload.hookName}:${payload.eventName}`;
+            const starts = startTimes.get(key);
+            const startTime = starts?.shift(); // Get the earliest start time for this hook type
+            // Cleanup empty arrays in map
+            if (starts && starts.length === 0) {
+                startTimes.delete(key);
+            }
+            const now = Date.now();
+            // Default to immediate removal if start time not found (defensive)
+            const elapsed = startTime ? now - startTime : WARNING_PROMPT_DURATION_MS;
+            const remaining = WARNING_PROMPT_DURATION_MS - elapsed;
+            const removeHook = () => {
+                setActiveHooks((prev) => {
+                    const index = prev.findIndex((h) => h.name === payload.hookName && h.eventName === payload.eventName);
+                    if (index === -1)
+                        return prev;
+                    const newHooks = [...prev];
+                    newHooks.splice(index, 1);
+                    return newHooks;
+                });
+            };
+            if (remaining > 0) {
+                const timeoutId = setTimeout(() => {
+                    removeHook();
+                    activeTimeouts.delete(timeoutId);
+                }, remaining);
+                activeTimeouts.add(timeoutId);
+            }
+            else {
+                removeHook();
+            }
+        };
+        coreEvents.on(CoreEvent.HookStart, handleHookStart);
+        coreEvents.on(CoreEvent.HookEnd, handleHookEnd);
+        return () => {
+            coreEvents.off(CoreEvent.HookStart, handleHookStart);
+            coreEvents.off(CoreEvent.HookEnd, handleHookEnd);
+            // Clear all pending timeouts
+            activeTimeouts.forEach(clearTimeout);
+            activeTimeouts.clear();
+        };
+    }, []);
+    return activeHooks;
+};

package/dist/ui/hooks/useIdeTrustListener.js

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useCallback, useEffect, useState, useSyncExternalStore, useRef, } from 'react';
+import { IdeClient, IDEConnectionStatus, ideContextStore, } from '@google/gemini-cli-core';
+import { useSettings } from '../contexts/SettingsContext.js';
+import { isWorkspaceTrusted } from '../../config/trustedFolders.js';
+/**
+ * This hook listens for trust status updates from the IDE companion extension.
+ * It provides the current trust status from the IDE and a reason if a restart
+ * is needed because the trust state has changed.
+ */
+export function useIdeTrustListener() {
+    const settings = useSettings();
+    const [connectionStatus, setConnectionStatus] = useState(IDEConnectionStatus.Disconnected);
+    const previousTrust = useRef(undefined);
+    const [restartReason, setRestartReason] = useState('NONE');
+    const [needsRestart, setNeedsRestart] = useState(false);
+    const subscribe = useCallback((onStoreChange) => {
+        const handleStatusChange = (state) => {
+            setConnectionStatus(state.status);
+            setRestartReason('CONNECTION_CHANGE');
+            // Also notify useSyncExternalStore that the data has changed
+            onStoreChange();
+        };
+        const handleTrustChange = () => {
+            setRestartReason('TRUST_CHANGE');
+            onStoreChange();
+        };
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        (async () => {
+            const ideClient = await IdeClient.getInstance();
+            ideClient.addTrustChangeListener(handleTrustChange);
+            ideClient.addStatusChangeListener(handleStatusChange);
+            setConnectionStatus(ideClient.getConnectionStatus().status);
+        })();
+        return () => {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            (async () => {
+                const ideClient = await IdeClient.getInstance();
+                ideClient.removeTrustChangeListener(handleTrustChange);
+                ideClient.removeStatusChangeListener(handleStatusChange);
+            })();
+        };
+    }, []);
+    const getSnapshot = () => {
+        if (connectionStatus !== IDEConnectionStatus.Connected) {
+            return undefined;
+        }
+        return ideContextStore.get()?.workspaceState?.isTrusted;
+    };
+    const isIdeTrusted = useSyncExternalStore(subscribe, getSnapshot);
+    useEffect(() => {
+        const currentTrust = isWorkspaceTrusted(settings.merged).isTrusted;
+        // Trigger a restart if the overall trust status for the CLI has changed,
+        // but not on the initial trust value.
+        if (previousTrust.current !== undefined &&
+            previousTrust.current !== currentTrust) {
+            setNeedsRestart(true);
+        }
+        previousTrust.current = currentTrust;
+    }, [isIdeTrusted, settings.merged]);
+    return { isIdeTrusted, needsRestart, restartReason };
+}

package/dist/ui/hooks/useInactivityTimer.js

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useEffect } from 'react';
+/**
+ * Returns true after a specified delay of inactivity.
+ * Inactivity is defined as 'trigger' not changing for 'delayMs' milliseconds.
+ *
+ * @param isActive Whether the timer should be running.
+ * @param trigger Any value that, when changed, resets the inactivity timer.
+ * @param delayMs The delay in milliseconds before considering the state inactive.
+ */
+export const useInactivityTimer = (isActive, trigger, delayMs = 5000) => {
+    const [isInactive, setIsInactive] = useState(false);
+    useEffect(() => {
+        if (!isActive) {
+            setIsInactive(false);
+            return;
+        }
+        setIsInactive(false);
+        const timer = setTimeout(() => {
+            setIsInactive(true);
+        }, delayMs);
+        return () => clearTimeout(timer);
+    }, [isActive, trigger, delayMs]);
+    return isInactive;
+};

package/dist/ui/hooks/useIncludeDirsTrust.js

@@ -0,0 +1,109 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useEffect } from 'react';
+import { loadTrustedFolders } from '../../config/trustedFolders.js';
+import { expandHomeDir, batchAddDirectories } from '../utils/directoryUtils.js';
+import { debugLogger } from '@google/gemini-cli-core';
+import { MultiFolderTrustDialog } from '../components/MultiFolderTrustDialog.js';
+import { MessageType } from '../types.js';
+async function finishAddingDirectories(config, addItem, added, errors) {
+    if (!config) {
+        addItem({
+            type: MessageType.ERROR,
+            text: 'Configuration is not available.',
+        });
+        return;
+    }
+    try {
+        if (config.shouldLoadMemoryFromIncludeDirectories()) {
+            await config.getMemoryContextManager()?.refresh();
+        }
+    }
+    catch (error) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        errors.push(`Error refreshing memory: ${error.message}`);
+    }
+    if (added.length > 0) {
+        const gemini = config.getGeminiClient();
+        if (gemini) {
+            await gemini.addDirectoryContext();
+        }
+    }
+    if (errors.length > 0) {
+        addItem({ type: MessageType.ERROR, text: errors.join('\n') });
+    }
+}
+export function useIncludeDirsTrust(config, isTrustedFolder, historyManager, setCustomDialog) {
+    const { addItem } = historyManager;
+    useEffect(() => {
+        // Don't run this until the initial trust is determined.
+        if (isTrustedFolder === undefined || !config) {
+            return;
+        }
+        const pendingDirs = config.getPendingIncludeDirectories();
+        if (pendingDirs.length === 0) {
+            return;
+        }
+        // If folder trust is disabled, isTrustedFolder will be undefined.
+        // In that case, or if the user decided not to trust the main folder,
+        // we can just add the directories without checking them.
+        if (config.getFolderTrust() === false || isTrustedFolder === false) {
+            const added = [];
+            const errors = [];
+            const workspaceContext = config.getWorkspaceContext();
+            const result = batchAddDirectories(workspaceContext, pendingDirs);
+            added.push(...result.added);
+            errors.push(...result.errors);
+            if (added.length > 0 || errors.length > 0) {
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                finishAddingDirectories(config, addItem, added, errors);
+            }
+            config.clearPendingIncludeDirectories();
+            return;
+        }
+        const trustedFolders = loadTrustedFolders();
+        const untrustedDirs = [];
+        const undefinedTrustDirs = [];
+        const trustedDirs = [];
+        const added = [];
+        const errors = [];
+        for (const pathToAdd of pendingDirs) {
+            const expandedPath = expandHomeDir(pathToAdd.trim());
+            const isTrusted = trustedFolders.isPathTrusted(expandedPath);
+            if (isTrusted === false) {
+                untrustedDirs.push(pathToAdd.trim());
+            }
+            else if (isTrusted === undefined) {
+                undefinedTrustDirs.push(pathToAdd.trim());
+            }
+            else {
+                trustedDirs.push(pathToAdd.trim());
+            }
+        }
+        if (untrustedDirs.length > 0) {
+            errors.push(`The following directories are explicitly untrusted and cannot be added to a trusted workspace:\n- ${untrustedDirs.join('\n- ')}\nPlease use the permissions command to modify their trust level.`);
+        }
+        const workspaceContext = config.getWorkspaceContext();
+        if (trustedDirs.length > 0) {
+            const result = batchAddDirectories(workspaceContext, trustedDirs);
+            added.push(...result.added);
+            errors.push(...result.errors);
+        }
+        if (undefinedTrustDirs.length > 0) {
+            debugLogger.log('Creating custom dialog with undecidedDirs:', undefinedTrustDirs);
+            setCustomDialog(_jsx(MultiFolderTrustDialog, { folders: undefinedTrustDirs, onComplete: () => {
+                    setCustomDialog(null);
+                    config.clearPendingIncludeDirectories();
+                }, trustedDirs: added, errors: errors, finishAddingDirectories: finishAddingDirectories, config: config, addItem: addItem }));
+        }
+        else if (added.length > 0 || errors.length > 0) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            finishAddingDirectories(config, addItem, added, errors);
+            config.clearPendingIncludeDirectories();
+        }
+    }, [isTrustedFolder, config, addItem, setCustomDialog]);
+}

package/dist/ui/hooks/useInlineEditBuffer.js

@@ -0,0 +1,112 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useReducer, useCallback, useEffect, useState } from 'react';
+import { cpSlice, cpLen, stripUnsafeCharacters } from '../utils/textUtils.js';
+const initialState = {
+    editingKey: null,
+    buffer: '',
+    cursorPos: 0,
+};
+function editBufferReducer(state, action) {
+    switch (action.type) {
+        case 'START_EDIT':
+            return {
+                editingKey: action.key,
+                buffer: action.initialValue,
+                cursorPos: cpLen(action.initialValue),
+            };
+        case 'COMMIT_EDIT':
+            return initialState;
+        case 'MOVE_LEFT':
+            return {
+                ...state,
+                cursorPos: Math.max(0, state.cursorPos - 1),
+            };
+        case 'MOVE_RIGHT':
+            return {
+                ...state,
+                cursorPos: Math.min(cpLen(state.buffer), state.cursorPos + 1),
+            };
+        case 'HOME':
+            return { ...state, cursorPos: 0 };
+        case 'END':
+            return { ...state, cursorPos: cpLen(state.buffer) };
+        case 'DELETE_LEFT': {
+            if (state.cursorPos === 0)
+                return state;
+            const before = cpSlice(state.buffer, 0, state.cursorPos - 1);
+            const after = cpSlice(state.buffer, state.cursorPos);
+            return {
+                ...state,
+                buffer: before + after,
+                cursorPos: state.cursorPos - 1,
+            };
+        }
+        case 'DELETE_RIGHT': {
+            if (state.cursorPos === cpLen(state.buffer))
+                return state;
+            const before = cpSlice(state.buffer, 0, state.cursorPos);
+            const after = cpSlice(state.buffer, state.cursorPos + 1);
+            return {
+                ...state,
+                buffer: before + after,
+            };
+        }
+        case 'INSERT_CHAR': {
+            let ch = action.char;
+            let isValidChar = false;
+            if (action.isNumberType) {
+                isValidChar = /[0-9\-+.]/.test(ch);
+            }
+            else {
+                isValidChar = ch.length === 1 && ch.charCodeAt(0) >= 32;
+                ch = stripUnsafeCharacters(ch);
+            }
+            if (!isValidChar || ch.length === 0)
+                return state;
+            const before = cpSlice(state.buffer, 0, state.cursorPos);
+            const after = cpSlice(state.buffer, state.cursorPos);
+            return {
+                ...state,
+                buffer: before + ch + after,
+                cursorPos: state.cursorPos + 1,
+            };
+        }
+        default:
+            return state;
+    }
+}
+export function useInlineEditBuffer({ onCommit }) {
+    const [state, dispatch] = useReducer(editBufferReducer, initialState);
+    const [cursorVisible, setCursorVisible] = useState(true);
+    useEffect(() => {
+        if (!state.editingKey) {
+            setCursorVisible(true);
+            return;
+        }
+        setCursorVisible(true);
+        const interval = setInterval(() => {
+            setCursorVisible((v) => !v);
+        }, 500);
+        return () => clearInterval(interval);
+    }, [state.editingKey, state.buffer, state.cursorPos]);
+    const startEditing = useCallback((key, initialValue) => {
+        dispatch({ type: 'START_EDIT', key, initialValue });
+    }, []);
+    const commitEdit = useCallback(() => {
+        if (state.editingKey) {
+            onCommit(state.editingKey, state.buffer);
+        }
+        dispatch({ type: 'COMMIT_EDIT' });
+    }, [state.editingKey, state.buffer, onCommit]);
+    return {
+        editState: state,
+        editDispatch: dispatch,
+        startEditing,
+        commitEdit,
+        cursorVisible,
+    };
+}

package/dist/ui/hooks/useInputHistory.js

@@ -0,0 +1,90 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useCallback, useRef } from 'react';
+import { cpLen } from '../utils/textUtils.js';
+export function useInputHistory({ userMessages, onSubmit, isActive, currentQuery, currentCursorOffset, onChange, }) {
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    // previousHistoryIndexRef tracks the index we occupied *immediately before* the current historyIndex.
+    // This allows us to detect when we are "returning" to a level we just left.
+    const previousHistoryIndexRef = useRef(undefined);
+    // Cache stores text and cursor offset for each history index level.
+    // Level -1 is the current unsubmitted prompt.
+    const historyCacheRef = useRef({});
+    const resetHistoryNav = useCallback(() => {
+        setHistoryIndex(-1);
+        previousHistoryIndexRef.current = undefined;
+        historyCacheRef.current = {};
+    }, []);
+    const handleSubmit = useCallback((value) => {
+        const trimmedValue = value.trim();
+        if (trimmedValue) {
+            onSubmit(trimmedValue); // Parent handles clearing the query
+        }
+        resetHistoryNav();
+    }, [onSubmit, resetHistoryNav]);
+    const navigateTo = useCallback((nextIndex, defaultCursor) => {
+        const prevIndexBeforeMove = historyIndex;
+        // 1. Save current state to cache before moving
+        historyCacheRef.current[prevIndexBeforeMove] = {
+            text: currentQuery,
+            offset: currentCursorOffset,
+        };
+        // 2. Update index
+        setHistoryIndex(nextIndex);
+        // 3. Restore next state
+        const saved = historyCacheRef.current[nextIndex];
+        // We robustly restore the cursor position IF:
+        // 1. We are returning to the compose prompt (-1)
+        // 2. OR we are returning to the level we occupied *just before* the current one.
+        // AND in both cases, the cursor was not at the very first or last character.
+        const isReturningToPrevious = nextIndex === -1 || nextIndex === previousHistoryIndexRef.current;
+        if (isReturningToPrevious &&
+            saved &&
+            saved.offset > 0 &&
+            saved.offset < cpLen(saved.text)) {
+            onChange(saved.text, saved.offset);
+        }
+        else if (nextIndex === -1) {
+            onChange(saved ? saved.text : '', defaultCursor);
+        }
+        else {
+            // For regular history browsing, use default cursor position.
+            if (saved) {
+                onChange(saved.text, defaultCursor);
+            }
+            else {
+                const newValue = userMessages[userMessages.length - 1 - nextIndex];
+                onChange(newValue, defaultCursor);
+            }
+        }
+        // Record the level we just came from for the next navigation
+        previousHistoryIndexRef.current = prevIndexBeforeMove;
+    }, [historyIndex, currentQuery, currentCursorOffset, userMessages, onChange]);
+    const navigateUp = useCallback(() => {
+        if (!isActive)
+            return false;
+        if (userMessages.length === 0)
+            return false;
+        if (historyIndex < userMessages.length - 1) {
+            navigateTo(historyIndex + 1, 'start');
+            return true;
+        }
+        return false;
+    }, [historyIndex, userMessages, isActive, navigateTo]);
+    const navigateDown = useCallback(() => {
+        if (!isActive)
+            return false;
+        if (historyIndex === -1)
+            return false; // Not currently navigating history
+        navigateTo(historyIndex - 1, 'end');
+        return true;
+    }, [historyIndex, isActive, navigateTo]);
+    return {
+        handleSubmit,
+        navigateUp,
+        navigateDown,
+    };
+}