@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/ui/components/ConfigExtensionDialog.js

@@ -0,0 +1,155 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState, useRef, useCallback } from 'react';
+import { Box, Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { configureExtension, configureSpecificSetting, configureAllExtensions, } from '../../commands/extensions/utils.js';
+import { ExtensionSettingScope, } from '../../config/extensions/extensionSettings.js';
+import { TextInput } from './shared/TextInput.js';
+import { useTextBuffer } from './shared/text-buffer.js';
+import { DialogFooter } from './shared/DialogFooter.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+export const ConfigExtensionDialog = ({ extensionManager, onClose, extensionName, settingKey, scope = ExtensionSettingScope.USER, configureAll, loggerAdapter, }) => {
+    const [state, setState] = useState({ type: 'IDLE' });
+    const [logMessages, setLogMessages] = useState([]);
+    // Buffers for input
+    const settingBuffer = useTextBuffer({
+        initialText: '',
+        viewport: { width: 80, height: 1 },
+        singleLine: true,
+        escapePastedPaths: true,
+    });
+    const mounted = useRef(true);
+    useEffect(() => {
+        mounted.current = true;
+        return () => {
+            mounted.current = false;
+        };
+    }, []);
+    const addLog = useCallback((msg) => {
+        setLogMessages((prev) => [...prev, msg].slice(-5)); // Keep last 5
+        loggerAdapter.log(msg);
+    }, [loggerAdapter]);
+    const requestSetting = useCallback(async (setting) => new Promise((resolve) => {
+        if (!mounted.current)
+            return;
+        settingBuffer.setText(''); // Clear buffer
+        setState({
+            type: 'ASK_SETTING',
+            setting,
+            resolve: (val) => {
+                resolve(val);
+                setState({ type: 'BUSY', message: 'Updating...' });
+            },
+        });
+    }), [settingBuffer]);
+    const requestConfirmation = useCallback(async (message) => new Promise((resolve) => {
+        if (!mounted.current)
+            return;
+        setState({
+            type: 'ASK_CONFIRMATION',
+            message,
+            resolve: (val) => {
+                resolve(val);
+                setState({ type: 'BUSY', message: 'Processing...' });
+            },
+        });
+    }), []);
+    useEffect(() => {
+        async function run() {
+            try {
+                setState({ type: 'BUSY', message: 'Initializing...' });
+                // Wrap logger to capture logs locally too
+                const localLogger = {
+                    log: (msg) => {
+                        addLog(msg);
+                    },
+                    error: (msg) => {
+                        addLog('Error: ' + msg);
+                        loggerAdapter.error(msg);
+                    },
+                };
+                if (configureAll) {
+                    await configureAllExtensions(extensionManager, scope, localLogger, requestSetting, requestConfirmation);
+                }
+                else if (extensionName && settingKey) {
+                    await configureSpecificSetting(extensionManager, extensionName, settingKey, scope, localLogger, requestSetting);
+                }
+                else if (extensionName) {
+                    await configureExtension(extensionManager, extensionName, scope, localLogger, requestSetting, requestConfirmation);
+                }
+                if (mounted.current) {
+                    setState({ type: 'DONE' });
+                    // Delay close slightly to show done
+                    setTimeout(onClose, 1000);
+                }
+            }
+            catch (err) {
+                if (mounted.current) {
+                    const error = err instanceof Error ? err : new Error(String(err));
+                    setState({ type: 'ERROR', error });
+                    loggerAdapter.error(error.message);
+                }
+            }
+        }
+        // Only run once
+        if (state.type === 'IDLE') {
+            void run();
+        }
+    }, [
+        extensionManager,
+        extensionName,
+        settingKey,
+        scope,
+        configureAll,
+        loggerAdapter,
+        requestSetting,
+        requestConfirmation,
+        addLog,
+        onClose,
+        state.type,
+    ]);
+    // Handle Input Submission
+    const handleSettingSubmit = (val) => {
+        if (state.type === 'ASK_SETTING') {
+            state.resolve(val);
+        }
+    };
+    // Handle Keys for Confirmation
+    useKeypress((key) => {
+        if (state.type === 'ASK_CONFIRMATION') {
+            if (key.name === 'y' || key.name === 'enter') {
+                state.resolve(true);
+                return true;
+            }
+            if (key.name === 'n' || key.name === 'escape') {
+                state.resolve(false);
+                return true;
+            }
+        }
+        if (state.type === 'DONE' || state.type === 'ERROR') {
+            if (key.name === 'enter' || key.name === 'escape') {
+                onClose();
+                return true;
+            }
+        }
+        return false;
+    }, {
+        isActive: state.type === 'ASK_CONFIRMATION' ||
+            state.type === 'DONE' ||
+            state.type === 'ERROR',
+    });
+    if (state.type === 'BUSY' || state.type === 'IDLE') {
+        return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.border.default, paddingX: 1, children: [_jsx(Text, { color: theme.text.secondary, children: state.type === 'BUSY' ? state.message : 'Starting...' }), logMessages.map((msg, i) => (_jsx(Text, { children: msg }, i)))] }));
+    }
+    if (state.type === 'ASK_SETTING') {
+        return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.border.default, paddingX: 1, children: [_jsxs(Text, { bold: true, color: theme.text.primary, children: ["Configure ", state.setting.name] }), _jsx(Text, { color: theme.text.secondary, children: state.setting.description || state.setting.envVar }), _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(Text, { color: theme.text.accent, children: '> ' }), _jsx(TextInput, { buffer: settingBuffer, onSubmit: handleSettingSubmit, focus: true, placeholder: `Enter value for ${state.setting.name}` })] }), _jsx(DialogFooter, { primaryAction: "Enter to submit" })] }));
+    }
+    if (state.type === 'ASK_CONFIRMATION') {
+        return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.border.default, paddingX: 1, children: [_jsx(Text, { color: theme.status.warning, bold: true, children: "Confirmation Required" }), _jsx(Text, { children: state.message }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.text.secondary, children: ["Press", ' ', _jsx(Text, { color: theme.text.accent, bold: true, children: "Y" }), ' ', "to confirm or", ' ', _jsx(Text, { color: theme.text.accent, bold: true, children: "N" }), ' ', "to cancel"] }) })] }));
+    }
+    if (state.type === 'ERROR') {
+        return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.status.error, paddingX: 1, children: [_jsx(Text, { color: theme.status.error, bold: true, children: "Error" }), _jsx(Text, { children: state.error.message }), _jsx(DialogFooter, { primaryAction: "Enter to close" })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.status.success, paddingX: 1, children: [_jsx(Text, { color: theme.status.success, bold: true, children: "Configuration Complete" }), _jsx(DialogFooter, { primaryAction: "Enter to close" })] }));
+};

