@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/ui/components/SettingsDialog.js

@@ -0,0 +1,283 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useMemo, useCallback, useEffect } from 'react';
+import { Text } from 'ink';
+;
+import { AsyncFzf } from 'fzf';
+import { theme } from '../semantic-colors.js';
+import { SettingScope, } from '../../config/settings.js';
+import { getScopeItems, getScopeMessageForSetting, } from '../../utils/dialogScopeUtils.js';
+import { getDialogSettingKeys, getDisplayValue, getSettingDefinition, getDialogRestartRequiredSettings, getEffectiveValue, isInSettingsScope, getEditValue, parseEditedValue, } from '../../utils/settingsUtils.js';
+import { useSettingsStore, } from '../contexts/SettingsContext.js';
+import { getCachedStringWidth } from '../utils/textUtils.js';
+import { TOGGLE_TYPES, } from '../../config/settingsSchema.js';
+import { debugLogger } from '@google/gemini-cli-core';
+import { useSearchBuffer } from '../hooks/useSearchBuffer.js';
+import { BaseSettingsDialog, } from './shared/BaseSettingsDialog.js';
+import { useKeyMatchers } from '../hooks/useKeyMatchers.js';
+import { Command, KeyBinding } from '../key/keyBindings.js';
+const MAX_ITEMS_TO_SHOW = 8;
+const KEY_UP = new KeyBinding('up');
+const KEY_CTRL_P = new KeyBinding('ctrl+p');
+const KEY_DOWN = new KeyBinding('down');
+const KEY_CTRL_N = new KeyBinding('ctrl+n');
+// Create a snapshot of the initial per-scope state of Restart Required Settings
+// This creates a nested map of the form
+// restartRequiredSetting -> Map { scopeName -> value }
+function getActiveRestartRequiredSettings(settings) {
+    const snapshot = new Map();
+    const scopes = [
+        ['User', settings.user.settings],
+        ['Workspace', settings.workspace.settings],
+        ['System', settings.system.settings],
+    ];
+    for (const key of getDialogRestartRequiredSettings()) {
+        const scopeMap = new Map();
+        for (const [scopeName, scopeSettings] of scopes) {
+            // Raw per-scope value (undefined if not in file)
+            const value = isInSettingsScope(key, scopeSettings)
+                ? getEffectiveValue(key, scopeSettings)
+                : undefined;
+            scopeMap.set(scopeName, JSON.stringify(value));
+        }
+        snapshot.set(key, scopeMap);
+    }
+    return snapshot;
+}
+export function SettingsDialog({ onSelect, onRestartRequest, availableTerminalHeight, }) {
+    // Reactive settings from store (re-renders on any settings change)
+    const { settings, setSetting } = useSettingsStore();
+    const [selectedScope, setSelectedScope] = useState(SettingScope.User);
+    const editableScopeItems = useMemo(() => getScopeItems().filter((item) => {
+        const settingsFile = settings.forScope(item.value);
+        return (settingsFile.readOnly !== true &&
+            (item.value !== SettingScope.Workspace ||
+                settingsFile.path !== undefined));
+    }), [settings]);
+    const writableSelectedScope = editableScopeItems.find((item) => item.value === selectedScope)?.value ??
+        editableScopeItems[0]?.value;
+    const effectiveSelectedScope = writableSelectedScope ?? SettingScope.User;
+    if (writableSelectedScope && selectedScope !== writableSelectedScope) {
+        setSelectedScope(writableSelectedScope);
+    }
+    // Snapshot restart-required values at mount time for diff tracking
+    const [activeRestartRequiredSettings] = useState(() => getActiveRestartRequiredSettings(settings));
+    // Search state
+    const [searchQuery, setSearchQuery] = useState('');
+    const [filteredKeys, setFilteredKeys] = useState(() => getDialogSettingKeys());
+    const { fzfInstance, searchMap } = useMemo(() => {
+        const keys = getDialogSettingKeys();
+        const map = new Map();
+        const searchItems = [];
+        keys.forEach((key) => {
+            const def = getSettingDefinition(key);
+            if (def?.label) {
+                searchItems.push(def.label);
+                map.set(def.label.toLowerCase(), key);
+            }
+        });
+        const fzf = new AsyncFzf(searchItems, {
+            fuzzy: 'v2',
+            casing: 'case-insensitive',
+        });
+        return { fzfInstance: fzf, searchMap: map };
+    }, []);
+    // Perform search
+    useEffect(() => {
+        let active = true;
+        if (!searchQuery.trim() || !fzfInstance) {
+            setFilteredKeys(getDialogSettingKeys());
+            return;
+        }
+        const doSearch = async () => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            const results = await fzfInstance.find(searchQuery);
+            if (!active)
+                return;
+            const matchedKeys = new Set();
+            results.forEach((res) => {
+                const key = searchMap.get(res.item.toLowerCase());
+                if (key)
+                    matchedKeys.add(key);
+            });
+            setFilteredKeys(Array.from(matchedKeys));
+        };
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        doSearch();
+        return () => {
+            active = false;
+        };
+    }, [searchQuery, fzfInstance, searchMap]);
+    // Track whether a restart is required to apply the changes in the Settings json file
+    // This does not care for inheritance
+    // It checks whether a proposed change from this UI to a settings.json file requires a restart to take effect in the app
+    const pendingRestartRequiredSettings = useMemo(() => {
+        const changed = new Set();
+        const scopes = [
+            ['User', settings.user.settings],
+            ['Workspace', settings.workspace.settings],
+            ['System', settings.system.settings],
+        ];
+        // Iterate through the nested map snapshot in activeRestartRequiredSettings, diff with current settings
+        for (const [key, initialScopeMap] of activeRestartRequiredSettings) {
+            for (const [scopeName, scopeSettings] of scopes) {
+                const currentValue = isInSettingsScope(key, scopeSettings)
+                    ? getEffectiveValue(key, scopeSettings)
+                    : undefined;
+                const initialJson = initialScopeMap.get(scopeName);
+                if (JSON.stringify(currentValue) !== initialJson) {
+                    changed.add(key);
+                    break; // one scope changed is enough
+                }
+            }
+        }
+        return changed;
+    }, [settings, activeRestartRequiredSettings]);
+    const showRestartPrompt = pendingRestartRequiredSettings.size > 0;
+    // Calculate max width for the left column (Label/Description) to keep values aligned or close
+    const maxLabelOrDescriptionWidth = useMemo(() => {
+        const allKeys = getDialogSettingKeys();
+        let max = 0;
+        for (const key of allKeys) {
+            const def = getSettingDefinition(key);
+            if (!def)
+                continue;
+            const scopeMessage = getScopeMessageForSetting(key, effectiveSelectedScope, settings);
+            const label = def.label || key;
+            const labelFull = label + (scopeMessage ? ` ${scopeMessage}` : '');
+            const lWidth = getCachedStringWidth(labelFull);
+            const dWidth = def.description
+                ? getCachedStringWidth(def.description)
+                : 0;
+            max = Math.max(max, lWidth, dWidth);
+        }
+        return max;
+    }, [effectiveSelectedScope, settings]);
+    // Search input buffer
+    const searchBuffer = useSearchBuffer({
+        initialText: '',
+        onChange: setSearchQuery,
+    });
+    // Generate items for BaseSettingsDialog
+    const settingKeys = searchQuery ? filteredKeys : getDialogSettingKeys();
+    const items = useMemo(() => {
+        const scopeSettings = settings.forScope(effectiveSelectedScope).settings;
+        const mergedSettings = settings.merged;
+        return settingKeys.map((key) => {
+            const definition = getSettingDefinition(key);
+            const type = definition?.type ?? 'string';
+            // Get the display value (with * indicator if modified)
+            const displayValue = getDisplayValue(key, scopeSettings, mergedSettings);
+            // Get the scope message (e.g., "(Modified in Workspace)")
+            const scopeMessage = getScopeMessageForSetting(key, effectiveSelectedScope, settings);
+            // Grey out values that defer to defaults
+            const isGreyedOut = !isInSettingsScope(key, scopeSettings);
+            // Some settings can be edited by an inline editor
+            const rawValue = getEffectiveValue(key, scopeSettings);
+            // The inline editor needs a string but non primitive settings like Arrays and Objects exist
+            const editValue = getEditValue(type, rawValue);
+            return {
+                key,
+                label: definition?.label || key,
+                description: definition?.description,
+                type,
+                displayValue,
+                isGreyedOut,
+                scopeMessage,
+                rawValue,
+                editValue,
+            };
+        });
+    }, [settingKeys, effectiveSelectedScope, settings]);
+    const handleScopeChange = useCallback((scope) => {
+        setSelectedScope(scope);
+    }, []);
+    // Toggle handler for boolean/enum settings
+    const handleItemToggle = useCallback((key, _item) => {
+        if (!writableSelectedScope) {
+            return;
+        }
+        const definition = getSettingDefinition(key);
+        if (!TOGGLE_TYPES.has(definition?.type)) {
+            return;
+        }
+        const scopeSettings = settings.forScope(writableSelectedScope).settings;
+        const currentValue = getEffectiveValue(key, scopeSettings);
+        let newValue;
+        if (definition?.type === 'boolean') {
+            if (typeof currentValue !== 'boolean') {
+                return;
+            }
+            newValue = !currentValue;
+        }
+        else if (definition?.type === 'enum' && definition.options) {
+            const options = definition.options;
+            if (options.length === 0) {
+                return;
+            }
+            const currentIndex = options?.findIndex((opt) => opt.value === currentValue);
+            if (currentIndex !== -1 && currentIndex < options.length - 1) {
+                newValue = options[currentIndex + 1].value;
+            }
+            else {
+                newValue = options[0].value; // loop back to start.
+            }
+        }
+        else {
+            return;
+        }
+        debugLogger.log(`[DEBUG SettingsDialog] Saving ${key} immediately with value:`, newValue);
+        setSetting(writableSelectedScope, key, newValue);
+    }, [settings, writableSelectedScope, setSetting]);
+    // For inline editor
+    const handleEditCommit = useCallback((key, newValue, _item) => {
+        if (!writableSelectedScope) {
+            return;
+        }
+        const definition = getSettingDefinition(key);
+        const type = definition?.type ?? 'string';
+        const parsed = parseEditedValue(type, newValue);
+        if (parsed === null) {
+            return;
+        }
+        setSetting(writableSelectedScope, key, parsed);
+    }, [writableSelectedScope, setSetting]);
+    // Clear/reset handler - removes the value from settings.json so it falls back to default
+    const handleItemClear = useCallback((key, _item) => {
+        if (!writableSelectedScope) {
+            return;
+        }
+        setSetting(writableSelectedScope, key, undefined);
+    }, [writableSelectedScope, setSetting]);
+    const handleClose = useCallback(() => {
+        onSelect(undefined, effectiveSelectedScope);
+    }, [onSelect, effectiveSelectedScope]);
+    const globalKeyMatchers = useKeyMatchers();
+    const settingsKeyMatchers = useMemo(() => ({
+        ...globalKeyMatchers,
+        [Command.DIALOG_NAVIGATION_UP]: (key) => KEY_UP.matches(key) || KEY_CTRL_P.matches(key),
+        [Command.DIALOG_NAVIGATION_DOWN]: (key) => KEY_DOWN.matches(key) || KEY_CTRL_N.matches(key),
+    }), [globalKeyMatchers]);
+    // Custom key handler for restart key
+    const handleKeyPress = useCallback((key, _currentItem) => {
+        // 'r' key for restart
+        if (showRestartPrompt && key.sequence === 'r') {
+            if (onRestartRequest)
+                onRestartRequest();
+            return true;
+        }
+        return false;
+    }, [showRestartPrompt, onRestartRequest]);
+    // Decisions on what features to enable
+    const showSearch = !showRestartPrompt;
+    return (_jsx(BaseSettingsDialog, { title: "Settings", borderColor: showRestartPrompt ? theme.status.warning : undefined, searchEnabled: showSearch, searchBuffer: searchBuffer, items: items, showScopeSelector: editableScopeItems.length > 1, scopeItems: editableScopeItems, selectedScope: effectiveSelectedScope, onScopeChange: handleScopeChange, maxItemsToShow: MAX_ITEMS_TO_SHOW, availableHeight: availableTerminalHeight, maxLabelWidth: maxLabelOrDescriptionWidth, onItemToggle: handleItemToggle, onEditCommit: handleEditCommit, onItemClear: handleItemClear, onClose: handleClose, onKeyPress: handleKeyPress, keyMatchers: settingsKeyMatchers, footer: showRestartPrompt
+            ? {
+                content: (_jsx(Text, { color: theme.status.warning, children: "Changes that require a restart have been modified. Press r to exit and apply changes now." })),
+                height: 1,
+            }
+            : undefined }));
+}

