@quantum-ai/gemini-cli 0.45.8 → 0.45.10

package/dist/ui/hooks/useShellHistory.js

@@ -0,0 +1,113 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useEffect, useCallback } from 'react';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { debugLogger, isNodeError, Storage } from '@google/gemini-cli-core';
+const MAX_HISTORY_LENGTH = 100;
+async function getHistoryFilePath(projectRoot, configStorage) {
+    const storage = configStorage ?? new Storage(projectRoot);
+    await storage.initialize();
+    return storage.getHistoryFilePath();
+}
+// Handle multiline commands
+async function readHistoryFile(filePath) {
+    try {
+        const text = await fs.readFile(filePath, 'utf-8');
+        const result = [];
+        let cur = '';
+        for (const raw of text.split(/\r?\n/)) {
+            if (!raw.trim())
+                continue;
+            const line = raw;
+            const m = cur.match(/(\\+)$/);
+            if (m && m[1].length % 2) {
+                // odd number of trailing '\'
+                cur = cur.slice(0, -1) + ' ' + line;
+            }
+            else {
+                if (cur)
+                    result.push(cur);
+                cur = line;
+            }
+        }
+        if (cur)
+            result.push(cur);
+        return result;
+    }
+    catch (err) {
+        if (isNodeError(err) && err.code === 'ENOENT')
+            return [];
+        debugLogger.error('Error reading history:', err);
+        return [];
+    }
+}
+async function writeHistoryFile(filePath, history) {
+    try {
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, history.join('\n'));
+    }
+    catch (error) {
+        debugLogger.error('Error writing shell history:', error);
+    }
+}
+export function useShellHistory(projectRoot, storage) {
+    const [history, setHistory] = useState([]);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const [historyFilePath, setHistoryFilePath] = useState(null);
+    useEffect(() => {
+        async function loadHistory() {
+            const filePath = await getHistoryFilePath(projectRoot, storage);
+            setHistoryFilePath(filePath);
+            const loadedHistory = await readHistoryFile(filePath);
+            setHistory(loadedHistory.reverse()); // Newest first
+        }
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        loadHistory();
+    }, [projectRoot, storage]);
+    const addCommandToHistory = useCallback((command) => {
+        if (!command.trim() || !historyFilePath) {
+            return;
+        }
+        const newHistory = [command, ...history.filter((c) => c !== command)]
+            .slice(0, MAX_HISTORY_LENGTH)
+            .filter(Boolean);
+        setHistory(newHistory);
+        // Write to file in reverse order (oldest first)
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        writeHistoryFile(historyFilePath, [...newHistory].reverse());
+        setHistoryIndex(-1);
+    }, [history, historyFilePath]);
+    const getPreviousCommand = useCallback(() => {
+        if (history.length === 0) {
+            return null;
+        }
+        const newIndex = Math.min(historyIndex + 1, history.length - 1);
+        setHistoryIndex(newIndex);
+        return history[newIndex] ?? null;
+    }, [history, historyIndex]);
+    const getNextCommand = useCallback(() => {
+        if (historyIndex < 0) {
+            return null;
+        }
+        const newIndex = historyIndex - 1;
+        setHistoryIndex(newIndex);
+        if (newIndex < 0) {
+            return '';
+        }
+        return history[newIndex] ?? null;
+    }, [history, historyIndex]);
+    const resetHistoryPosition = useCallback(() => {
+        setHistoryIndex(-1);
+    }, []);
+    return {
+        history,
+        addCommandToHistory,
+        getPreviousCommand,
+        getNextCommand,
+        resetHistoryPosition,
+    };
+}

