@quantum-ai/gemini-cli 0.45.8 → 0.45.10

package/dist/ui/hooks/useInputHistoryStore.js

@@ -0,0 +1,81 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { debugLogger } from '@google/gemini-cli-core';
+import { useState, useCallback } from 'react';
+/**
+ * Hook for independently managing input history.
+ * Completely separated from chat history and unaffected by /clear commands.
+ */
+export function useInputHistoryStore() {
+    const [inputHistory, setInputHistory] = useState([]);
+    const [_pastSessionMessages, setPastSessionMessages] = useState([]);
+    const [_currentSessionMessages, setCurrentSessionMessages] = useState([]);
+    const [isInitialized, setIsInitialized] = useState(false);
+    /**
+     * Recalculate the complete input history from past and current sessions.
+     * Applies the same deduplication logic as the previous implementation.
+     */
+    const recalculateHistory = useCallback((currentSession, pastSession) => {
+        // Combine current session (newest first) + past session (newest first)
+        const combinedMessages = [...currentSession, ...pastSession];
+        // Deduplicate consecutive identical messages (same algorithm as before)
+        const deduplicatedMessages = [];
+        if (combinedMessages.length > 0) {
+            deduplicatedMessages.push(combinedMessages[0]); // Add the newest one unconditionally
+            for (let i = 1; i < combinedMessages.length; i++) {
+                if (combinedMessages[i] !== combinedMessages[i - 1]) {
+                    deduplicatedMessages.push(combinedMessages[i]);
+                }
+            }
+        }
+        // Reverse to oldest first for useInputHistory
+        setInputHistory(deduplicatedMessages.reverse());
+    }, []);
+    /**
+     * Initialize input history from logger with past session data.
+     * Executed only once at app startup.
+     */
+    const initializeFromLogger = useCallback(async (logger) => {
+        if (isInitialized || !logger)
+            return;
+        try {
+            const pastMessages = (await logger.getPreviousUserMessages()) || [];
+            setPastSessionMessages(pastMessages); // Store as newest first
+            recalculateHistory([], pastMessages);
+            setIsInitialized(true);
+        }
+        catch (error) {
+            // Start with empty history even if logger initialization fails
+            debugLogger.warn('Failed to initialize input history from logger:', error);
+            setPastSessionMessages([]);
+            recalculateHistory([], []);
+            setIsInitialized(true);
+        }
+    }, [isInitialized, recalculateHistory]);
+    /**
+     * Add new input to history.
+     * Recalculates the entire history with deduplication.
+     */
+    const addInput = useCallback((input) => {
+        const trimmedInput = input.trim();
+        if (!trimmedInput)
+            return; // Filter empty/whitespace-only inputs
+        setCurrentSessionMessages((prevCurrent) => {
+            const newCurrentSession = [...prevCurrent, trimmedInput];
+            setPastSessionMessages((prevPast) => {
+                recalculateHistory(newCurrentSession.slice().reverse(), // Convert to newest first
+                prevPast);
+                return prevPast; // No change to past messages
+            });
+            return newCurrentSession;
+        });
+    }, [recalculateHistory]);
+    return {
+        inputHistory,
+        addInput,
+        initializeFromLogger,
+    };
+}

package/dist/ui/hooks/useKeyMatchers.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+import { defaultKeyMatchers } from '../key/keyMatchers.js';
+export const KeyMatchersContext = createContext(defaultKeyMatchers);
+export const KeyMatchersProvider = ({ children, value, }) => (_jsx(KeyMatchersContext.Provider, { value: value, children: children }));
+/**
+ * Hook to retrieve the currently active key matchers.
+ * Defaults to defaultKeyMatchers if no provider is present, allowing tests to run without explicit wrappers.
+ */
+export function useKeyMatchers() {
+    return useContext(KeyMatchersContext);
+}

package/dist/ui/hooks/useKeypress.js

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useEffect } from 'react';
+import { useKeypressContext, } from '../contexts/KeypressContext.js';
+/**
+ * A hook that listens for keypress events from stdin.
+ *
+ * @param onKeypress - The callback function to execute on each keypress.
+ * @param options - Options to control the hook's behavior.
+ * @param options.isActive - Whether the hook should be actively listening for input.
+ * @param options.priority - Priority level (integer or KeypressPriority enum) or boolean for backward compatibility.
+ */
+export function useKeypress(onKeypress, { isActive, priority, }) {
+    const { subscribe, unsubscribe } = useKeypressContext();
+    useEffect(() => {
+        if (!isActive) {
+            return;
+        }
+        subscribe(onKeypress, priority);
+        return () => {
+            unsubscribe(onKeypress);
+        };
+    }, [isActive, onKeypress, subscribe, unsubscribe, priority]);
+}

