@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/ui/components/messages/ToolGroupMessage.js

@@ -0,0 +1,268 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, Fragment } from 'react';
+import { Box, Text } from 'ink';
+;
+import { ToolCallStatus, mapCoreStatusToDisplayStatus } from '../../types.js';
+import { ToolMessage } from './ToolMessage.js';
+import { ShellToolMessage } from './ShellToolMessage.js';
+import { TopicMessage, isTopicTool } from './TopicMessage.js';
+import { SubagentGroupDisplay } from './SubagentGroupDisplay.js';
+import { DenseToolMessage } from './DenseToolMessage.js';
+import { theme } from '../../semantic-colors.js';
+import { useConfig } from '../../contexts/ConfigContext.js';
+import { isShellTool } from './ToolShared.js';
+import { isVisibleInToolGroup, Kind, EDIT_DISPLAY_NAME, GLOB_DISPLAY_NAME, WEB_SEARCH_DISPLAY_NAME, READ_FILE_DISPLAY_NAME, LS_DISPLAY_NAME, GREP_DISPLAY_NAME, WEB_FETCH_DISPLAY_NAME, WRITE_FILE_DISPLAY_NAME, READ_MANY_FILES_DISPLAY_NAME, isFileDiff, } from '@google/gemini-cli-core';
+import { buildToolVisibilityContextFromDisplay } from '../../utils/historyUtils.js';
+import { useUIState } from '../../contexts/UIStateContext.js';
+import { getToolGroupBorderAppearance } from '../../utils/borderStyles.js';
+import { useSettings } from '../../contexts/SettingsContext.js';
+import { TOOL_RESULT_STATIC_HEIGHT, TOOL_RESULT_STANDARD_RESERVED_LINE_COUNT, } from '../../utils/toolLayoutUtils.js';
+const COMPACT_OUTPUT_ALLOWLIST = new Set([
+    EDIT_DISPLAY_NAME,
+    GLOB_DISPLAY_NAME,
+    WEB_SEARCH_DISPLAY_NAME,
+    READ_FILE_DISPLAY_NAME,
+    LS_DISPLAY_NAME,
+    GREP_DISPLAY_NAME,
+    WEB_FETCH_DISPLAY_NAME,
+    WRITE_FILE_DISPLAY_NAME,
+    READ_MANY_FILES_DISPLAY_NAME,
+]);
+// Helper to identify if a tool should use the compact view
+export const isCompactTool = (tool, isCompactModeEnabled) => {
+    const hasCompactOutputSupport = COMPACT_OUTPUT_ALLOWLIST.has(tool.name);
+    const displayStatus = mapCoreStatusToDisplayStatus(tool.status);
+    return (isCompactModeEnabled &&
+        hasCompactOutputSupport &&
+        displayStatus !== ToolCallStatus.Confirming);
+};
+// Helper to identify if a compact tool has a payload (diff, list, etc.)
+export const hasDensePayload = (tool) => {
+    if (tool.outputFile)
+        return true;
+    const res = tool.resultDisplay;
+    if (!res)
+        return false;
+    // TODO(24053): Usage of type guards makes this class too aware of internals
+    if (isFileDiff(res))
+        return true;
+    if (tool.confirmationDetails?.type === 'edit')
+        return true;
+    // Generic summary/payload pattern
+    if (typeof res === 'object' &&
+        res !== null &&
+        'summary' in res &&
+        'payload' in res) {
+        return true;
+    }
+    return false;
+};
+// Main component renders the border and maps the tools using ToolMessage
+const TOOL_MESSAGE_HORIZONTAL_MARGIN = 4;
+export const ToolGroupMessage = ({ item, toolCalls: allToolCalls, availableTerminalHeight, terminalWidth, borderTop: borderTopOverride, borderBottom: borderBottomOverride, isExpandable, }) => {
+    const settings = useSettings();
+    const isLowErrorVerbosity = settings.merged.ui?.errorVerbosity !== 'full';
+    const isCompactModeEnabled = settings.merged.ui?.compactToolOutput === true;
+    // Filter out tool calls that should be hidden (e.g. in-progress Ask User, or Plan Mode operations).
+    const visibleToolCalls = useMemo(() => allToolCalls.filter((t) => 
+    // Use the unified visibility utility
+    isVisibleInToolGroup(buildToolVisibilityContextFromDisplay(t), isLowErrorVerbosity ? 'low' : 'full')), [allToolCalls, isLowErrorVerbosity]);
+    const { activePtyId, embeddedShellFocused, backgroundTasks, pendingHistoryItems, } = useUIState();
+    const config = useConfig();
+    const { borderColor, borderDimColor } = useMemo(() => getToolGroupBorderAppearance(item, activePtyId, embeddedShellFocused, pendingHistoryItems, backgroundTasks), [
+        item,
+        activePtyId,
+        embeddedShellFocused,
+        pendingHistoryItems,
+        backgroundTasks,
+    ]);
+    const groupedTools = useMemo(() => {
+        const groups = [];
+        for (const tool of visibleToolCalls) {
+            if (tool.kind === Kind.Agent) {
+                const lastGroup = groups[groups.length - 1];
+                if (Array.isArray(lastGroup)) {
+                    lastGroup.push(tool);
+                }
+                else {
+                    groups.push([tool]);
+                }
+            }
+            else {
+                groups.push(tool);
+            }
+        }
+        return groups;
+    }, [visibleToolCalls]);
+    const staticHeight = useMemo(() => {
+        let height = 0;
+        for (let i = 0; i < groupedTools.length; i++) {
+            const group = groupedTools[i];
+            const isLast = i === groupedTools.length - 1;
+            const prevGroup = i > 0 ? groupedTools[i - 1] : null;
+            const prevIsCompact = prevGroup &&
+                !Array.isArray(prevGroup) &&
+                isCompactTool(prevGroup, isCompactModeEnabled);
+            const prevIsTopic = prevGroup && !Array.isArray(prevGroup) && isTopicTool(prevGroup.name);
+            const nextGroup = !isLast ? groupedTools[i + 1] : null;
+            const nextIsCompact = nextGroup &&
+                !Array.isArray(nextGroup) &&
+                isCompactTool(nextGroup, isCompactModeEnabled);
+            const nextIsTopicToolCall = nextGroup && !Array.isArray(nextGroup) && isTopicTool(nextGroup.name);
+            const isAgentGroup = Array.isArray(group);
+            const isCompact = !isAgentGroup && isCompactTool(group, isCompactModeEnabled);
+            const isTopicToolCall = !isAgentGroup && isTopicTool(group.name);
+            // Align isFirst logic with rendering
+            let isFirst = i === 0;
+            if (!isFirst) {
+                // Check if all previous tools were topics (matches rendering logic exactly)
+                let allPreviousTopics = true;
+                for (let j = 0; j < i; j++) {
+                    const prevGroupItem = groupedTools[j];
+                    if (Array.isArray(prevGroupItem) ||
+                        !isTopicTool(prevGroupItem.name)) {
+                        allPreviousTopics = false;
+                        break;
+                    }
+                }
+                isFirst = allPreviousTopics;
+            }
+            const isFirstProp = !!(isFirst
+                ? (borderTopOverride ?? true)
+                : prevIsCompact || prevIsTopic);
+            const showClosingBorder = !isCompact &&
+                !isTopicToolCall &&
+                (nextIsCompact || nextIsTopicToolCall || isLast);
+            if (isAgentGroup) {
+                // Agent Group Spacing Breakdown:
+                // 1. Top Boundary (0 or 1): Only present via borderTop if isFirstProp is true.
+                // 2. Header Content (1): The "≡ Running Agent..." status text.
+                // 3. Agent List (group.length lines): One line per agent in the group.
+                // 4. Closing Border (1): Added if transition logic (showClosingBorder) requires it.
+                height +=
+                    (isFirstProp ? 1 : 0) +
+                        1 +
+                        group.length +
+                        (showClosingBorder ? 1 : 0);
+            }
+            else if (isTopicToolCall) {
+                // Topic Message Spacing Breakdown:
+                // 1. Topic Content (1).
+                // 2. Bottom Margin (1): Always present around TopicMessage for breathing room.
+                // 3. Closing Border (1): Added if transition logic (showClosingBorder) requires it.
+                height += 1 + 1 + (showClosingBorder ? 1 : 0);
+            }
+            else if (isCompact) {
+                // Compact Tool: Always renders as a single dense line.
+                height += 1;
+            }
+            else {
+                // Standard Tool (ToolMessage / ShellToolMessage) Spacing Breakdown:
+                // 1. TOOL_RESULT_STANDARD_RESERVED_LINE_COUNT (4) accounts for the top boundary,
+                // internal separator, header padding, and the group closing border.
+                // (Subtract 1 to isolate the group-level closing border.)
+                // 2. Header Content (1): TOOL_RESULT_STATIC_HEIGHT (the tool name/status).
+                // 3. Output File Message (1): (conditional) if outputFile is present.
+                // 4. Group Closing Border (1): (conditional) if transition logic (showClosingBorder) requires it.
+                height +=
+                    TOOL_RESULT_STANDARD_RESERVED_LINE_COUNT -
+                        1 +
+                        TOOL_RESULT_STATIC_HEIGHT +
+                        (group.outputFile ? 1 : 0) +
+                        (showClosingBorder ? 1 : 0);
+            }
+        }
+        return height;
+    }, [groupedTools, isCompactModeEnabled, borderTopOverride]);
+    let countToolCallsWithResults = 0;
+    for (const tool of visibleToolCalls) {
+        if (tool.kind !== Kind.Agent) {
+            if (isCompactTool(tool, isCompactModeEnabled)) {
+                if (hasDensePayload(tool)) {
+                    countToolCallsWithResults++;
+                }
+            }
+            else if (tool.resultDisplay !== undefined &&
+                tool.resultDisplay !== '') {
+                countToolCallsWithResults++;
+            }
+        }
+    }
+    const availableTerminalHeightPerToolMessage = availableTerminalHeight
+        ? Math.max(Math.floor((availableTerminalHeight - staticHeight) /
+            Math.max(1, countToolCallsWithResults)), 1)
+        : undefined;
+    const contentWidth = terminalWidth - TOOL_MESSAGE_HORIZONTAL_MARGIN;
+    // If all tools are filtered out (e.g., in-progress AskUser tools, low-verbosity
+    // internal errors, plan-mode hidden write/edit), we should not emit standalone
+    // border fragments. The only case where an empty group should render is the
+    // explicit "closing slice" (tools: []) used to bridge static/pending sections,
+    // and only if it's actually continuing an open box from above.
+    const isExplicitClosingSlice = allToolCalls.length === 0;
+    const shouldShowGroup = visibleToolCalls.length > 0 ||
+        (isExplicitClosingSlice && borderBottomOverride === true);
+    if (!shouldShowGroup) {
+        return null;
+    }
+    const content = (_jsxs(Box, { flexDirection: "column", 
+        /*
+        This width constraint is highly important and protects us from an Ink rendering bug.
+        Since the ToolGroup can typically change rendering states frequently, it can cause
+        Ink to render the border of the box incorrectly and span multiple lines and even
+        cause tearing.
+      */
+        width: terminalWidth, paddingRight: TOOL_MESSAGE_HORIZONTAL_MARGIN, marginBottom: 0, children: [visibleToolCalls.length === 0 &&
+                isExplicitClosingSlice &&
+                borderBottomOverride === true && (_jsx(Box, { width: contentWidth, borderLeft: true, borderRight: true, borderTop: false, borderBottom: true, borderColor: borderColor, borderDimColor: borderDimColor, borderStyle: "round" })), groupedTools.map((group, index) => {
+                let isFirst = index === 0;
+                if (!isFirst) {
+                    // Check if all previous tools were topics
+                    let allPreviousWereTopics = true;
+                    for (let i = 0; i < index; i++) {
+                        const prevGroup = groupedTools[i];
+                        if (Array.isArray(prevGroup) || !isTopicTool(prevGroup.name)) {
+                            allPreviousWereTopics = false;
+                            break;
+                        }
+                    }
+                    isFirst = allPreviousWereTopics;
+                }
+                const isLast = index === groupedTools.length - 1;
+                const prevGroup = index > 0 ? groupedTools[index - 1] : null;
+                const prevIsCompact = prevGroup &&
+                    !Array.isArray(prevGroup) &&
+                    isCompactTool(prevGroup, isCompactModeEnabled);
+                const prevIsTopic = prevGroup && !Array.isArray(prevGroup) && isTopicTool(prevGroup.name);
+                const nextGroup = !isLast ? groupedTools[index + 1] : null;
+                const nextIsCompact = nextGroup &&
+                    !Array.isArray(nextGroup) &&
+                    isCompactTool(nextGroup, isCompactModeEnabled);
+                const nextIsTopicToolCall = nextGroup && !Array.isArray(nextGroup) && isTopicTool(nextGroup.name);
+                const isAgentGroup = Array.isArray(group);
+                const isCompact = !isAgentGroup && isCompactTool(group, isCompactModeEnabled);
+                const isTopicToolCall = !isAgentGroup && isTopicTool(group.name);
+                const isFirstProp = !!(isFirst
+                    ? (borderTopOverride ?? true)
+                    : prevIsCompact || prevIsTopic);
+                const showClosingBorder = !isCompact &&
+                    !isTopicToolCall &&
+                    (nextIsCompact || nextIsTopicToolCall || isLast);
+                if (isAgentGroup) {
+                    return (_jsxs(Box, { flexDirection: "column", width: contentWidth, children: [_jsx(SubagentGroupDisplay, { toolCalls: group, availableTerminalHeight: availableTerminalHeight, terminalWidth: contentWidth, borderColor: borderColor, borderDimColor: borderDimColor, isFirst: isFirstProp, isExpandable: isExpandable }), showClosingBorder && (_jsx(Box, { width: contentWidth, borderLeft: true, borderRight: true, borderTop: false, borderBottom: isLast ? (borderBottomOverride ?? true) : true, borderColor: borderColor, borderDimColor: borderDimColor, borderStyle: "round" }))] }, group[0].callId));
+                }
+                const tool = group;
+                const isShellToolCall = isShellTool(tool.name);
+                const commonProps = {
+                    ...tool,
+                    availableTerminalHeight: availableTerminalHeightPerToolMessage,
+                    terminalWidth: contentWidth,
+                    emphasis: 'medium',
+                    isFirst: isCompact ? false : isFirstProp,
+                    borderColor,
+                    borderDimColor,
+                    isExpandable,
+                };
+                return (_jsxs(Fragment, { children: [_jsxs(Box, { flexDirection: "column", minHeight: 1, width: contentWidth, children: [isCompact ? (_jsx(DenseToolMessage, { ...commonProps })) : isTopicToolCall ? (_jsx(Box, { marginBottom: 1, children: _jsx(TopicMessage, { ...commonProps }) })) : isShellToolCall ? (_jsx(ShellToolMessage, { ...commonProps, config: config })) : (_jsx(ToolMessage, { ...commonProps })), !isCompact && tool.outputFile && (_jsx(Box, { borderLeft: true, borderRight: true, borderTop: false, borderBottom: false, borderColor: borderColor, borderDimColor: borderDimColor, flexDirection: "column", borderStyle: "round", paddingLeft: 1, paddingRight: 1, children: _jsx(Box, { children: _jsxs(Text, { color: theme.text.primary, children: ["Output too long and was saved to: ", tool.outputFile] }) }) }))] }), showClosingBorder && (_jsx(Box, { width: contentWidth, borderLeft: true, borderRight: true, borderTop: false, borderBottom: isLast ? (borderBottomOverride ?? true) : true, borderColor: borderColor, borderDimColor: borderDimColor, borderStyle: "round" }))] }, tool.callId));
+            })] }));
+    return content;
+};