package/dist/ui/hooks/useShellInactivityStatus.js

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useInactivityTimer } from './useInactivityTimer.js';
+import { useTurnActivityMonitor, } from './useTurnActivityMonitor.js';
+import { SHELL_FOCUS_HINT_DELAY_MS, SHELL_ACTION_REQUIRED_TITLE_DELAY_MS, SHELL_SILENT_WORKING_TITLE_DELAY_MS, } from '../constants.js';
+/**
+ * Consolidated hook to manage all shell-related inactivity states.
+ * Centralizes the timing heuristics and redirection suppression logic.
+ */
+export const useShellInactivityStatus = ({ activePtyId, lastOutputTime, streamingState, pendingToolCalls, embeddedShellFocused, isInteractiveShellEnabled, }) => {
+    const { operationStartTime, isRedirectionActive } = useTurnActivityMonitor(streamingState, activePtyId, pendingToolCalls);
+    const isAwaitingFocus = !!activePtyId && !embeddedShellFocused && isInteractiveShellEnabled;
+    // Derive whether output was produced by comparing the last output time to when the operation started.
+    const hasProducedOutput = lastOutputTime > operationStartTime;
+    // 1. Focus Hint (The "press tab to focus" message in the loading indicator)
+    // Logic: 5s if output has been produced, 20s if silent. Suppressed if redirected.
+    const shouldShowFocusHint = useInactivityTimer(isAwaitingFocus && !isRedirectionActive, lastOutputTime, hasProducedOutput
+        ? SHELL_FOCUS_HINT_DELAY_MS
+        : SHELL_FOCUS_HINT_DELAY_MS * 4);
+    // 2. Action Required Status (The ✋ icon in the terminal window title)
+    // Logic: Only if output has been produced (likely a prompt).
+    // Triggered after 30s of silence, but SUPPRESSED if redirection is active.
+    const shouldShowActionRequiredTitle = useInactivityTimer(isAwaitingFocus && !isRedirectionActive && hasProducedOutput, lastOutputTime, SHELL_ACTION_REQUIRED_TITLE_DELAY_MS);
+    // 3. Silent Working Status (The ⏲ icon in the terminal window title)
+    // Logic: If redirected OR if no output has been produced yet (e.g. sleep 600).
+    // Triggered after 2 mins for redirected, or 60s for non-redirected silent commands.
+    const shouldShowSilentWorkingTitle = useInactivityTimer(isAwaitingFocus && (isRedirectionActive || !hasProducedOutput), lastOutputTime, isRedirectionActive
+        ? SHELL_SILENT_WORKING_TITLE_DELAY_MS
+        : SHELL_ACTION_REQUIRED_TITLE_DELAY_MS * 2);
+    let inactivityStatus = 'none';
+    if (shouldShowActionRequiredTitle) {
+        inactivityStatus = 'action_required';
+    }
+    else if (shouldShowSilentWorkingTitle) {
+        inactivityStatus = 'silent_working';
+    }
+    return {
+        shouldShowFocusHint,
+        inactivityStatus,
+    };
+};

package/dist/ui/hooks/useSlashCompletion.js