package/dist/ui/hooks/useKittyKeyboardProtocol.js

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState } from 'react';
+import { terminalCapabilityManager } from '../utils/terminalCapabilityManager.js';
+/**
+ * Hook that returns the cached Kitty keyboard protocol status.
+ * Detection is done once at app startup to avoid repeated queries.
+ */
+export function useKittyKeyboardProtocol() {
+    const [status] = useState({
+        enabled: terminalCapabilityManager.isKittyProtocolEnabled(),
+        checking: false,
+    });
+    return status;
+}

package/dist/ui/hooks/useLoadingIndicator.js

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { StreamingState } from '../types.js';
+import { useTimer } from './useTimer.js';
+import { usePhraseCycler } from './usePhraseCycler.js';
+import { useState, useEffect, useRef } from 'react';
+import { getDisplayString, } from '@google/gemini-cli-core';
+const LOW_VERBOSITY_RETRY_HINT_ATTEMPT_THRESHOLD = 2;
+export const useLoadingIndicator = ({ streamingState, shouldShowFocusHint, retryStatus, showTips = true, showWit = false, customWittyPhrases, errorVerbosity = 'full', maxLength, }) => {
+    const [timerResetKey, setTimerResetKey] = useState(0);
+    const isTimerActive = streamingState === StreamingState.Responding;
+    const elapsedTimeFromTimer = useTimer(isTimerActive, timerResetKey);
+    const isPhraseCyclingActive = streamingState === StreamingState.Responding;
+    const isWaiting = streamingState === StreamingState.WaitingForConfirmation;
+    const { currentTip, currentWittyPhrase } = usePhraseCycler(isPhraseCyclingActive, isWaiting, shouldShowFocusHint, showTips, showWit, customWittyPhrases, maxLength);
+    const [retainedElapsedTime, setRetainedElapsedTime] = useState(0);
+    const prevStreamingStateRef = useRef(null);
+    useEffect(() => {
+        if (prevStreamingStateRef.current === StreamingState.WaitingForConfirmation &&
+            streamingState === StreamingState.Responding) {
+            setTimerResetKey((prevKey) => prevKey + 1);
+            setRetainedElapsedTime(0); // Clear retained time when going back to responding
+        }
+        else if (streamingState === StreamingState.Idle &&
+            prevStreamingStateRef.current === StreamingState.Responding) {
+            setTimerResetKey((prevKey) => prevKey + 1); // Reset timer when becoming idle from responding
+            setRetainedElapsedTime(0);
+        }
+        else if (streamingState === StreamingState.WaitingForConfirmation) {
+            // Capture the time when entering WaitingForConfirmation
+            // elapsedTimeFromTimer will hold the last value from when isTimerActive was true.
+            setRetainedElapsedTime(elapsedTimeFromTimer);
+        }
+        prevStreamingStateRef.current = streamingState;
+    }, [streamingState, elapsedTimeFromTimer]);
+    const retryPhrase = streamingState === StreamingState.Responding && retryStatus
+        ? errorVerbosity === 'low'
+            ? retryStatus.attempt >= LOW_VERBOSITY_RETRY_HINT_ATTEMPT_THRESHOLD
+                ? "This is taking a bit longer, we're still on it."
+                : null
+            : `Trying to reach ${getDisplayString(retryStatus.model)} (Attempt ${retryStatus.attempt + 1}/${retryStatus.maxAttempts})`
+        : null;
+    return {
+        elapsedTime: streamingState === StreamingState.WaitingForConfirmation
+            ? retainedElapsedTime
+            : elapsedTimeFromTimer,
+        currentLoadingPhrase: retryPhrase || currentTip || currentWittyPhrase,
+        currentTip,
+        currentWittyPhrase,
+    };
+};