package/dist/ui/components/ConfigInitDisplay.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useEffect, useState } from 'react';
+import { Box, Text } from 'ink';
+;
+import { CoreEvent, coreEvents, MCPServerStatus, } from '@google/gemini-cli-core';
+import { GeminiSpinner } from './GeminiSpinner.js';
+import { theme } from '../semantic-colors.js';
+export const ConfigInitDisplay = ({ message: initialMessage = 'Working...', }) => {
+    const [message, setMessage] = useState(initialMessage);
+    useEffect(() => {
+        const onChange = (clients) => {
+            if (!clients || clients.size === 0) {
+                setMessage(initialMessage);
+                return;
+            }
+            let connected = 0;
+            const connecting = [];
+            for (const [name, client] of clients.entries()) {
+                if (client.getStatus() === MCPServerStatus.CONNECTED) {
+                    connected++;
+                }
+                else {
+                    connecting.push(name);
+                }
+            }
+            if (connecting.length > 0) {
+                const maxDisplay = 3;
+                const displayedServers = connecting.slice(0, maxDisplay).join(', ');
+                const remaining = connecting.length - maxDisplay;
+                const suffix = remaining > 0 ? `, +${remaining} more` : '';
+                const mcpMessage = `Connecting to MCP servers... (${connected}/${clients.size}) - Waiting for: ${displayedServers}${suffix}`;
+                setMessage(initialMessage && initialMessage !== 'Working...'
+                    ? `${initialMessage} (${mcpMessage})`
+                    : mcpMessage);
+            }
+            else {
+                const mcpMessage = `Connecting to MCP servers... (${connected}/${clients.size})`;
+                setMessage(initialMessage && initialMessage !== 'Working...'
+                    ? `${initialMessage} (${mcpMessage})`
+                    : mcpMessage);
+            }
+        };
+        coreEvents.on(CoreEvent.McpClientUpdate, onChange);
+        return () => {
+            coreEvents.off(CoreEvent.McpClientUpdate, onChange);
+        };
+    }, [initialMessage]);
+    return (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [_jsx(GeminiSpinner, {}), " ", _jsx(Text, { color: theme.text.primary, children: message })] }) }));
+};