package/dist/ui/components/ShellInputPrompt.js

@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useCallback } from 'react';
+import { useKeypress } from '../hooks/useKeypress.js';
+import { ShellExecutionService } from '@google/gemini-cli-core';
+import { keyToAnsi } from '../key/keyToAnsi.js';
+import { ACTIVE_SHELL_MAX_LINES } from '../constants.js';
+import { Command } from '../key/keyMatchers.js';
+import { useKeyMatchers } from '../hooks/useKeyMatchers.js';
+export const ShellInputPrompt = ({ activeShellPtyId, focus = true, scrollPageSize = ACTIVE_SHELL_MAX_LINES, }) => {
+    const keyMatchers = useKeyMatchers();
+    const handleShellInputSubmit = useCallback((input) => {
+        if (activeShellPtyId) {
+            ShellExecutionService.writeToPty(activeShellPtyId, input);
+        }
+    }, [activeShellPtyId]);
+    const handleInput = useCallback((key) => {
+        if (!focus || !activeShellPtyId) {
+            return false;
+        }
+        // Allow background shell toggle to bubble up
+        if (keyMatchers[Command.TOGGLE_BACKGROUND_SHELL](key)) {
+            return false;
+        }
+        // Allow Shift+Tab to bubble up for focus navigation
+        if (keyMatchers[Command.UNFOCUS_SHELL_INPUT](key)) {
+            return false;
+        }
+        if (keyMatchers[Command.SCROLL_UP](key)) {
+            ShellExecutionService.scrollPty(activeShellPtyId, -1);
+            return true;
+        }
+        if (keyMatchers[Command.SCROLL_DOWN](key)) {
+            ShellExecutionService.scrollPty(activeShellPtyId, 1);
+            return true;
+        }
+        // TODO: Check pty service actually scrolls (request)[https://github.com/google-gemini/gemini-cli/pull/17438/changes/c9fdaf8967da0036bfef43592fcab5a69537df35#r2776479023].
+        if (keyMatchers[Command.PAGE_UP](key)) {
+            ShellExecutionService.scrollPty(activeShellPtyId, -scrollPageSize);
+            return true;
+        }
+        if (keyMatchers[Command.PAGE_DOWN](key)) {
+            ShellExecutionService.scrollPty(activeShellPtyId, scrollPageSize);
+            return true;
+        }
+        const ansiSequence = keyToAnsi(key);
+        if (ansiSequence) {
+            handleShellInputSubmit(ansiSequence);
+            return true;
+        }
+        return false;
+    }, [
+        focus,
+        handleShellInputSubmit,
+        activeShellPtyId,
+        scrollPageSize,
+        keyMatchers,
+    ]);
+    useKeypress(handleInput, { isActive: focus });
+    return null;
+};