package/dist/ui/hooks/useLogger.js

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useEffect } from 'react';
+import { Logger } from '@google/gemini-cli-core';
+/**
+ * Hook to manage the logger instance.
+ */
+export const useLogger = (config) => {
+    const [logger, setLogger] = useState(null);
+    useEffect(() => {
+        const newLogger = new Logger(config.getSessionId(), config.storage);
+        /**
+         * Start async initialization, no need to await. Using await slows down the
+         * time from launch to see the gemini-cli prompt and it's better to not save
+         * messages than for the cli to hanging waiting for the logger to loading.
+         */
+        newLogger
+            .initialize()
+            .then(() => setLogger(newLogger))
+            .catch(() => { });
+    }, [config]);
+    return logger;
+};

package/dist/ui/hooks/useMcpStatus.js

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useEffect, useState } from 'react';
+import { coreEvents, MCPDiscoveryState, CoreEvent, } from '@google/gemini-cli-core';
+export function useMcpStatus(config) {
+    const [discoveryState, setDiscoveryState] = useState(() => config.getMcpClientManager()?.getDiscoveryState() ??
+        MCPDiscoveryState.NOT_STARTED);
+    const [mcpServerCount, setMcpServerCount] = useState(() => config.getMcpClientManager()?.getMcpServerCount() ?? 0);
+    useEffect(() => {
+        const onChange = () => {
+            const manager = config.getMcpClientManager();
+            if (manager) {
+                setDiscoveryState(manager.getDiscoveryState());
+                setMcpServerCount(manager.getMcpServerCount());
+            }
+        };
+        coreEvents.on(CoreEvent.McpClientUpdate, onChange);
+        return () => {
+            coreEvents.off(CoreEvent.McpClientUpdate, onChange);
+        };
+    }, [config]);
+    // We are ready if discovery has completed, OR if it hasn't even started and there are no servers.
+    const isMcpReady = discoveryState === MCPDiscoveryState.COMPLETED ||
+        (discoveryState === MCPDiscoveryState.NOT_STARTED && mcpServerCount === 0);
+    return {
+        discoveryState,
+        mcpServerCount,
+        isMcpReady,
+    };
+}

package/dist/ui/hooks/useMemoryMonitor.js

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useEffect } from 'react';
+import process from 'node:process';
+import { MessageType } from '../types.js';
+export const MEMORY_WARNING_THRESHOLD = 7 * 1024 * 1024 * 1024; // 7GB in bytes
+export const MEMORY_CHECK_INTERVAL = 60 * 1000; // one minute
+export const useMemoryMonitor = ({ addItem }) => {
+    useEffect(() => {
+        const intervalId = setInterval(() => {
+            const usage = process.memoryUsage().rss;
+            if (usage > MEMORY_WARNING_THRESHOLD) {
+                addItem({
+                    type: MessageType.WARNING,
+                    text: `High memory usage detected: ${(usage /
+                        (1024 * 1024 * 1024)).toFixed(2)} GB. ` +
+                        'If you experience a crash, please file a bug report by running `/bug`',
+                }, Date.now());
+                clearInterval(intervalId);
+            }
+        }, MEMORY_CHECK_INTERVAL);
+        return () => clearInterval(intervalId);
+    }, [addItem]);
+};

package/dist/ui/hooks/useMessageQueue.js

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useCallback, useEffect, useState } from 'react';
+import { StreamingState } from '../types.js';
+/**
+ * Hook for managing message queuing during streaming responses.
+ * Allows users to queue messages while the AI is responding and automatically
+ * sends them when streaming completes.
+ */
+export function useMessageQueue({ isConfigInitialized, streamingState, submitQuery, isMcpReady, isCompressing = false, }) {
+    const [messageQueue, setMessageQueue] = useState([]);
+    // Add a message to the queue
+    const addMessage = useCallback((message) => {
+        const trimmedMessage = message.trim();
+        if (trimmedMessage.length > 0) {
+            setMessageQueue((prev) => [...prev, trimmedMessage]);
+        }
+    }, []);
+    // Clear the entire queue
+    const clearQueue = useCallback(() => {
+        setMessageQueue([]);
+    }, []);
+    // Get all queued messages as a single text string
+    const getQueuedMessagesText = useCallback(() => {
+        if (messageQueue.length === 0)
+            return '';
+        return messageQueue.join('\n\n');
+    }, [messageQueue]);
+    // Pop all messages from the queue and return them as a single string
+    const popAllMessages = useCallback(() => {
+        if (messageQueue.length === 0) {
+            return undefined;
+        }
+        const allMessages = messageQueue.join('\n\n');
+        setMessageQueue([]);
+        return allMessages;
+    }, [messageQueue]);
+    // Process queued messages when streaming becomes idle
+    useEffect(() => {
+        if (isConfigInitialized &&
+            streamingState === StreamingState.Idle &&
+            !isCompressing &&
+            isMcpReady &&
+            messageQueue.length > 0) {
+            // Combine all messages with double newlines for clarity
+            const combinedMessage = messageQueue.join('\n\n');
+            // Clear the queue and submit
+            setMessageQueue([]);
+            submitQuery(combinedMessage);
+        }
+    }, [
+        isConfigInitialized,
+        streamingState,
+        isMcpReady,
+        messageQueue,
+        submitQuery,
+        isCompressing,
+    ]);
+    return {
+        messageQueue,
+        addMessage,
+        clearQueue,
+        getQueuedMessagesText,
+        popAllMessages,
+    };
+}