package/dist/ui/components/ConsentPrompt.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Box } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { MarkdownDisplay } from '../utils/MarkdownDisplay.js';
+import { RadioButtonSelect } from './shared/RadioButtonSelect.js';
+import { DialogFooter } from './shared/DialogFooter.js';
+export const ConsentPrompt = (props) => {
+    const { prompt, onConfirm, terminalWidth } = props;
+    return (_jsxs(Box, { borderStyle: "round", borderColor: theme.border.default, flexDirection: "column", paddingTop: 1, paddingX: 2, children: [typeof prompt === 'string' ? (_jsx(MarkdownDisplay, { isPending: true, text: prompt, terminalWidth: terminalWidth })) : (prompt), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(RadioButtonSelect, { items: [
+                            { label: 'Yes', value: true, key: 'Yes' },
+                            { label: 'No', value: false, key: 'No' },
+                        ], onSelect: onConfirm }), _jsx(DialogFooter, { primaryAction: "Enter to select", navigationActions: "\u2191/\u2193 to navigate" })] })] }));
+};

package/dist/ui/components/ConsoleSummaryDisplay.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+export const ConsoleSummaryDisplay = ({ errorCount, }) => {
+    if (errorCount === 0) {
+        return null;
+    }
+    const errorIcon = '\u2716'; // Heavy multiplication x (✖)
+    return (_jsx(Box, { children: errorCount > 0 && (_jsxs(Text, { color: theme.status.error, children: [errorIcon, " ", errorCount, " error", errorCount > 1 ? 's' : '', ' ', _jsx(Text, { color: theme.text.secondary, children: "(F12 for details)" })] })) }));
+};

package/dist/ui/components/ContextSummaryDisplay.js

@@ -0,0 +1,70 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { Command } from '../key/keyMatchers.js';
+import { formatCommand } from '../key/keybindingUtils.js';
+export const ContextSummaryDisplay = ({ geminiMdFileCount, contextFileNames, mcpServers, blockedMcpServers, ideContext, skillCount, backgroundProcessCount = 0, }) => {
+    const mcpServerCount = Object.keys(mcpServers || {}).length;
+    const blockedMcpServerCount = blockedMcpServers?.length || 0;
+    const openFileCount = ideContext?.workspaceState?.openFiles?.length ?? 0;
+    if (geminiMdFileCount === 0 &&
+        mcpServerCount === 0 &&
+        blockedMcpServerCount === 0 &&
+        openFileCount === 0 &&
+        skillCount === 0 &&
+        backgroundProcessCount === 0) {
+        return null;
+    }
+    const openFilesText = (() => {
+        if (openFileCount === 0) {
+            return '';
+        }
+        return `${openFileCount} open file${openFileCount > 1 ? 's' : ''} (${formatCommand(Command.SHOW_IDE_CONTEXT_DETAIL)} to view)`;
+    })();
+    const geminiMdText = (() => {
+        if (geminiMdFileCount === 0) {
+            return '';
+        }
+        const allNamesTheSame = new Set(contextFileNames).size < 2;
+        const name = allNamesTheSame ? contextFileNames[0] : 'context';
+        return `${geminiMdFileCount} ${name} file${geminiMdFileCount > 1 ? 's' : ''}`;
+    })();
+    const mcpText = (() => {
+        if (mcpServerCount === 0 && blockedMcpServerCount === 0) {
+            return '';
+        }
+        const parts = [];
+        if (mcpServerCount > 0) {
+            parts.push(`${mcpServerCount} MCP server${mcpServerCount > 1 ? 's' : ''}`);
+        }
+        if (blockedMcpServerCount > 0) {
+            let blockedText = `${blockedMcpServerCount} Blocked`;
+            if (mcpServerCount === 0) {
+                blockedText += ` MCP server${blockedMcpServerCount > 1 ? 's' : ''}`;
+            }
+            parts.push(blockedText);
+        }
+        return parts.join(', ');
+    })();
+    const skillText = (() => {
+        if (skillCount === 0) {
+            return '';
+        }
+        return `${skillCount} skill${skillCount > 1 ? 's' : ''}`;
+    })();
+    const backgroundText = (() => {
+        if (backgroundProcessCount === 0) {
+            return '';
+        }
+        return `${backgroundProcessCount} Background process${backgroundProcessCount > 1 ? 'es' : ''}`;
+    })();
+    const summaryParts = [
+        openFilesText,
+        geminiMdText,
+        mcpText,
+        skillText,
+        backgroundText,
+    ].filter(Boolean);
+    return (_jsx(Box, { paddingX: 1, flexDirection: "row", flexWrap: "wrap", children: summaryParts.map((part, index) => (_jsxs(Box, { flexDirection: "row", children: [index > 0 && _jsx(Text, { color: theme.text.secondary, children: ' · ' }), _jsx(Text, { color: theme.text.secondary, children: part })] }, index))) }));
+};