package/dist/ui/components/ShellModeIndicator.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+export const ShellModeIndicator = () => (_jsx(Box, { children: _jsxs(Text, { color: theme.ui.symbol, children: ["shell mode enabled", _jsx(Text, { color: theme.text.secondary, children: " (esc to disable)" })] }) }));

package/dist/ui/components/ShortcutsHelp.js

@@ -0,0 +1,58 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { isNarrowWidth } from '../utils/isNarrowWidth.js';
+import { SectionHeader } from './shared/SectionHeader.js';
+import { useUIState } from '../contexts/UIStateContext.js';
+import { Command } from '../key/keyBindings.js';
+import { formatCommand } from '../key/keybindingUtils.js';
+const buildShortcutItems = () => [
+    { key: '!', description: 'shell mode' },
+    { key: '@', description: 'select file or folder' },
+    { key: 'Double Esc', description: 'clear & rewind' },
+    { key: formatCommand(Command.FOCUS_SHELL_INPUT), description: 'focus UI' },
+    { key: formatCommand(Command.TOGGLE_YOLO), description: 'YOLO mode' },
+    {
+        key: formatCommand(Command.CYCLE_APPROVAL_MODE),
+        description: 'cycle mode',
+    },
+    {
+        key: formatCommand(Command.PASTE_CLIPBOARD),
+        description: 'paste images',
+    },
+    {
+        key: formatCommand(Command.TOGGLE_MARKDOWN),
+        description: 'raw markdown mode',
+    },
+    {
+        key: formatCommand(Command.REVERSE_SEARCH),
+        description: 'reverse-search history',
+    },
+    {
+        key: formatCommand(Command.OPEN_EXTERNAL_EDITOR),
+        description: 'open external editor',
+    },
+];
+const Shortcut = ({ item }) => (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { flexShrink: 0, marginRight: 1, children: _jsx(Text, { color: theme.text.accent, children: item.key }) }), _jsx(Box, { flexGrow: 1, children: _jsx(Text, { color: theme.text.primary, children: item.description }) })] }));
+export const ShortcutsHelp = () => {
+    const { terminalWidth } = useUIState();
+    const isNarrow = isNarrowWidth(terminalWidth);
+    const items = buildShortcutItems();
+    const itemsForDisplay = isNarrow
+        ? items
+        : [
+            // Keep first column stable: !, @, Esc Esc, Tab Tab.
+            items[0],
+            items[5],
+            items[6],
+            items[1],
+            items[4],
+            items[7],
+            items[2],
+            items[8],
+            items[9],
+            items[3],
+        ];
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", children: [_jsx(SectionHeader, { title: " Shortcuts", subtitle: " See /help for more" }), _jsx(Box, { flexDirection: "row", flexWrap: "wrap", paddingLeft: 1, paddingRight: 2, children: itemsForDisplay.map((item, index) => (_jsx(Box, { width: isNarrow ? '100%' : '33%', paddingRight: isNarrow ? 0 : 2, children: _jsx(Shortcut, { item: item }) }, `${item.key}-${index}`))) })] }));
+};