package/dist/ui/components/messages/ToolMessage.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box } from 'ink';
+;
+import { StickyHeader } from '../StickyHeader.js';
+import { ToolResultDisplay } from './ToolResultDisplay.js';
+import { ToolStatusIndicator, ToolInfo, TrailingIndicator, McpProgressIndicator, STATUS_INDICATOR_WIDTH, isThisShellFocusable as checkIsShellFocusable, isThisShellFocused as checkIsShellFocused, useFocusHint, FocusHint, } from './ToolShared.js';
+import { CoreToolCallStatus, Kind } from '@google/gemini-cli-core';
+import { ShellInputPrompt } from '../ShellInputPrompt.js';
+import { SUBAGENT_MAX_LINES } from '../../constants.js';
+import { useToolActions } from '../../contexts/ToolActionsContext.js';
+export const ToolMessage = ({ callId, name, description, resultDisplay, status, kind, availableTerminalHeight, terminalWidth, emphasis = 'medium', renderOutputAsMarkdown = true, isFirst, borderColor, borderDimColor, activeShellPtyId, embeddedShellFocused, ptyId, config, progressMessage, originalRequestName, progress, progressTotal, }) => {
+    const { isExpanded: isExpandedInContext } = useToolActions();
+    const isExpanded = (isExpandedInContext ? isExpandedInContext(callId) : false) ||
+        availableTerminalHeight === undefined;
+    const isThisShellFocused = checkIsShellFocused(name, status, ptyId, activeShellPtyId, embeddedShellFocused);
+    const isThisShellFocusable = checkIsShellFocusable(name, status, config);
+    const { shouldShowFocusHint } = useFocusHint(isThisShellFocusable, isThisShellFocused, resultDisplay);
+    return (
+    // It is crucial we don't replace this <> with a Box because otherwise the
+    // sticky header inside it would be sticky to that box rather than to the
+    // parent component of this ToolMessage.
+    _jsxs(_Fragment, { children: [_jsxs(StickyHeader, { width: terminalWidth, isFirst: isFirst, borderColor: borderColor, borderDimColor: borderDimColor, children: [_jsx(ToolStatusIndicator, { status: status, name: name, isFocused: isThisShellFocused }), _jsx(ToolInfo, { name: name, status: status, description: description, emphasis: emphasis, progressMessage: progressMessage, originalRequestName: originalRequestName, isExpanded: isExpanded }), _jsx(FocusHint, { shouldShowFocusHint: shouldShowFocusHint, isThisShellFocused: isThisShellFocused }), emphasis === 'high' && _jsx(TrailingIndicator, {})] }), _jsxs(Box, { width: terminalWidth, borderStyle: "round", borderColor: borderColor, borderDimColor: borderDimColor, borderTop: false, borderBottom: false, borderLeft: true, borderRight: true, paddingX: 1, flexDirection: "column", children: [status === CoreToolCallStatus.Executing && progress !== undefined && (_jsx(McpProgressIndicator, { progress: progress, total: progressTotal, message: progressMessage, barWidth: 20 })), _jsx(ToolResultDisplay, { resultDisplay: resultDisplay, availableTerminalHeight: availableTerminalHeight, terminalWidth: terminalWidth, renderOutputAsMarkdown: renderOutputAsMarkdown, hasFocus: isThisShellFocused, maxLines: kind === Kind.Agent && availableTerminalHeight !== undefined
+                            ? SUBAGENT_MAX_LINES
+                            : undefined, overflowDirection: kind === Kind.Agent ? 'bottom' : 'top' }), isThisShellFocused && config && (_jsx(Box, { paddingLeft: STATUS_INDICATOR_WIDTH, marginTop: 1, children: _jsx(ShellInputPrompt, { activeShellPtyId: activeShellPtyId ?? null, focus: embeddedShellFocused }) }))] })] }));
+};