package/dist/ui/hooks/useModelCommand.js

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useCallback } from 'react';
+export const useModelCommand = () => {
+    const [isModelDialogOpen, setIsModelDialogOpen] = useState(false);
+    const openModelDialog = useCallback(() => {
+        setIsModelDialogOpen(true);
+    }, []);
+    const closeModelDialog = useCallback(() => {
+        setIsModelDialogOpen(false);
+    }, []);
+    return {
+        isModelDialogOpen,
+        openModelDialog,
+        closeModelDialog,
+    };
+};

package/dist/ui/hooks/useMouse.js

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useEffect } from 'react';
+import { useMouseContext, } from '../contexts/MouseContext.js';
+/**
+ * A hook that listens for mouse events from stdin.
+ *
+ * @param onMouseEvent - The callback function to execute on each mouse event.
+ * @param options - Options to control the hook's behavior.
+ * @param options.isActive - Whether the hook should be actively listening for input.
+ */
+export function useMouse(onMouseEvent, { isActive }) {
+    const { subscribe, unsubscribe } = useMouseContext();
+    useEffect(() => {
+        if (!isActive) {
+            return;
+        }
+        subscribe(onMouseEvent);
+        return () => {
+            unsubscribe(onMouseEvent);
+        };
+    }, [isActive, onMouseEvent, subscribe, unsubscribe]);
+}

package/dist/ui/hooks/useMouseClick.js

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { measureElement } from 'ink';
+;
+import { useCallback, useRef } from 'react';
+import { useMouse, } from '../contexts/MouseContext.js';
+export const useMouseClick = (containerRef, handler, options = {}) => {
+    const { isActive = true, button = 'left', name } = options;
+    const handlerRef = useRef(handler);
+    handlerRef.current = handler;
+    const onMouse = useCallback((event) => {
+        const eventName = name ?? (button === 'left' ? 'left-press' : 'right-release');
+        if (event.name === eventName && containerRef.current) {
+            const node = containerRef.current;
+            const { width, height } = measureElement(node);
+            const x = node.yogaNode?.getComputedLeft() ?? 0;
+            const y = node.yogaNode?.getComputedTop() ?? 0;
+            // Terminal mouse events are 1-based, Ink layout is 0-based.
+            const mouseX = event.col - 1;
+            const mouseY = event.row - 1;
+            const relativeX = mouseX - x;
+            const relativeY = mouseY - y;
+            if (relativeX >= 0 &&
+                relativeX < width &&
+                relativeY >= 0 &&
+                relativeY < height) {
+                handlerRef.current(event, relativeX, relativeY);
+            }
+        }
+    }, [containerRef, button, name]);
+    useMouse(onMouse, { isActive });
+};

package/dist/ui/hooks/usePermissionsModifyTrust.js