package/dist/ui/components/ShowMoreLines.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Box, Text } from 'ink';
+;
+import { useOverflowState } from '../contexts/OverflowContext.js';
+import { useStreamingContext } from '../contexts/StreamingContext.js';
+import { StreamingState } from '../types.js';
+import { theme } from '../semantic-colors.js';
+export const ShowMoreLines = ({ constrainHeight, isOverflowing: isOverflowingProp, }) => {
+    const overflowState = useOverflowState();
+    const streamingState = useStreamingContext();
+    const isOverflowing = isOverflowingProp ??
+        (overflowState !== undefined && overflowState.overflowingIds.size > 0);
+    if (!isOverflowing ||
+        !constrainHeight ||
+        !(streamingState === StreamingState.Idle ||
+            streamingState === StreamingState.WaitingForConfirmation ||
+            streamingState === StreamingState.Responding)) {
+        return null;
+    }
+    return (_jsx(Box, { paddingX: 1, marginBottom: 1, children: _jsx(Text, { color: theme.text.accent, wrap: "truncate", children: "Press Ctrl+O to show more lines" }) }));
+};

package/dist/ui/components/StatsDisplay.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+;
+import { ThemedGradient } from './ThemedGradient.js';
+import { theme } from '../semantic-colors.js';
+import { formatDuration } from '../utils/formatters.js';
+import { useSessionStats, } from '../contexts/SessionContext.js';
+import { getStatusColor, TOOL_SUCCESS_RATE_HIGH, TOOL_SUCCESS_RATE_MEDIUM, USER_AGREEMENT_RATE_HIGH, USER_AGREEMENT_RATE_MEDIUM, } from '../utils/displayUtils.js';
+import { computeSessionStats } from '../utils/computeStats.js';
+import { useSettings } from '../contexts/SettingsContext.js';
+import { LlmRole, getDisplayString } from '@google/gemini-cli-core';
+const StatRow = ({ title, children }) => (_jsxs(Box, { children: [_jsx(Box, { width: 28, children: _jsx(Text, { color: theme.text.link, children: title }) }), children] }));
+const SubStatRow = ({ title, children }) => (_jsxs(Box, { paddingLeft: 2, children: [_jsx(Box, { width: 26, children: _jsxs(Text, { color: theme.text.secondary, children: ["\u00BB ", title] }) }), children] }));
+const Section = ({ title, children }) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { bold: true, color: theme.text.primary, children: title }), children] }));
+const ModelUsageTable = ({ models }) => {
+    const nameWidth = 28;
+    const requestsWidth = 8;
+    const inputTokensWidth = 14;
+    const cacheReadsWidth = 14;
+    const outputTokensWidth = 14;
+    const rows = [];
+    Object.entries(models).forEach(([name, metrics]) => {
+        rows.push({
+            name,
+            displayName: getDisplayString(name),
+            requests: metrics.api.totalRequests,
+            cachedTokens: metrics.tokens.cached.toLocaleString(),
+            inputTokens: metrics.tokens.prompt.toLocaleString(),
+            outputTokens: metrics.tokens.candidates.toLocaleString(),
+            isSubRow: false,
+        });
+        if (metrics.roles) {
+            const roleEntries = Object.entries(metrics.roles).filter((entry) => entry[1] !== undefined && entry[1].totalRequests > 0);
+            roleEntries.sort(([a], [b]) => {
+                if (a === b)
+                    return 0;
+                if (a === LlmRole.MAIN)
+                    return -1;
+                if (b === LlmRole.MAIN)
+                    return 1;
+                return a.localeCompare(b);
+            });
+            roleEntries.forEach(([role, roleMetrics]) => {
+                rows.push({
+                    name: `${name}-${role}`,
+                    displayName: `  ↳ ${role}`,
+                    requests: roleMetrics.totalRequests,
+                    cachedTokens: roleMetrics.tokens.cached.toLocaleString(),
+                    inputTokens: roleMetrics.tokens.prompt.toLocaleString(),
+                    outputTokens: roleMetrics.tokens.candidates.toLocaleString(),
+                    isSubRow: true,
+                });
+            });
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: theme.text.primary, children: "Model Usage" }), _jsx(Text, { color: theme.text.secondary, children: "Use /model to view model quota information" }), _jsx(Box, { height: 1 }), _jsxs(Box, { borderBottom: true, borderStyle: "single", borderColor: theme.border.default, borderTop: false, borderLeft: false, borderRight: false, children: [_jsx(Box, { width: nameWidth, children: _jsx(Text, { bold: true, color: theme.text.secondary, children: "Model" }) }), _jsx(Box, { width: requestsWidth, justifyContent: "flex-end", children: _jsx(Text, { bold: true, color: theme.text.secondary, children: "Reqs" }) }), _jsx(Box, { width: inputTokensWidth, justifyContent: "flex-end", children: _jsx(Text, { bold: true, color: theme.text.secondary, children: "Input Tokens" }) }), _jsx(Box, { width: cacheReadsWidth, justifyContent: "flex-end", children: _jsx(Text, { bold: true, color: theme.text.secondary, children: "Cache Reads" }) }), _jsx(Box, { width: outputTokensWidth, justifyContent: "flex-end", children: _jsx(Text, { bold: true, color: theme.text.secondary, children: "Output Tokens" }) })] }), rows.map((row) => (_jsxs(Box, { children: [_jsx(Box, { width: nameWidth, children: _jsx(Text, { color: row.isSubRow ? theme.text.secondary : theme.text.primary, wrap: "truncate-end", children: row.displayName }) }), _jsx(Box, { width: requestsWidth, justifyContent: "flex-end", children: _jsx(Text, { color: row.isSubRow ? theme.text.secondary : theme.text.primary, children: row.requests }) }), _jsx(Box, { width: inputTokensWidth, justifyContent: "flex-end", children: _jsx(Text, { color: row.isSubRow ? theme.text.secondary : theme.text.primary, children: row.inputTokens }) }), _jsx(Box, { width: cacheReadsWidth, justifyContent: "flex-end", children: _jsx(Text, { color: row.isSubRow ? theme.text.secondary : theme.text.primary, children: row.cachedTokens }) }), _jsx(Box, { width: outputTokensWidth, justifyContent: "flex-end", children: _jsx(Text, { color: row.isSubRow ? theme.text.secondary : theme.text.primary, children: row.outputTokens }) })] }, row.name)))] }));
+};
+export const StatsDisplay = ({ duration, title, footer, selectedAuthType, userEmail, tier, creditBalance, }) => {
+    const { stats } = useSessionStats();
+    const { metrics } = stats;
+    const { tools, files, models } = metrics;
+    const computed = computeSessionStats(metrics);
+    const settings = useSettings();
+    const showUserIdentity = settings.merged.ui.showUserIdentity;
+    const successThresholds = {
+        green: TOOL_SUCCESS_RATE_HIGH,
+        yellow: TOOL_SUCCESS_RATE_MEDIUM,
+    };
+    const agreementThresholds = {
+        green: USER_AGREEMENT_RATE_HIGH,
+        yellow: USER_AGREEMENT_RATE_MEDIUM,
+    };
+    const successColor = getStatusColor(computed.successRate, successThresholds);
+    const agreementColor = getStatusColor(computed.agreementRate, agreementThresholds);
+    const renderTitle = () => {
+        if (title) {
+            return _jsx(ThemedGradient, { bold: true, children: title });
+        }
+        return (_jsx(Text, { bold: true, color: theme.text.accent, children: "Session Stats" }));
+    };
+    const renderFooter = () => {
+        if (!footer) {
+            return null;
+        }
+        return _jsx(ThemedGradient, { bold: true, children: footer });
+    };
+    return (_jsxs(Box, { borderStyle: "round", borderColor: theme.border.default, flexDirection: "column", paddingTop: 1, paddingX: 2, overflow: "hidden", children: [renderTitle(), _jsx(Box, { height: 1 }), _jsxs(Section, { title: "Interaction Summary", children: [_jsx(StatRow, { title: "Session ID:", children: _jsx(Text, { color: theme.text.primary, children: stats.sessionId }) }), showUserIdentity && selectedAuthType && (_jsx(StatRow, { title: "Auth Method:", children: _jsx(Text, { color: theme.text.primary, children: selectedAuthType.startsWith('oauth')
+                                ? userEmail
+                                    ? `Signed in with Google (${userEmail})`
+                                    : 'Signed in with Google'
+                                : selectedAuthType }) })), showUserIdentity && tier && (_jsx(StatRow, { title: "Tier:", children: _jsx(Text, { color: theme.text.primary, children: tier }) })), showUserIdentity && creditBalance != null && creditBalance >= 0 && (_jsx(StatRow, { title: "Google AI Credits:", children: _jsx(Text, { color: creditBalance > 0 ? theme.text.primary : theme.text.secondary, children: creditBalance.toLocaleString() }) })), _jsx(StatRow, { title: "Tool Calls:", children: _jsxs(Text, { color: theme.text.primary, children: [tools.totalCalls, " (", ' ', _jsxs(Text, { color: theme.status.success, children: ["\u2713 ", tools.totalSuccess] }), ' ', _jsxs(Text, { color: theme.status.error, children: ["x ", tools.totalFail] }), " )"] }) }), _jsx(StatRow, { title: "Success Rate:", children: _jsxs(Text, { color: successColor, children: [computed.successRate.toFixed(1), "%"] }) }), computed.totalDecisions > 0 && (_jsx(StatRow, { title: "User Agreement:", children: _jsxs(Text, { color: agreementColor, children: [computed.agreementRate.toFixed(1), "%", ' ', _jsxs(Text, { color: theme.text.secondary, children: ["(", computed.totalDecisions, " reviewed)"] })] }) })), files &&
+                        (files.totalLinesAdded > 0 || files.totalLinesRemoved > 0) && (_jsx(StatRow, { title: "Code Changes:", children: _jsxs(Text, { color: theme.text.primary, children: [_jsxs(Text, { color: theme.status.success, children: ["+", files.totalLinesAdded] }), ' ', _jsxs(Text, { color: theme.status.error, children: ["-", files.totalLinesRemoved] })] }) }))] }), _jsxs(Section, { title: "Performance", children: [_jsx(StatRow, { title: "Wall Time:", children: _jsx(Text, { color: theme.text.primary, children: duration }) }), _jsx(StatRow, { title: "Agent Active:", children: _jsx(Text, { color: theme.text.primary, children: formatDuration(computed.agentActiveTime) }) }), _jsx(SubStatRow, { title: "API Time:", children: _jsxs(Text, { color: theme.text.primary, children: [formatDuration(computed.totalApiTime), ' ', _jsxs(Text, { color: theme.text.secondary, children: ["(", computed.apiTimePercent.toFixed(1), "%)"] })] }) }), _jsx(SubStatRow, { title: "Tool Time:", children: _jsxs(Text, { color: theme.text.primary, children: [formatDuration(computed.totalToolTime), ' ', _jsxs(Text, { color: theme.text.secondary, children: ["(", computed.toolTimePercent.toFixed(1), "%)"] })] }) })] }), Object.keys(models).length > 0 && _jsx(ModelUsageTable, { models: models }), renderFooter()] }));
+};

package/dist/ui/components/StatusDisplay.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { useUIState } from '../contexts/UIStateContext.js';
+import { useSettings } from '../contexts/SettingsContext.js';
+import { useConfig } from '../contexts/ConfigContext.js';
+import { ContextSummaryDisplay } from './ContextSummaryDisplay.js';
+export const StatusDisplay = ({ hideContextSummary, }) => {
+    const uiState = useUIState();
+    const settings = useSettings();
+    const config = useConfig();
+    if (process.env['GEMINI_SYSTEM_MD']) {
+        return _jsx(Text, { color: theme.status.error, children: "|\u2310\u25A0_\u25A0|" });
+    }
+    if (!settings.merged.ui.hideContextSummary && !hideContextSummary) {
+        return (_jsx(ContextSummaryDisplay, { ideContext: uiState.ideContextState, geminiMdFileCount: uiState.geminiMdFileCount, contextFileNames: uiState.contextFileNames, mcpServers: config.getMcpClientManager()?.getMcpServers() ?? {}, blockedMcpServers: config.getMcpClientManager()?.getBlockedMcpServers() ?? [], skillCount: config.getSkillManager().getDisplayableSkills().length, backgroundProcessCount: uiState.backgroundTaskCount }));
+    }
+    return null;
+};