package/dist/ui/components/messages/ToolResultDisplay.js

@@ -0,0 +1,146 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import React from 'react';
+import { Box, Text } from 'ink';
+;
+import { DiffRenderer } from './DiffRenderer.js';
+import { MarkdownDisplay } from '../../utils/MarkdownDisplay.js';
+import { AnsiOutputText, AnsiLineText } from '../AnsiOutput.js';
+import { SlicingMaxSizedBox } from '../shared/SlicingMaxSizedBox.js';
+import { MaxSizedBox } from '../shared/MaxSizedBox.js';
+import { theme } from '../../semantic-colors.js';
+import { isSubagentProgress, isStructuredToolResult, } from '@google/gemini-cli-core';
+import { useUIState } from '../../contexts/UIStateContext.js';
+import { tryParseJSON } from '../../../utils/jsonoutput.js';
+import { useAlternateBuffer } from '../../hooks/useAlternateBuffer.js';
+import { Scrollable } from '../shared/Scrollable.js';
+import { ScrollableList } from '../shared/ScrollableList.js';
+import { SCROLL_TO_ITEM_END } from '../shared/VirtualizedList.js';
+import { ACTIVE_SHELL_MAX_LINES } from '../../constants.js';
+import { calculateToolContentMaxLines } from '../../utils/toolLayoutUtils.js';
+import { SubagentProgressDisplay } from './SubagentProgressDisplay.js';
+export const ToolResultDisplay = ({ resultDisplay, availableTerminalHeight, terminalWidth, renderOutputAsMarkdown = true, maxLines, hasFocus = false, overflowDirection = 'top', }) => {
+    const { renderMarkdown, constrainHeight } = useUIState();
+    const isAlternateBuffer = useAlternateBuffer();
+    const availableHeight = calculateToolContentMaxLines({
+        availableTerminalHeight,
+        isAlternateBuffer,
+        maxLinesLimit: maxLines,
+    });
+    const combinedPaddingAndBorderWidth = 4;
+    const childWidth = terminalWidth - combinedPaddingAndBorderWidth;
+    const keyExtractor = React.useCallback((_, index) => index.toString(), []);
+    const renderVirtualizedAnsiLine = React.useCallback(({ item }) => (_jsx(Box, { height: 1, overflow: "hidden", children: _jsx(AnsiLineText, { line: item }) })), []);
+    if (!resultDisplay)
+        return null;
+    // 1. Early return for background tools (Todos)
+    if (typeof resultDisplay === 'object' && 'todos' in resultDisplay) {
+        // display nothing, as the TodoTray will handle rendering todos
+        return null;
+    }
+    const renderContent = (contentData) => {
+        // Check if string content is valid JSON and pretty-print it
+        const prettyJSON = typeof contentData === 'string' ? tryParseJSON(contentData) : null;
+        const formattedJSON = prettyJSON
+            ? JSON.stringify(prettyJSON, null, 2)
+            : null;
+        let content;
+        if (formattedJSON) {
+            // Render pretty-printed JSON
+            content = (_jsx(Text, { wrap: "wrap", color: theme.text.primary, children: formattedJSON }));
+        }
+        else if (isSubagentProgress(contentData)) {
+            content = (_jsx(SubagentProgressDisplay, { progress: contentData, terminalWidth: childWidth }));
+        }
+        else if (typeof contentData === 'string' && renderOutputAsMarkdown) {
+            content = (_jsx(MarkdownDisplay, { text: contentData, terminalWidth: childWidth, renderMarkdown: renderMarkdown, isPending: false }));
+        }
+        else if (typeof contentData === 'string' && !renderOutputAsMarkdown) {
+            content = (_jsx(Text, { wrap: "wrap", color: theme.text.primary, children: contentData }));
+        }
+        else if (isStructuredToolResult(contentData)) {
+            if (renderOutputAsMarkdown) {
+                content = (_jsx(MarkdownDisplay, { text: contentData.summary, terminalWidth: childWidth, renderMarkdown: renderMarkdown, isPending: false }));
+            }
+            else {
+                content = (_jsx(Text, { wrap: "wrap", color: theme.text.primary, children: contentData.summary }));
+            }
+        }
+        else if (typeof contentData === 'object' &&
+            contentData !== null &&
+            'fileDiff' in contentData) {
+            content = (_jsx(DiffRenderer, { diffContent: 
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                contentData.fileDiff, 
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                filename: contentData.fileName, availableTerminalHeight: availableHeight, terminalWidth: childWidth }));
+        }
+        else if (Array.isArray(contentData)) {
+            const shouldDisableTruncation = isAlternateBuffer ||
+                (availableTerminalHeight === undefined && maxLines === undefined);
+            content = (_jsx(AnsiOutputText
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            , { 
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                data: contentData, availableTerminalHeight: isAlternateBuffer ? undefined : availableHeight, width: childWidth, maxLines: isAlternateBuffer ? undefined : maxLines, disableTruncation: shouldDisableTruncation }));
+        }
+        else if (typeof contentData === 'object' && contentData !== null) {
+            // Render as JSON for other non-null objects
+            content = (_jsx(Text, { wrap: "wrap", color: theme.text.primary, children: JSON.stringify(contentData, null, 2) }));
+        }
+        else {
+            content = null;
+        }
+        // Final render based on session mode
+        if (isAlternateBuffer) {
+            // Use maxLines if provided, otherwise fall back to the calculated available height
+            const effectiveMaxHeight = maxLines ?? availableHeight;
+            return (_jsx(Scrollable, { width: childWidth, maxHeight: effectiveMaxHeight, hasFocus: hasFocus, scrollToBottom: true, reportOverflow: true, children: content }));
+        }
+        return content;
+    };
+    if (Array.isArray(resultDisplay)) {
+        const limit = maxLines ?? availableHeight ?? ACTIVE_SHELL_MAX_LINES;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        const data = resultDisplay;
+        // Calculate list height: if not constrained, use full data length.
+        // If constrained (e.g. alternate buffer), limit to available height
+        // to ensure virtualization works and fits within the viewport.
+        const listHeight = !constrainHeight
+            ? data.length
+            : Math.min(data.length, limit);
+        if (isAlternateBuffer) {
+            const initialScrollIndex = overflowDirection === 'bottom' ? 0 : SCROLL_TO_ITEM_END;
+            return (_jsx(Box, { width: childWidth, flexDirection: "column", maxHeight: listHeight, children: _jsx(ScrollableList, { width: childWidth, containerHeight: listHeight, data: data, renderItem: renderVirtualizedAnsiLine, estimatedItemHeight: () => 1, fixedItemHeight: true, keyExtractor: keyExtractor, initialScrollIndex: initialScrollIndex, hasFocus: hasFocus }) }));
+        }
+        else {
+            let displayData = data;
+            let hiddenLines = 0;
+            if (constrainHeight && data.length > listHeight) {
+                hiddenLines = data.length - listHeight;
+                if (overflowDirection === 'top') {
+                    displayData = data.slice(hiddenLines);
+                }
+                else {
+                    displayData = data.slice(0, listHeight);
+                }
+            }
+            return (_jsx(Box, { width: childWidth, flexDirection: "column", children: _jsx(MaxSizedBox, { maxHeight: constrainHeight ? listHeight : undefined, maxWidth: childWidth, overflowDirection: overflowDirection, additionalHiddenLinesCount: hiddenLines, children: displayData.map((item, index) => {
+                        const actualIndex = (overflowDirection === 'top' ? hiddenLines : 0) + index;
+                        return (_jsx(Box, { height: 1, overflow: "hidden", children: _jsx(AnsiLineText, { line: item }) }, keyExtractor(item, actualIndex)));
+                    }) }) }));
+        }
+    }
+    // ASB Mode Handling (Interactive/Fullscreen)
+    if (isAlternateBuffer) {
+        // Standard path for strings/diffs in ASB
+        return (_jsx(Box, { width: childWidth, flexDirection: "column", children: renderContent(resultDisplay) }));
+    }
+    // Standard Mode Handling (History/Scrollback)
+    // We use SlicingMaxSizedBox which includes MaxSizedBox for precision truncation + hidden labels
+    return (_jsx(Box, { width: childWidth, flexDirection: "column", children: _jsx(SlicingMaxSizedBox, { data: resultDisplay, maxLines: maxLines, isAlternateBuffer: isAlternateBuffer, maxHeight: availableHeight, maxWidth: childWidth, overflowDirection: overflowDirection, children: (truncatedResultDisplay) => renderContent(truncatedResultDisplay) }) }));
+};