package/dist/ui/components/ContextUsageDisplay.js

@@ -0,0 +1,28 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { getContextUsagePercentage } from '../utils/contextUsage.js';
+import { useSettings } from '../contexts/SettingsContext.js';
+import { MIN_TERMINAL_WIDTH_FOR_FULL_LABEL, DEFAULT_COMPRESSION_THRESHOLD, } from '../constants.js';
+export const ContextUsageDisplay = ({ promptTokenCount, model, terminalWidth, }) => {
+    const settings = useSettings();
+    const percentage = getContextUsagePercentage(promptTokenCount, model);
+    const percentageUsed = (percentage * 100).toFixed(0);
+    const threshold = settings.merged.model?.compressionThreshold ??
+        DEFAULT_COMPRESSION_THRESHOLD;
+    let textColor = theme.text.secondary;
+    if (percentage >= 1.0) {
+        textColor = theme.status.error;
+    }
+    else if (percentage >= threshold) {
+        textColor = theme.status.warning;
+    }
+    const label = terminalWidth < MIN_TERMINAL_WIDTH_FOR_FULL_LABEL ? '%' : '% used';
+    return (_jsxs(Text, { color: textColor, children: [percentageUsed, label] }));
+};

package/dist/ui/components/CopyModeWarning.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+;
+import { useInputState } from '../contexts/InputContext.js';
+import { theme } from '../semantic-colors.js';
+export const CopyModeWarning = () => {
+    const { copyModeEnabled } = useInputState();
+    return (_jsx(Box, { height: 1, children: copyModeEnabled && (_jsx(Text, { color: theme.status.warning, children: "In Copy Mode. Use Page Up/Down to scroll. Press Ctrl+S or any other key to exit." })) }));
+};

package/dist/ui/components/DebugProfiler.js