@@ -0,0 +1,113 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useCallback } from 'react';
+import * as process from 'node:process';
+import * as path from 'node:path';
+import { loadTrustedFolders, TrustLevel, isWorkspaceTrusted, } from '../../config/trustedFolders.js';
+import { useSettings } from '../contexts/SettingsContext.js';
+import { MessageType } from '../types.js';
+import { coreEvents } from '@google/gemini-cli-core';
+function getInitialTrustState(settings, cwd, isCurrentWorkspace) {
+    const folders = loadTrustedFolders();
+    const explicitTrustLevel = folders.user.config[cwd];
+    if (!isCurrentWorkspace) {
+        return {
+            currentTrustLevel: explicitTrustLevel,
+            isInheritedTrustFromParent: false,
+            isInheritedTrustFromIde: false,
+        };
+    }
+    const { isTrusted, source } = isWorkspaceTrusted(settings.merged, process.cwd());
+    const isInheritedTrust = isTrusted &&
+        (!explicitTrustLevel || explicitTrustLevel === TrustLevel.DO_NOT_TRUST);
+    return {
+        currentTrustLevel: explicitTrustLevel,
+        isInheritedTrustFromParent: !!(source === 'file' && isInheritedTrust),
+        isInheritedTrustFromIde: !!(source === 'ide' && isInheritedTrust),
+    };
+}
+export const usePermissionsModifyTrust = (onExit, addItem, targetDirectory) => {
+    const settings = useSettings();
+    const cwd = targetDirectory;
+    // Normalize paths for case-insensitive file systems (macOS/Windows) to ensure
+    // accurate comparison between targetDirectory and process.cwd().
+    const isCurrentWorkspace = path.resolve(targetDirectory).toLowerCase() ===
+        path.resolve(process.cwd()).toLowerCase();
+    const [initialState] = useState(() => getInitialTrustState(settings, cwd, isCurrentWorkspace));
+    const [currentTrustLevel] = useState(initialState.currentTrustLevel);
+    const [pendingTrustLevel, setPendingTrustLevel] = useState();
+    const [isInheritedTrustFromParent] = useState(initialState.isInheritedTrustFromParent);
+    const [isInheritedTrustFromIde] = useState(initialState.isInheritedTrustFromIde);
+    const [needsRestart, setNeedsRestart] = useState(false);
+    const isFolderTrustEnabled = settings.merged.security.folderTrust.enabled ?? true;
+    const updateTrustLevel = useCallback(async (trustLevel) => {
+        // If we are not editing the current workspace, the logic is simple:
+        // just save the setting and exit. No restart or warnings are needed.
+        if (!isCurrentWorkspace) {
+            const folders = loadTrustedFolders();
+            await folders.setValue(cwd, trustLevel);
+            onExit();
+            return;
+        }
+        // All logic below only applies when editing the current workspace.
+        const wasTrusted = isWorkspaceTrusted(settings.merged, process.cwd()).isTrusted;
+        // Create a temporary config to check the new trust status without writing
+        const currentConfig = loadTrustedFolders().user.config;
+        const newConfig = { ...currentConfig, [cwd]: trustLevel };
+        const { isTrusted, source } = isWorkspaceTrusted(settings.merged, process.cwd(), newConfig);
+        if (trustLevel === TrustLevel.DO_NOT_TRUST && isTrusted) {
+            let message = 'Note: This folder is still trusted because the connected IDE workspace is trusted.';
+            if (source === 'file') {
+                message =
+                    'Note: This folder is still trusted because a parent folder is trusted.';
+            }
+            addItem({
+                type: MessageType.WARNING,
+                text: message,
+            }, Date.now());
+        }
+        if (wasTrusted !== isTrusted) {
+            setPendingTrustLevel(trustLevel);
+            setNeedsRestart(true);
+        }
+        else {
+            const folders = loadTrustedFolders();
+            try {
+                await folders.setValue(cwd, trustLevel);
+            }
+            catch {
+                coreEvents.emitFeedback('error', 'Failed to save trust settings. Your changes may not persist.');
+            }
+            onExit();
+        }
+    }, [cwd, settings.merged, onExit, addItem, isCurrentWorkspace]);
+    const commitTrustLevelChange = useCallback(async () => {
+        if (pendingTrustLevel) {
+            const folders = loadTrustedFolders();
+            try {
+                await folders.setValue(cwd, pendingTrustLevel);
+                return true;
+            }
+            catch {
+                coreEvents.emitFeedback('error', 'Failed to save trust settings. Your changes may not persist.');
+                setNeedsRestart(false);
+                setPendingTrustLevel(undefined);
+                return false;
+            }
+        }
+        return true;
+    }, [cwd, pendingTrustLevel]);
+    return {
+        cwd,
+        currentTrustLevel,
+        isInheritedTrustFromParent,
+        isInheritedTrustFromIde,
+        needsRestart,
+        updateTrustLevel,
+        commitTrustLevelChange,
+        isFolderTrustEnabled,
+    };
+};