package/dist/ui/components/messages/ToolShared.js

@@ -0,0 +1,125 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+;
+import { ToolCallStatus, mapCoreStatusToDisplayStatus } from '../../types.js';
+import { CliSpinner } from '../CliSpinner.js';
+import { SHELL_COMMAND_NAME, SHELL_NAME, TOOL_STATUS, SHELL_FOCUS_HINT_DELAY_MS, } from '../../constants.js';
+import { theme } from '../../semantic-colors.js';
+import { SHELL_TOOL_NAME, isCompletedAskUserTool, CoreToolCallStatus, } from '@google/gemini-cli-core';
+import { useInactivityTimer } from '../../hooks/useInactivityTimer.js';
+import { formatCommand } from '../../key/keybindingUtils.js';
+import { Command } from '../../key/keyBindings.js';
+export const STATUS_INDICATOR_WIDTH = 3;
+/**
+ * Returns true if the tool name corresponds to a shell tool.
+ */
+export function isShellTool(name) {
+    const normalized = name.toLowerCase();
+    return (name === SHELL_COMMAND_NAME ||
+        name === SHELL_NAME ||
+        name === SHELL_TOOL_NAME ||
+        normalized === 'shell');
+}
+/**
+ * Returns true if the shell tool call is currently focusable.
+ */
+export function isThisShellFocusable(name, status, config) {
+    return !!(isShellTool(name) &&
+        status === CoreToolCallStatus.Executing &&
+        config?.getEnableInteractiveShell());
+}
+/**
+ * Returns true if this specific shell tool call is currently focused.
+ */
+export function isThisShellFocused(name, status, ptyId, activeShellPtyId, embeddedShellFocused) {
+    return !!(isShellTool(name) &&
+        status === CoreToolCallStatus.Executing &&
+        ptyId === activeShellPtyId &&
+        embeddedShellFocused);
+}
+/**
+ * Hook to manage focus hint state.
+ */
+export function useFocusHint(isThisShellFocusable, isThisShellFocused, resultDisplay) {
+    const [userHasFocused, setUserHasFocused] = useState(false);
+    // Derive a stable reset key for the inactivity timer. For strings and arrays
+    // (shell output), we use the length to capture updates without referential
+    // identity issues or expensive deep comparisons.
+    const resetKey = typeof resultDisplay === 'string'
+        ? resultDisplay.length
+        : Array.isArray(resultDisplay)
+            ? resultDisplay.length
+            : !!resultDisplay;
+    const showFocusHint = useInactivityTimer(isThisShellFocusable, resetKey, SHELL_FOCUS_HINT_DELAY_MS);
+    useEffect(() => {
+        if (isThisShellFocused) {
+            setUserHasFocused(true);
+        }
+    }, [isThisShellFocused]);
+    const shouldShowFocusHint = isThisShellFocusable && (showFocusHint || userHasFocused);
+    return { shouldShowFocusHint };
+}
+/**
+ * Component to render the focus hint.
+ */
+export const FocusHint = ({ shouldShowFocusHint, isThisShellFocused }) => {
+    if (!shouldShowFocusHint) {
+        return null;
+    }
+    return (_jsx(Box, { marginLeft: 1, flexShrink: 0, children: _jsx(Text, { color: isThisShellFocused ? theme.ui.focus : theme.ui.active, children: isThisShellFocused
+                ? `(${formatCommand(Command.UNFOCUS_SHELL_INPUT)} to unfocus)`
+                : `(${formatCommand(Command.FOCUS_SHELL_INPUT)} to focus)` }) }));
+};
+export const ToolStatusIndicator = ({ status: coreStatus, name, isFocused, }) => {
+    const status = mapCoreStatusToDisplayStatus(coreStatus);
+    const isShell = isShellTool(name);
+    const statusColor = isFocused
+        ? theme.ui.focus
+        : isShell
+            ? theme.ui.active
+            : theme.status.warning;
+    return (_jsxs(Box, { minWidth: STATUS_INDICATOR_WIDTH, children: [status === ToolCallStatus.Pending && (_jsx(Text, { color: theme.status.success, children: TOOL_STATUS.PENDING })), status === ToolCallStatus.Executing && (_jsx(Text, { color: statusColor, children: _jsx(CliSpinner, { type: "toggle" }) })), status === ToolCallStatus.Success && (_jsx(Text, { color: theme.status.success, "aria-label": 'Success:', children: TOOL_STATUS.SUCCESS })), status === ToolCallStatus.Confirming && (_jsx(Text, { color: statusColor, "aria-label": 'Confirming:', children: TOOL_STATUS.CONFIRMING })), status === ToolCallStatus.Canceled && (_jsx(Text, { color: statusColor, "aria-label": 'Canceled:', bold: true, children: TOOL_STATUS.CANCELED })), status === ToolCallStatus.Error && (_jsx(Text, { color: theme.status.error, "aria-label": 'Error:', bold: true, children: TOOL_STATUS.ERROR }))] }));
+};
+export const ToolInfo = ({ name, description, status: coreStatus, emphasis, progressMessage: _progressMessage, originalRequestName, isExpanded = false, }) => {
+    const status = mapCoreStatusToDisplayStatus(coreStatus);
+    const nameColor = React.useMemo(() => {
+        switch (emphasis) {
+            case 'high':
+                return theme.text.primary;
+            case 'medium':
+                return theme.text.primary;
+            case 'low':
+                return theme.text.secondary;
+            default: {
+                const exhaustiveCheck = emphasis;
+                return exhaustiveCheck;
+            }
+        }
+    }, [emphasis]);
+    // Hide description for completed Ask User tools (the result display speaks for itself)
+    const isCompletedAskUser = isCompletedAskUserTool(name, status);
+    return (_jsx(Box, { overflow: "hidden", height: isExpanded ? undefined : 1, flexGrow: 1, flexShrink: 1, children: _jsxs(Text, { strikethrough: status === ToolCallStatus.Canceled, wrap: isExpanded ? 'wrap' : 'truncate', children: [_jsx(Text, { color: nameColor, bold: true, children: name }), originalRequestName && originalRequestName !== name && (_jsxs(Text, { color: theme.text.secondary, italic: true, children: [' ', "(redirection from ", originalRequestName, ")"] })), !isCompletedAskUser && (_jsxs(_Fragment, { children: [' ', _jsx(Text, { color: theme.text.secondary, children: description })] }))] }) }));
+};
+export const McpProgressIndicator = ({ progress, total, message, barWidth, }) => {
+    const percentage = total && total > 0
+        ? Math.min(100, Math.round((progress / total) * 100))
+        : null;
+    let rawFilled;
+    if (total && total > 0) {
+        rawFilled = Math.round((progress / total) * barWidth);
+    }
+    else {
+        rawFilled = Math.floor(progress) % (barWidth + 1);
+    }
+    const filled = Math.max(0, Math.min(Number.isFinite(rawFilled) ? rawFilled : 0, barWidth));
+    const empty = Math.max(0, barWidth - filled);
+    const progressBar = '\u2588'.repeat(filled) + '\u2591'.repeat(empty);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { children: _jsxs(Text, { color: theme.text.accent, children: [progressBar, " ", percentage !== null ? `${percentage}%` : `${progress}`] }) }), message && (_jsx(Text, { color: theme.text.secondary, wrap: "truncate", children: message }))] }));
+};
+export const TrailingIndicator = () => (_jsxs(Text, { color: theme.text.primary, wrap: "truncate", children: [' ', "\u2190"] }));