@@ -0,0 +1,189 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Text } from 'ink';
+;
+import { useEffect, useState } from 'react';
+import { FixedDeque } from 'mnemonist';
+import { theme } from '../semantic-colors.js';
+import { useUIState } from '../contexts/UIStateContext.js';
+import { debugState } from '../debug.js';
+import { appEvents, AppEvent } from '../../utils/events.js';
+import { coreEvents, CoreEvent, debugLogger } from '@google/gemini-cli-core';
+// Frames that render at least this far before or after an action are considered
+// idle frames.
+const MIN_TIME_FROM_ACTION_TO_BE_IDLE = 500;
+export const ACTION_TIMESTAMP_CAPACITY = 2048;
+export const FRAME_TIMESTAMP_CAPACITY = 2048;
+// Exported for testing purposes.
+export const profiler = {
+    profilersActive: 0,
+    numFrames: 0,
+    totalIdleFrames: 0,
+    totalFlickerFrames: 0,
+    hasLoggedFirstFlicker: false,
+    lastFrameStartTime: 0,
+    openedDebugConsole: false,
+    lastActionTimestamp: 0,
+    possiblyIdleFrameTimestamps: new FixedDeque(Array, FRAME_TIMESTAMP_CAPACITY),
+    actionTimestamps: new FixedDeque(Array, ACTION_TIMESTAMP_CAPACITY),
+    reportAction() {
+        const now = Date.now();
+        if (now - this.lastActionTimestamp > 16) {
+            if (this.actionTimestamps.size >= ACTION_TIMESTAMP_CAPACITY) {
+                this.actionTimestamps.shift();
+            }
+            this.actionTimestamps.push(now);
+            this.lastActionTimestamp = now;
+        }
+    },
+    reportFrameRendered() {
+        if (this.profilersActive === 0) {
+            return;
+        }
+        const now = Date.now();
+        this.lastFrameStartTime = now;
+        this.numFrames++;
+        if (debugState.debugNumAnimatedComponents === 0) {
+            if (this.possiblyIdleFrameTimestamps.size >= FRAME_TIMESTAMP_CAPACITY) {
+                this.possiblyIdleFrameTimestamps.shift();
+            }
+            this.possiblyIdleFrameTimestamps.push(now);
+        }
+        else {
+            // If a spinner is present, consider this an action that both prevents
+            // this frame from being idle and also should prevent a follow on frame
+            // from being considered idle.
+            if (this.actionTimestamps.size >= ACTION_TIMESTAMP_CAPACITY) {
+                this.actionTimestamps.shift();
+            }
+            this.actionTimestamps.push(now);
+        }
+    },
+    checkForIdleFrames() {
+        const now = Date.now();
+        const judgementCutoff = now - MIN_TIME_FROM_ACTION_TO_BE_IDLE;
+        const oneSecondIntervalFromJudgementCutoff = judgementCutoff - 1000;
+        let idleInPastSecond = 0;
+        while (this.possiblyIdleFrameTimestamps.size > 0 &&
+            this.possiblyIdleFrameTimestamps.peekFirst() <= judgementCutoff) {
+            const frameTime = this.possiblyIdleFrameTimestamps.shift();
+            const start = frameTime - MIN_TIME_FROM_ACTION_TO_BE_IDLE;
+            const end = frameTime + MIN_TIME_FROM_ACTION_TO_BE_IDLE;
+            while (this.actionTimestamps.size > 0 &&
+                this.actionTimestamps.peekFirst() < start) {
+                this.actionTimestamps.shift();
+            }
+            const hasAction = this.actionTimestamps.size > 0 &&
+                this.actionTimestamps.peekFirst() <= end;
+            if (!hasAction) {
+                if (frameTime >= oneSecondIntervalFromJudgementCutoff) {
+                    idleInPastSecond++;
+                }
+                this.totalIdleFrames++;
+            }
+        }
+        if (idleInPastSecond >= 5) {
+            if (this.openedDebugConsole === false) {
+                this.openedDebugConsole = true;
+                appEvents.emit(AppEvent.OpenDebugConsole);
+            }
+            debugLogger.error(`${idleInPastSecond} frames rendered while the app was ` +
+                `idle in the past second. This likely indicates severe infinite loop ` +
+                `React state management bugs.`);
+        }
+    },
+    registerFlickerHandler(constrainHeight) {
+        const flickerHandler = () => {
+            // If we are not constraining the height, we are intentionally
+            // overflowing the screen.
+            if (!constrainHeight) {
+                return;
+            }
+            this.totalFlickerFrames++;
+            this.reportAction();
+            if (!this.hasLoggedFirstFlicker) {
+                this.hasLoggedFirstFlicker = true;
+                debugLogger.error('A flicker frame was detected. This will cause UI instability. Type `/profile` for more info.');
+            }
+        };
+        appEvents.on(AppEvent.Flicker, flickerHandler);
+        return () => {
+            appEvents.off(AppEvent.Flicker, flickerHandler);
+        };
+    },
+};
+export const DebugProfiler = () => {
+    const { showDebugProfiler, constrainHeight } = useUIState();
+    const [forceRefresh, setForceRefresh] = useState(0);
+    // Effect for listening to stdin for keypresses and stdout for resize events.
+    useEffect(() => {
+        profiler.profilersActive++;
+        const stdin = process.stdin;
+        const stdout = process.stdout;
+        const handler = () => {
+            profiler.reportAction();
+        };
+        stdin.on('data', handler);
+        stdout.on('resize', handler);
+        // Register handlers for all core and app events to ensure they are
+        // considered "actions" and don't trigger spurious idle frame warnings.
+        // These events are expected to trigger UI renders.
+        for (const eventName of Object.values(CoreEvent)) {
+            coreEvents.on(eventName, handler);
+        }
+        for (const eventName of Object.values(AppEvent)) {
+            appEvents.on(eventName, handler);
+        }
+        // Register handlers for extension lifecycle events emitted on coreEvents
+        // but not part of the CoreEvent enum, to prevent false-positive idle warnings.
+        const extensionEvents = [
+            'extensionsStarting',
+            'extensionsStopping',
+        ];
+        for (const eventName of extensionEvents) {
+            coreEvents.on(eventName, handler);
+        }
+        return () => {
+            stdin.off('data', handler);
+            stdout.off('resize', handler);
+            for (const eventName of Object.values(CoreEvent)) {
+                coreEvents.off(eventName, handler);
+            }
+            for (const eventName of Object.values(AppEvent)) {
+                appEvents.off(eventName, handler);
+            }
+            for (const eventName of extensionEvents) {
+                coreEvents.off(eventName, handler);
+            }
+            profiler.profilersActive--;
+        };
+    }, []);
+    useEffect(() => {
+        const updateInterval = setInterval(() => {
+            profiler.checkForIdleFrames();
+        }, 1000);
+        return () => clearInterval(updateInterval);
+    }, []);
+    useEffect(() => profiler.registerFlickerHandler(constrainHeight), [constrainHeight]);
+    // Effect for updating stats
+    useEffect(() => {
+        if (!showDebugProfiler) {
+            return;
+        }
+        // Only update the UX infrequently as updating the UX itself will cause
+        // frames to run so can disturb what we are measuring.
+        const forceRefreshInterval = setInterval(() => {
+            setForceRefresh((f) => f + 1);
+            profiler.reportAction();
+        }, 4000);
+        return () => clearInterval(forceRefreshInterval);
+    }, [showDebugProfiler]);
+    if (!showDebugProfiler) {
+        return null;
+    }
+    return (_jsxs(Text, { color: theme.status.warning, children: ["Renders: ", profiler.numFrames, " (total),", ' ', _jsxs(Text, { color: theme.status.error, children: [profiler.totalIdleFrames, " (idle)"] }), ",", ' ', _jsxs(Text, { color: theme.status.error, children: [profiler.totalFlickerFrames, " (flicker)"] })] }, forceRefresh));
+};