@@ -0,0 +1,434 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useEffect, useMemo } from 'react';
+import { AsyncFzf } from 'fzf';
+import { CommandKind, } from '../commands/types.js';
+import { debugLogger } from '@google/gemini-cli-core';
+// Utility function to safely handle errors without information disclosure
+function logErrorSafely(error, context) {
+    if (error instanceof Error) {
+        // Log full error details securely for debugging
+        debugLogger.warn(`[${context}]`, error);
+    }
+    else {
+        debugLogger.warn(`[${context}] Non-error thrown:`, error);
+    }
+}
+// Shared utility function for command matching logic
+function matchesCommand(cmd, query) {
+    return (cmd.name.toLowerCase() === query.toLowerCase() ||
+        cmd.altNames?.some((alt) => alt.toLowerCase() === query.toLowerCase()) ||
+        false);
+}
+function useCommandParser(query, slashCommands) {
+    return useMemo(() => {
+        if (!query) {
+            return {
+                hasTrailingSpace: false,
+                commandPathParts: [],
+                partial: '',
+                currentLevel: slashCommands,
+                leafCommand: null,
+                isArgumentCompletion: false,
+            };
+        }
+        const fullPath = query.substring(1) || '';
+        const hasTrailingSpace = !!query.endsWith(' ');
+        const rawParts = fullPath.split(/\s+/).filter((p) => p);
+        let commandPathParts = rawParts;
+        let partial = '';
+        if (!hasTrailingSpace && rawParts.length > 0) {
+            partial = rawParts[rawParts.length - 1];
+            commandPathParts = rawParts.slice(0, -1);
+        }
+        let currentLevel = slashCommands;
+        let leafCommand = null;
+        for (const part of commandPathParts) {
+            if (!currentLevel) {
+                leafCommand = null;
+                currentLevel = [];
+                break;
+            }
+            const found = currentLevel.find((cmd) => matchesCommand(cmd, part));
+            if (found) {
+                leafCommand = found;
+                currentLevel = found.subCommands;
+                if (found.kind === CommandKind.MCP_PROMPT) {
+                    break;
+                }
+            }
+            else {
+                leafCommand = null;
+                currentLevel = [];
+                break;
+            }
+        }
+        const depth = commandPathParts.length;
+        const isArgumentCompletion = !!(leafCommand?.completion &&
+            (hasTrailingSpace ||
+                (rawParts.length > depth && depth > 0 && partial !== '')));
+        return {
+            hasTrailingSpace,
+            commandPathParts,
+            partial,
+            currentLevel,
+            leafCommand,
+            isArgumentCompletion,
+        };
+    }, [query, slashCommands]);
+}
+function useCommandSuggestions(query, parserResult, commandContext, getFzfForCommands, getPrefixSuggestions) {
+    const [suggestions, setSuggestions] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    useEffect(() => {
+        const abortController = new AbortController();
+        const { signal } = abortController;
+        const { isArgumentCompletion, leafCommand, commandPathParts, partial, currentLevel, } = parserResult;
+        if (isArgumentCompletion) {
+            const fetchAndSetSuggestions = async () => {
+                if (signal.aborted)
+                    return;
+                // Safety check: ensure leafCommand and completion exist
+                if (!leafCommand?.completion) {
+                    debugLogger.warn('Attempted argument completion without completion function');
+                    return;
+                }
+                const showLoading = leafCommand.showCompletionLoading !== false;
+                if (showLoading) {
+                    setIsLoading(true);
+                }
+                try {
+                    const rawParts = [...commandPathParts];
+                    if (partial)
+                        rawParts.push(partial);
+                    const depth = commandPathParts.length;
+                    const argString = rawParts.slice(depth).join(' ');
+                    const results = (await leafCommand.completion({
+                        ...commandContext,
+                        invocation: {
+                            raw: query || `/${rawParts.join(' ')}`,
+                            name: leafCommand.name,
+                            args: argString,
+                        },
+                    }, argString)) || [];
+                    if (!signal.aborted) {
+                        const finalSuggestions = results.map((s) => ({
+                            label: s,
+                            value: s,
+                        }));
+                        setSuggestions(finalSuggestions);
+                        setIsLoading(false);
+                    }
+                }
+                catch (error) {
+                    if (!signal.aborted) {
+                        logErrorSafely(error, 'Argument completion');
+                        setSuggestions([]);
+                        setIsLoading(false);
+                    }
+                }
+            };
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            fetchAndSetSuggestions();
+            return () => abortController.abort();
+        }
+        const commandsToSearch = currentLevel || [];
+        if (commandsToSearch.length > 0) {
+            const performFuzzySearch = async () => {
+                if (signal.aborted)
+                    return;
+                let potentialSuggestions = [];
+                if (partial === '') {
+                    // If no partial query, show all available commands
+                    potentialSuggestions = commandsToSearch.filter((cmd) => cmd.description && !cmd.hidden);
+                }
+                else {
+                    // Use fuzzy search for non-empty partial queries with fallback
+                    const fzfInstance = getFzfForCommands(commandsToSearch);
+                    if (fzfInstance) {
+                        try {
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                            const fzfResults = await fzfInstance.fzf.find(partial);
+                            if (signal.aborted)
+                                return;
+                            const uniqueCommands = new Set();
+                            fzfResults.forEach((result) => {
+                                const cmd = fzfInstance.commandMap.get(result.item);
+                                if (cmd && cmd.description) {
+                                    uniqueCommands.add(cmd);
+                                }
+                            });
+                            potentialSuggestions = Array.from(uniqueCommands);
+                        }
+                        catch (error) {
+                            logErrorSafely(error, 'Fuzzy search - falling back to prefix matching');
+                            // Fallback to prefix-based filtering
+                            potentialSuggestions = getPrefixSuggestions(commandsToSearch, partial);
+                        }
+                    }
+                    else {
+                        // Fallback to prefix-based filtering when fzf instance creation fails
+                        potentialSuggestions = getPrefixSuggestions(commandsToSearch, partial);
+                    }
+                }
+                if (!signal.aborted) {
+                    // Sort potentialSuggestions so that exact name/prefix match comes first,
+                    // prioritizing primary name over altNames.
+                    const lowerPartial = partial.toLowerCase();
+                    const sortedSuggestions = [...potentialSuggestions].sort((a, b) => {
+                        // 1. Exact name match
+                        const aNameExact = a.name.toLowerCase() === lowerPartial;
+                        const bNameExact = b.name.toLowerCase() === lowerPartial;
+                        if (aNameExact && !bNameExact)
+                            return -1;
+                        if (!aNameExact && bNameExact)
+                            return 1;
+                        // 2. Exact altName match
+                        const aAltExact = a.altNames?.some((alt) => alt.toLowerCase() === lowerPartial) ||
+                            false;
+                        const bAltExact = b.altNames?.some((alt) => alt.toLowerCase() === lowerPartial) ||
+                            false;
+                        if (aAltExact && !bAltExact)
+                            return -1;
+                        if (!aAltExact && bAltExact)
+                            return 1;
+                        // 3. Prefix name match
+                        const aNamePrefix = a.name.toLowerCase().startsWith(lowerPartial);
+                        const bNamePrefix = b.name.toLowerCase().startsWith(lowerPartial);
+                        if (aNamePrefix && !bNamePrefix)
+                            return -1;
+                        if (!aNamePrefix && bNamePrefix)
+                            return 1;
+                        // 4. Prefix altName match
+                        const aAltPrefix = a.altNames?.some((alt) => alt.toLowerCase().startsWith(lowerPartial)) || false;
+                        const bAltPrefix = b.altNames?.some((alt) => alt.toLowerCase().startsWith(lowerPartial)) || false;
+                        if (aAltPrefix && !bAltPrefix)
+                            return -1;
+                        if (!aAltPrefix && bAltPrefix)
+                            return 1;
+                        return 0; // Maintain FZF score order for other matches
+                    });
+                    const finalSuggestions = sortedSuggestions.map((cmd) => {
+                        const suggestion = {
+                            label: cmd.name,
+                            value: cmd.name,
+                            description: cmd.description,
+                            commandKind: cmd.kind,
+                        };
+                        if (cmd.suggestionGroup) {
+                            suggestion.sectionTitle = cmd.suggestionGroup;
+                        }
+                        return suggestion;
+                    });
+                    const isTopLevelChatOrResumeContext = !!(leafCommand &&
+                        (leafCommand.name === 'chat' || leafCommand.name === 'resume') &&
+                        (commandPathParts.length === 0 ||
+                            (commandPathParts.length === 1 &&
+                                matchesCommand(leafCommand, commandPathParts[0]))));
+                    if (isTopLevelChatOrResumeContext) {
+                        const canonicalParentName = leafCommand.name;
+                        const autoLabel = 'list';
+                        if (partial === '' ||
+                            autoLabel.toLowerCase().startsWith(partial.toLowerCase())) {
+                            const autoSectionSuggestion = {
+                                label: autoLabel,
+                                value: autoLabel,
+                                insertValue: canonicalParentName,
+                                description: 'Browse auto-saved chats',
+                                commandKind: CommandKind.BUILT_IN,
+                                sectionTitle: 'auto',
+                                submitValue: `/${canonicalParentName}`,
+                            };
+                            setSuggestions([autoSectionSuggestion, ...finalSuggestions]);
+                            return;
+                        }
+                    }
+                    setSuggestions(finalSuggestions);
+                }
+            };
+            performFuzzySearch().catch((error) => {
+                logErrorSafely(error, 'Unexpected fuzzy search error');
+                if (!signal.aborted) {
+                    // Ultimate fallback: show no suggestions rather than confusing the user
+                    // with all available commands when their query clearly doesn't match anything
+                    setSuggestions([]);
+                }
+            });
+            return () => abortController.abort();
+        }
+        setSuggestions([]);
+        return () => abortController.abort();
+    }, [
+        query,
+        parserResult,
+        commandContext,
+        getFzfForCommands,
+        getPrefixSuggestions,
+    ]);
+    return { suggestions, isLoading };
+}
+function useCompletionPositions(query, parserResult) {
+    return useMemo(() => {
+        if (!query) {
+            return { start: -1, end: -1 };
+        }
+        const { hasTrailingSpace, partial } = parserResult;
+        // Set completion start/end positions
+        if (hasTrailingSpace) {
+            return { start: query.length, end: query.length };
+        }
+        else if (partial) {
+            if (parserResult.isArgumentCompletion) {
+                const commandSoFar = `/${parserResult.commandPathParts.join(' ')}`;
+                const argStartIndex = commandSoFar.length +
+                    (parserResult.commandPathParts.length > 0 ? 1 : 0);
+                return { start: argStartIndex, end: query.length };
+            }
+            else {
+                return { start: query.length - partial.length, end: query.length };
+            }
+        }
+        else {
+            return { start: 1, end: query.length };
+        }
+    }, [query, parserResult]);
+}
+function usePerfectMatch(parserResult) {
+    return useMemo(() => {
+        const { hasTrailingSpace, partial, leafCommand, currentLevel } = parserResult;
+        if (hasTrailingSpace) {
+            return { isPerfectMatch: false };
+        }
+        if (leafCommand && partial === '' && leafCommand.action) {
+            return { isPerfectMatch: true };
+        }
+        if (currentLevel) {
+            const perfectMatch = currentLevel.find((cmd) => matchesCommand(cmd, partial) && cmd.action);
+            if (perfectMatch) {
+                return { isPerfectMatch: true };
+            }
+        }
+        return { isPerfectMatch: false };
+    }, [parserResult]);
+}
+/**
+ * Gets the SlashCommand object for a given suggestion by navigating the command hierarchy
+ * based on the current parser state.
+ * @param suggestion The suggestion object
+ * @param parserResult The current parser result with hierarchy information
+ * @returns The matching SlashCommand or undefined
+ */
+function getCommandFromSuggestion(suggestion, parserResult) {
+    const { currentLevel } = parserResult;
+    if (!currentLevel) {
+        return undefined;
+    }
+    // suggestion.value is just the command name at the current level (e.g., "list")
+    // Find it in the current level's commands
+    const command = currentLevel.find((cmd) => matchesCommand(cmd, suggestion.value));
+    return command;
+}
+export function useSlashCompletion(props) {
+    const { enabled, query, slashCommands, commandContext, setSuggestions, setIsLoadingSuggestions, setIsPerfectMatch, } = props;
+    const [completionStart, setCompletionStart] = useState(-1);
+    const [completionEnd, setCompletionEnd] = useState(-1);
+    // Simplified cache for AsyncFzf instances - WeakMap handles automatic cleanup
+    const fzfInstanceCache = useMemo(() => new WeakMap(), []);
+    // Helper function to create or retrieve cached AsyncFzf instance for a command level
+    const getFzfForCommands = useMemo(() => (commands) => {
+        if (!commands || commands.length === 0) {
+            return null;
+        }
+        // Check if we already have a cached instance
+        const cached = fzfInstanceCache.get(commands);
+        if (cached) {
+            return cached;
+        }
+        // Create new fzf instance
+        const commandItems = [];
+        const commandMap = new Map();
+        commands.forEach((cmd) => {
+            if (cmd.description && !cmd.hidden) {
+                commandItems.push(cmd.name);
+                commandMap.set(cmd.name, cmd);
+                if (cmd.altNames) {
+                    cmd.altNames.forEach((alt) => {
+                        commandItems.push(alt);
+                        commandMap.set(alt, cmd);
+                    });
+                }
+            }
+        });
+        if (commandItems.length === 0) {
+            return null;
+        }
+        try {
+            const instance = {
+                fzf: new AsyncFzf(commandItems, {
+                    fuzzy: 'v2',
+                    casing: 'case-insensitive', // Explicitly enforce case-insensitivity
+                }),
+                commandMap,
+            };
+            // Cache the instance - WeakMap will handle automatic cleanup
+            fzfInstanceCache.set(commands, instance);
+            return instance;
+        }
+        catch (error) {
+            logErrorSafely(error, 'FZF instance creation');
+            return null;
+        }
+    }, [fzfInstanceCache]);
+    // Memoized helper function for prefix-based filtering to improve performance
+    const getPrefixSuggestions = useMemo(() => (commands, partial) => commands.filter((cmd) => cmd.description &&
+        !cmd.hidden &&
+        (cmd.name.toLowerCase().startsWith(partial.toLowerCase()) ||
+            cmd.altNames?.some((alt) => alt.toLowerCase().startsWith(partial.toLowerCase())))), []);
+    // Use extracted hooks for better separation of concerns
+    const parserResult = useCommandParser(query, slashCommands);
+    const { suggestions: hookSuggestions, isLoading } = useCommandSuggestions(query, parserResult, commandContext, getFzfForCommands, getPrefixSuggestions);
+    const { start: calculatedStart, end: calculatedEnd } = useCompletionPositions(query, parserResult);
+    const { isPerfectMatch } = usePerfectMatch(parserResult);
+    // Clear internal state when disabled
+    useEffect(() => {
+        if (!enabled) {
+            setSuggestions([]);
+            setIsLoadingSuggestions(false);
+            setIsPerfectMatch(false);
+            setCompletionStart(-1);
+            setCompletionEnd(-1);
+        }
+    }, [enabled, setSuggestions, setIsLoadingSuggestions, setIsPerfectMatch]);
+    // Update external state only when enabled
+    useEffect(() => {
+        if (!enabled || query === null) {
+            return;
+        }
+        setSuggestions(hookSuggestions);
+        setIsLoadingSuggestions(isLoading);
+        setIsPerfectMatch(isPerfectMatch);
+        setCompletionStart(calculatedStart);
+        setCompletionEnd(calculatedEnd);
+    }, [
+        enabled,
+        query,
+        hookSuggestions,
+        isLoading,
+        isPerfectMatch,
+        calculatedStart,
+        calculatedEnd,
+        setSuggestions,
+        setIsLoadingSuggestions,
+        setIsPerfectMatch,
+    ]);
+    return {
+        completionStart,
+        completionEnd,
+        getCommandFromSuggestion: (suggestion) => getCommandFromSuggestion(suggestion, parserResult),
+        isArgumentCompletion: parserResult.isArgumentCompletion,
+        leafCommand: parserResult.leafCommand,
+    };
+}