package/dist/ui/components/messages/TopicMessage.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useId, useRef, useCallback } from 'react';
+import { Box, Text } from 'ink';
+;
+import { UPDATE_TOPIC_TOOL_NAME, UPDATE_TOPIC_DISPLAY_NAME, TOPIC_PARAM_TITLE, TOPIC_PARAM_SUMMARY, TOPIC_PARAM_STRATEGIC_INTENT, } from '@google/gemini-cli-core';
+import { theme } from '../../semantic-colors.js';
+import { useOverflowActions } from '../../contexts/OverflowContext.js';
+import { useToolActions } from '../../contexts/ToolActionsContext.js';
+import { useMouseClick } from '../../hooks/useMouseClick.js';
+export const isTopicTool = (name) => name === UPDATE_TOPIC_TOOL_NAME || name === UPDATE_TOPIC_DISPLAY_NAME;
+export const TopicMessage = ({ callId, args, availableTerminalHeight, isExpandable = true, }) => {
+    const { isExpanded: isExpandedInContext, toggleExpansion } = useToolActions();
+    // Expansion is active if either:
+    // 1. The individual callId is expanded in the ToolActionsContext
+    // 2. The entire turn is expanded (Ctrl+O) which sets availableTerminalHeight to undefined
+    const isExpanded = (isExpandedInContext ? isExpandedInContext(callId) : false) ||
+        availableTerminalHeight === undefined;
+    const overflowActions = useOverflowActions();
+    const uniqueId = useId();
+    const overflowId = `topic-${uniqueId}`;
+    const containerRef = useRef(null);
+    const rawTitle = args?.[TOPIC_PARAM_TITLE];
+    const title = typeof rawTitle === 'string' ? rawTitle : undefined;
+    const rawStrategicIntent = args?.[TOPIC_PARAM_STRATEGIC_INTENT];
+    const strategicIntent = typeof rawStrategicIntent === 'string' ? rawStrategicIntent : undefined;
+    const rawSummary = args?.[TOPIC_PARAM_SUMMARY];
+    const summary = typeof rawSummary === 'string' ? rawSummary : undefined;
+    // Top line intent: prefer strategic_intent, fallback to summary
+    const intent = strategicIntent || summary;
+    // Extra summary: only if both exist and are different (or just summary if we want to show it below)
+    const hasExtraSummary = !!(strategicIntent &&
+        summary &&
+        strategicIntent !== summary);
+    const handleToggle = useCallback(() => {
+        if (toggleExpansion && hasExtraSummary) {
+            toggleExpansion(callId);
+        }
+    }, [toggleExpansion, hasExtraSummary, callId]);
+    useMouseClick(containerRef, handleToggle, {
+        isActive: isExpandable && hasExtraSummary,
+    });
+    useEffect(() => {
+        // Only register if there is more content (summary) and it's currently hidden
+        const hasHiddenContent = isExpandable && hasExtraSummary && !isExpanded;
+        if (hasHiddenContent && overflowActions) {
+            overflowActions.addOverflowingId(overflowId);
+        }
+        else if (overflowActions) {
+            overflowActions.removeOverflowingId(overflowId);
+        }
+        return () => {
+            overflowActions?.removeOverflowingId(overflowId);
+        };
+    }, [isExpandable, hasExtraSummary, isExpanded, overflowActions, overflowId]);
+    return (_jsxs(Box, { ref: containerRef, flexDirection: "column", marginLeft: 2, children: [_jsxs(Box, { flexDirection: "row", flexWrap: "wrap", children: [_jsxs(Text, { color: theme.text.primary, bold: true, wrap: "truncate-end", children: [title || 'Topic', intent && _jsx(Text, { children: ": " })] }), intent && (_jsx(Text, { color: theme.text.secondary, wrap: "wrap", children: intent }))] }), isExpanded && hasExtraSummary && summary && (_jsx(Box, { marginTop: 1, marginLeft: 0, children: _jsx(Text, { color: theme.text.secondary, wrap: "wrap", children: summary }) }))] }));
+};