package/dist/ui/components/DetailedMessagesDisplay.js

@@ -0,0 +1,59 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useCallback, useMemo } from 'react';
+import { Box, Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { ScrollableList, } from './shared/ScrollableList.js';
+import { useConsoleMessages } from '../hooks/useConsoleMessages.js';
+import { useConfig } from '../contexts/ConfigContext.js';
+const iconBoxWidth = 3;
+export const DetailedMessagesDisplay = ({ maxHeight, width, hasFocus }) => {
+    const scrollableListRef = useRef(null);
+    const consoleMessages = useConsoleMessages();
+    const config = useConfig();
+    const messages = useMemo(() => {
+        if (config.getDebugMode()) {
+            return consoleMessages;
+        }
+        return consoleMessages.filter((msg) => msg.type !== 'debug');
+    }, [consoleMessages, config]);
+    const borderAndPadding = 3;
+    const estimatedItemHeight = useCallback((index) => {
+        const msg = messages[index];
+        if (!msg) {
+            return 1;
+        }
+        const textWidth = width - borderAndPadding - iconBoxWidth;
+        if (textWidth <= 0) {
+            return 1;
+        }
+        const lines = Math.ceil((msg.content?.length || 1) / textWidth);
+        return Math.max(1, lines);
+    }, [width, messages]);
+    if (messages.length === 0) {
+        return null;
+    }
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, borderStyle: "round", borderColor: theme.border.default, paddingLeft: 1, width: width, height: maxHeight, flexShrink: 0, flexGrow: 0, overflow: "hidden", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: theme.text.primary, children: ["Debug Console ", _jsx(Text, { color: theme.text.secondary, children: "(F12 to close)" })] }) }), _jsx(Box, { height: maxHeight, width: width - borderAndPadding, children: _jsx(ScrollableList, { ref: scrollableListRef, data: messages, renderItem: ({ item: msg }) => {
+                        let textColor = theme.text.primary;
+                        let icon = 'ℹ'; // Information source (ℹ)
+                        switch (msg.type) {
+                            case 'warn':
+                                textColor = theme.status.warning;
+                                icon = '⚠'; // Warning sign (⚠)
+                                break;
+                            case 'error':
+                                textColor = theme.status.error;
+                                icon = '✖'; // Heavy multiplication x (✖)
+                                break;
+                            case 'debug':
+                                textColor = theme.text.secondary; // Or theme.text.secondary
+                                icon = '🔍'; // Left-pointing magnifying glass (🔍)
+                                break;
+                            case 'log':
+                            default:
+                                // Default textColor and icon are already set
+                                break;
+                        }
+                        return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { minWidth: iconBoxWidth, flexShrink: 0, children: _jsx(Text, { color: textColor, children: icon }) }), _jsxs(Text, { color: textColor, wrap: "wrap", children: [msg.content, msg.count && msg.count > 1 && (_jsxs(Text, { color: theme.text.secondary, children: [" (x", msg.count, ")"] }))] })] }));
+                    }, keyExtractor: (item, index) => `${item.content}-${index}`, estimatedItemHeight: estimatedItemHeight, hasFocus: hasFocus, initialScrollIndex: Number.MAX_SAFE_INTEGER }) })] }));
+};