@quantum-ai/gemini-cli 0.45.8 → 0.45.9

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

@@ -0,0 +1,270 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { Box, Text } from 'ink';
+;
+import { colorizeCode, colorizeLine } from '../../utils/CodeColorizer.js';
+import { MaxSizedBox } from '../shared/MaxSizedBox.js';
+import { theme as semanticTheme } from '../../semantic-colors.js';
+import { useSettings } from '../../contexts/SettingsContext.js';
+import { getFileExtension } from '../../utils/fileUtils.js';
+export function parseDiffWithLineNumbers(diffContent) {
+    const lines = diffContent.split(/\r?\n/);
+    const result = [];
+    let currentOldLine = 0;
+    let currentNewLine = 0;
+    let inHunk = false;
+    const hunkHeaderRegex = /^@@ -(\d+),?\d* \+(\d+),?\d* @@/;
+    for (const line of lines) {
+        const hunkMatch = line.match(hunkHeaderRegex);
+        if (hunkMatch) {
+            currentOldLine = parseInt(hunkMatch[1], 10);
+            currentOldLine = parseInt(hunkMatch[1], 10);
+            currentNewLine = parseInt(hunkMatch[2], 10);
+            inHunk = true;
+            result.push({ type: 'hunk', content: line });
+            // We need to adjust the starting point because the first line number applies to the *first* actual line change/context,
+            // but we increment *before* pushing that line. So decrement here.
+            currentOldLine--;
+            currentNewLine--;
+            continue;
+        }
+        if (!inHunk) {
+            // Skip standard Git header lines more robustly
+            if (line.startsWith('--- ')) {
+                continue;
+            }
+            // If it's not a hunk or header, skip (or handle as 'other' if needed)
+            continue;
+        }
+        if (line.startsWith('+')) {
+            currentNewLine++; // Increment before pushing
+            result.push({
+                type: 'add',
+                newLine: currentNewLine,
+                content: line.substring(1),
+            });
+        }
+        else if (line.startsWith('-')) {
+            currentOldLine++; // Increment before pushing
+            result.push({
+                type: 'del',
+                oldLine: currentOldLine,
+                content: line.substring(1),
+            });
+        }
+        else if (line.startsWith(' ')) {
+            currentOldLine++; // Increment before pushing
+            currentNewLine++;
+            result.push({
+                type: 'context',
+                oldLine: currentOldLine,
+                newLine: currentNewLine,
+                content: line.substring(1),
+            });
+        }
+        else if (line.startsWith('\\')) {
+            // Handle ""
+            result.push({ type: 'other', content: line });
+        }
+    }
+    return result;
+}
+const DEFAULT_TAB_WIDTH = 4; // Spaces per tab for normalization
+export const DiffRenderer = ({ diffContent, filename, tabWidth = DEFAULT_TAB_WIDTH, availableTerminalHeight, terminalWidth, theme, disableColor = false, paddingX = 0, }) => {
+    const settings = useSettings();
+    const screenReaderEnabled = false; // Ink v4
+    const parsedLines = useMemo(() => {
+        if (!diffContent || typeof diffContent !== 'string') {
+            return [];
+        }
+        return parseDiffWithLineNumbers(diffContent);
+    }, [diffContent]);
+    const isNewFileResult = useMemo(() => isNewFile(parsedLines), [parsedLines]);
+    const renderedOutput = useMemo(() => {
+        if (!diffContent || typeof diffContent !== 'string') {
+            return _jsx(Text, { color: semanticTheme.status.warning, children: "No diff content." });
+        }
+        if (parsedLines.length === 0) {
+            return (_jsx(Box, { padding: 1, children: _jsx(Text, { dimColor: true, children: "No changes detected." }) }));
+        }
+        if (screenReaderEnabled) {
+            return (_jsx(Box, { flexDirection: "column", children: parsedLines.map((line, index) => (_jsxs(Text, { children: [line.type, ": ", line.content] }, index))) }));
+        }
+        if (isNewFileResult) {
+            // Extract only the added lines' content
+            const addedContent = parsedLines
+                .filter((line) => line.type === 'add')
+                .map((line) => line.content)
+                .join('\n');
+            // Attempt to infer language from filename, default to plain text if no filename
+            const fileExtension = getFileExtension(filename);
+            const language = fileExtension
+                ? getLanguageFromExtension(fileExtension)
+                : null;
+            return colorizeCode({
+                code: addedContent,
+                language,
+                availableHeight: availableTerminalHeight,
+                maxWidth: terminalWidth,
+                theme,
+                settings,
+                disableColor,
+                paddingX,
+            });
+        }
+        else {
+            const key = filename ? `diff-box-${filename}` : undefined;
+            return (_jsx(MaxSizedBox, { paddingX: paddingX, maxHeight: availableTerminalHeight, maxWidth: terminalWidth, children: renderDiffLines({
+                    parsedLines,
+                    filename,
+                    tabWidth,
+                    terminalWidth,
+                    disableColor,
+                }) }, key));
+        }
+    }, [
+        diffContent,
+        parsedLines,
+        screenReaderEnabled,
+        isNewFileResult,
+        filename,
+        availableTerminalHeight,
+        terminalWidth,
+        theme,
+        settings,
+        tabWidth,
+        disableColor,
+        paddingX,
+    ]);
+    return renderedOutput;
+};
+export const isNewFile = (parsedLines) => {
+    if (parsedLines.length === 0)
+        return false;
+    return parsedLines.every((line) => line.type === 'add' ||
+        line.type === 'hunk' ||
+        line.type === 'other' ||
+        line.content.startsWith('diff --git') ||
+        line.content.startsWith('new file mode'));
+};
+export const renderDiffLines = ({ parsedLines, filename, tabWidth = DEFAULT_TAB_WIDTH, terminalWidth, disableColor = false, }) => {
+    // 1. Normalize whitespace (replace tabs with spaces) *before* further processing
+    const normalizedLines = parsedLines.map((line) => ({
+        ...line,
+        content: line.content.replace(/\t/g, ' '.repeat(tabWidth)),
+    }));
+    // Filter out non-displayable lines (hunks, potentially 'other') using the normalized list
+    const displayableLines = normalizedLines.filter((l) => l.type !== 'hunk' && l.type !== 'other');
+    if (displayableLines.length === 0) {
+        return [
+            _jsx(Box, { padding: 1, children: _jsx(Text, { dimColor: true, children: "No changes detected." }) }, "no-changes"),
+        ];
+    }
+    const maxLineNumber = Math.max(0, ...displayableLines.map((l) => l.oldLine ?? 0), ...displayableLines.map((l) => l.newLine ?? 0));
+    const gutterWidth = Math.max(1, maxLineNumber.toString().length);
+    const fileExtension = getFileExtension(filename);
+    const language = fileExtension
+        ? getLanguageFromExtension(fileExtension)
+        : null;
+    // Calculate the minimum indentation across all displayable lines
+    let baseIndentation = Infinity; // Start high to find the minimum
+    for (const line of displayableLines) {
+        // Only consider lines with actual content for indentation calculation
+        if (line.content.trim() === '')
+            continue;
+        const firstCharIndex = line.content.search(/\S/); // Find index of first non-whitespace char
+        const currentIndent = firstCharIndex === -1 ? 0 : firstCharIndex; // Indent is 0 if no non-whitespace found
+        baseIndentation = Math.min(baseIndentation, currentIndent);
+    }
+    // If baseIndentation remained Infinity (e.g., no displayable lines with content), default to 0
+    if (!isFinite(baseIndentation)) {
+        baseIndentation = 0;
+    }
+    let lastLineNumber = null;
+    const MAX_CONTEXT_LINES_WITHOUT_GAP = 5;
+    const content = displayableLines.reduce((acc, line, index) => {
+        // Determine the relevant line number for gap calculation based on type
+        let relevantLineNumberForGapCalc = null;
+        if (line.type === 'add' || line.type === 'context') {
+            relevantLineNumberForGapCalc = line.newLine ?? null;
+        }
+        else if (line.type === 'del') {
+            // For deletions, the gap is typically in relation to the original file's line numbering
+            relevantLineNumberForGapCalc = line.oldLine ?? null;
+        }
+        if (lastLineNumber !== null &&
+            relevantLineNumberForGapCalc !== null &&
+            relevantLineNumberForGapCalc >
+                lastLineNumber + MAX_CONTEXT_LINES_WITHOUT_GAP + 1) {
+            acc.push(_jsx(Box, { children: _jsx(Box, { borderStyle: "double", borderLeft: false, borderRight: false, borderBottom: false, width: terminalWidth, borderColor: semanticTheme.text.secondary }) }, `gap-${index}`));
+        }
+        const lineKey = `diff-line-${index}`;
+        let gutterNumStr = '';
+        let prefixSymbol = ' ';
+        switch (line.type) {
+            case 'add':
+                gutterNumStr = (line.newLine ?? '').toString();
+                prefixSymbol = '+';
+                lastLineNumber = line.newLine ?? null;
+                break;
+            case 'del':
+                gutterNumStr = (line.oldLine ?? '').toString();
+                prefixSymbol = '-';
+                // For deletions, update lastLineNumber based on oldLine if it's advancing.
+                // This helps manage gaps correctly if there are multiple consecutive deletions
+                // or if a deletion is followed by a context line far away in the original file.
+                if (line.oldLine !== undefined) {
+                    lastLineNumber = line.oldLine;
+                }
+                break;
+            case 'context':
+                gutterNumStr = (line.newLine ?? '').toString();
+                prefixSymbol = ' ';
+                lastLineNumber = line.newLine ?? null;
+                break;
+            default:
+                return acc;
+        }
+        const displayContent = line.content.substring(baseIndentation);
+        const backgroundColor = disableColor
+            ? undefined
+            : line.type === 'add'
+                ? semanticTheme.background.diff.added
+                : line.type === 'del'
+                    ? semanticTheme.background.diff.removed
+                    : undefined;
+        const gutterColor = disableColor
+            ? undefined
+            : semanticTheme.text.secondary;
+        const symbolColor = disableColor
+            ? undefined
+            : line.type === 'add'
+                ? semanticTheme.status.success
+                : line.type === 'del'
+                    ? semanticTheme.status.error
+                    : undefined;
+        acc.push(_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: gutterWidth + 1, paddingRight: 1, flexShrink: 0, backgroundColor: backgroundColor, justifyContent: "flex-end", children: _jsx(Text, { color: gutterColor, children: gutterNumStr }) }), line.type === 'context' ? (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [prefixSymbol, " "] }), _jsx(Text, { wrap: "wrap", children: colorizeLine(displayContent, language, undefined, disableColor) })] })) : (_jsxs(Text, { backgroundColor: backgroundColor, wrap: "wrap", children: [_jsx(Text, { color: symbolColor, children: prefixSymbol }), ' ', colorizeLine(displayContent, language, undefined, disableColor)] }))] }, lineKey));
+        return acc;
+    }, []);
+    return content;
+};
+const getLanguageFromExtension = (extension) => {
+    const languageMap = {
+        js: 'javascript',
+        ts: 'typescript',
+        py: 'python',
+        json: 'json',
+        css: 'css',
+        html: 'html',
+        sh: 'bash',
+        md: 'markdown',
+        yaml: 'yaml',
+        yml: 'yaml',
+        txt: 'plaintext',
+        java: 'java',
+        c: 'c',
+        cpp: 'cpp',
+        rb: 'ruby',
+    };
+    return languageMap[extension] || null; // Return null if extension not found
+};

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

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, Box } from 'ink';
+;
+import { theme } from '../../semantic-colors.js';
+export const ErrorMessage = ({ text }) => {
+    const prefix = '✕ ';
+    const prefixWidth = prefix.length;
+    return (_jsxs(Box, { flexDirection: "row", marginBottom: 1, children: [_jsx(Box, { width: prefixWidth, children: _jsx(Text, { color: theme.status.error, children: prefix }) }), _jsx(Box, { flexGrow: 1, children: _jsx(Text, { wrap: "wrap", color: theme.status.error, children: text }) })] }));
+};

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

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+;
+import { CliSpinner } from '../CliSpinner.js';
+import { theme } from '../../semantic-colors.js';
+/*
+ * Export session messages appear when the /export-session command is run, and show a loading spinner
+ * while export is in progress, followed by a success message.
+ */
+export function ExportSessionMessage({ exportSession, }) {
+    const { isPending, targetPath } = exportSession;
+    return (_jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(Box, { marginRight: 1, children: isPending ? (_jsx(CliSpinner, { type: "dots" })) : (_jsx(Text, { color: theme.status.success, children: "\u2713" })) }), _jsx(Box, { children: _jsx(Text, { color: isPending ? theme.text.accent : theme.status.success, children: isPending
+                        ? 'Exporting session...'
+                        : `Successfully exported session to ${targetPath}` }) })] }));
+}

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

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, Box } from 'ink';
+;
+import { MarkdownDisplay } from '../../utils/MarkdownDisplay.js';
+import { theme } from '../../semantic-colors.js';
+import { SCREEN_READER_MODEL_PREFIX } from '../../textConstants.js';
+import { useUIState } from '../../contexts/UIStateContext.js';
+export const GeminiMessage = ({ text, isPending, availableTerminalHeight, terminalWidth, }) => {
+    const { renderMarkdown } = useUIState();
+    const prefix = '✦ ';
+    const prefixWidth = prefix.length;
+    return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: prefixWidth, children: _jsx(Text, { color: theme.text.accent, "aria-label": SCREEN_READER_MODEL_PREFIX, children: prefix }) }), _jsx(Box, { flexGrow: 1, flexDirection: "column", children: _jsx(MarkdownDisplay, { text: text, isPending: isPending, availableTerminalHeight: availableTerminalHeight === undefined
+                        ? undefined
+                        : Math.max(availableTerminalHeight - 1, 1), terminalWidth: Math.max(terminalWidth - prefixWidth, 0), renderMarkdown: renderMarkdown }) })] }));
+};

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

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from 'ink';
+;
+import { MarkdownDisplay } from '../../utils/MarkdownDisplay.js';
+import { useUIState } from '../../contexts/UIStateContext.js';
+/*
+ * Gemini message content is a semi-hacked component. The intention is to represent a partial
+ * of GeminiMessage and is only used when a response gets too long. In that instance messages
+ * are split into multiple GeminiMessageContent's to enable the root <Static> component in
+ * App.tsx to be as performant as humanly possible.
+ */
+export const GeminiMessageContent = ({ text, isPending, availableTerminalHeight, terminalWidth, }) => {
+    const { renderMarkdown } = useUIState();
+    const originalPrefix = '✦ ';
+    const prefixWidth = originalPrefix.length;
+    return (_jsx(Box, { flexDirection: "column", paddingLeft: prefixWidth, children: _jsx(MarkdownDisplay, { text: text, isPending: isPending, availableTerminalHeight: availableTerminalHeight === undefined
+                ? undefined
+                : Math.max(availableTerminalHeight - 1, 1), terminalWidth: Math.max(terminalWidth - prefixWidth, 0), renderMarkdown: renderMarkdown }) }));
+};

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

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, Box } from 'ink';
+;
+import { theme } from '../../semantic-colors.js';
+import { SCREEN_READER_USER_PREFIX } from '../../textConstants.js';
+import { HalfLinePaddedBox } from '../shared/HalfLinePaddedBox.js';
+import { useConfig } from '../../contexts/ConfigContext.js';
+export const HintMessage = ({ text }) => {
+    const prefix = '💡 ';
+    const prefixWidth = prefix.length;
+    const config = useConfig();
+    const useBackgroundColorSetting = config.getUseBackgroundColor();
+    const useBackgroundColor = useBackgroundColorSetting && !!theme.background.message;
+    return (_jsx(HalfLinePaddedBox, { backgroundBaseColor: theme.text.accent, backgroundOpacity: 0.1, useBackgroundColor: useBackgroundColor, children: _jsxs(Box, { flexDirection: "row", paddingY: 0, marginY: useBackgroundColor ? 0 : 1, paddingX: useBackgroundColor ? 1 : 0, alignSelf: "flex-start", children: [_jsx(Box, { width: prefixWidth, flexShrink: 0, children: _jsx(Text, { color: theme.text.accent, "aria-label": SCREEN_READER_USER_PREFIX, children: prefix }) }), _jsx(Box, { flexGrow: 1, children: _jsx(Text, { wrap: "wrap", italic: true, color: theme.text.accent, children: `Steering Hint: ${text}` }) })] }) }));
+};

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

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, Box } from 'ink';
+;
+import { theme } from '../../semantic-colors.js';
+import { RenderInline } from '../../utils/InlineMarkdownRenderer.js';
+export const InfoMessage = ({ text, secondaryText, source, icon, color, marginBottom, }) => {
+    color ??= theme.status.warning;
+    const prefix = icon ?? 'ℹ ';
+    const prefixWidth = prefix.length;
+    return (_jsxs(Box, { flexDirection: "row", marginTop: 1, marginBottom: marginBottom ?? 0, children: [_jsx(Box, { width: prefixWidth, children: _jsx(Text, { color: color, children: prefix }) }), _jsx(Box, { flexGrow: 1, flexDirection: "column", children: text.split('\n').map((line, index) => (_jsxs(Text, { wrap: "wrap", children: [_jsx(RenderInline, { text: line, defaultColor: color }), index === text.split('\n').length - 1 && secondaryText && (_jsxs(Text, { color: theme.text.secondary, children: [" ", secondaryText] })), index === text.split('\n').length - 1 && source && (_jsxs(Text, { color: theme.text.secondary, children: [" [", source, "]"] }))] }, index))) })] }));
+};

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

@@ -0,0 +1,6 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Text, Box } from 'ink';
+;
+import { theme } from '../../semantic-colors.js';
+import { getDisplayString } from '@google/gemini-cli-core';
+export const ModelMessage = ({ model }) => (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: theme.ui.comment, italic: true, children: ["Responding with ", getDisplayString(model)] }) }));

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

@@ -0,0 +1,84 @@
+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 from 'react';
+import { Box } from 'ink';
+;
+import { ShellInputPrompt } from '../ShellInputPrompt.js';
+import { StickyHeader } from '../StickyHeader.js';
+import { useUIActions } from '../../contexts/UIActionsContext.js';
+import { useMouseClick } from '../../hooks/useMouseClick.js';
+import { ToolResultDisplay } from './ToolResultDisplay.js';
+import { ToolStatusIndicator, ToolInfo, TrailingIndicator, isThisShellFocusable as checkIsShellFocusable, isThisShellFocused as checkIsShellFocused, useFocusHint, FocusHint, } from './ToolShared.js';
+import { ACTIVE_SHELL_MAX_LINES } from '../../constants.js';
+import { useAlternateBuffer } from '../../hooks/useAlternateBuffer.js';
+import { useUIState } from '../../contexts/UIStateContext.js';
+import { useToolActions } from '../../contexts/ToolActionsContext.js';
+import { ShellExecutionService, CoreToolCallStatus, } from '@google/gemini-cli-core';
+import { calculateShellMaxLines, calculateToolContentMaxLines, SHELL_CONTENT_OVERHEAD, } from '../../utils/toolLayoutUtils.js';
+export const ShellToolMessage = ({ callId, name, description, resultDisplay, status, availableTerminalHeight, terminalWidth, emphasis = 'medium', renderOutputAsMarkdown = true, ptyId, config, isFirst, borderColor, borderDimColor, isExpandable, originalRequestName, }) => {
+    const { isExpanded: isExpandedInContext } = useToolActions();
+    const isExpanded = (isExpandedInContext ? isExpandedInContext(callId) : false) ||
+        availableTerminalHeight === undefined;
+    const { activePtyId: activeShellPtyId, embeddedShellFocused, constrainHeight, } = useUIState();
+    const isAlternateBuffer = useAlternateBuffer();
+    const isThisShellFocused = checkIsShellFocused(name, status, ptyId, activeShellPtyId, embeddedShellFocused);
+    const maxLines = calculateShellMaxLines({
+        status,
+        isAlternateBuffer,
+        isThisShellFocused,
+        availableTerminalHeight,
+        constrainHeight,
+        isExpandable,
+    });
+    const availableHeight = calculateToolContentMaxLines({
+        availableTerminalHeight,
+        isAlternateBuffer,
+        maxLinesLimit: maxLines,
+    });
+    React.useEffect(() => {
+        const isExecuting = status === CoreToolCallStatus.Executing;
+        if (isExecuting && ptyId) {
+            try {
+                const childWidth = terminalWidth - 4; // account for padding and borders
+                const finalHeight = availableHeight ?? ACTIVE_SHELL_MAX_LINES - SHELL_CONTENT_OVERHEAD;
+                ShellExecutionService.resizePty(ptyId, Math.max(1, childWidth), Math.max(1, finalHeight));
+            }
+            catch (e) {
+                if (!(e instanceof Error &&
+                    e.message.includes('Cannot resize a pty that has already exited'))) {
+                    throw e;
+                }
+            }
+        }
+    }, [ptyId, status, terminalWidth, availableHeight]);
+    const { setEmbeddedShellFocused } = useUIActions();
+    const wasFocusedRef = React.useRef(false);
+    React.useEffect(() => {
+        if (isThisShellFocused) {
+            wasFocusedRef.current = true;
+        }
+        else if (wasFocusedRef.current) {
+            if (embeddedShellFocused) {
+                setEmbeddedShellFocused(false);
+            }
+            wasFocusedRef.current = false;
+        }
+    }, [isThisShellFocused, embeddedShellFocused, setEmbeddedShellFocused]);
+    const headerRef = React.useRef(null);
+    const contentRef = React.useRef(null);
+    // The shell is focusable if it's the shell command, it's executing, and the interactive shell is enabled.
+    const isThisShellFocusable = checkIsShellFocusable(name, status, config);
+    const handleFocus = () => {
+        if (isThisShellFocusable) {
+            setEmbeddedShellFocused(true);
+        }
+    };
+    useMouseClick(headerRef, handleFocus, { isActive: !!isThisShellFocusable });
+    useMouseClick(contentRef, handleFocus, { isActive: !!isThisShellFocusable });
+    const { shouldShowFocusHint } = useFocusHint(isThisShellFocusable, isThisShellFocused, resultDisplay);
+    return (_jsxs(_Fragment, { children: [_jsxs(StickyHeader, { width: terminalWidth, isFirst: isFirst, borderColor: borderColor, borderDimColor: borderDimColor, containerRef: headerRef, children: [_jsx(ToolStatusIndicator, { status: status, name: name, isFocused: isThisShellFocused }), _jsx(ToolInfo, { name: name, status: status, description: description, emphasis: emphasis, originalRequestName: originalRequestName, isExpanded: isExpanded }), _jsx(FocusHint, { shouldShowFocusHint: shouldShowFocusHint, isThisShellFocused: isThisShellFocused }), emphasis === 'high' && _jsx(TrailingIndicator, {})] }), _jsxs(Box, { ref: contentRef, width: terminalWidth, borderStyle: "round", borderColor: borderColor, borderDimColor: borderDimColor, borderTop: false, borderBottom: false, borderLeft: true, borderRight: true, paddingX: 1, flexDirection: "column", children: [_jsx(ToolResultDisplay, { resultDisplay: resultDisplay, availableTerminalHeight: availableTerminalHeight, terminalWidth: terminalWidth, renderOutputAsMarkdown: renderOutputAsMarkdown, hasFocus: isThisShellFocused, maxLines: maxLines }), isThisShellFocused && config && (_jsx(ShellInputPrompt, { activeShellPtyId: activeShellPtyId ?? null, focus: embeddedShellFocused, scrollPageSize: availableTerminalHeight ?? ACTIVE_SHELL_MAX_LINES }))] })] }));
+};

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

@@ -0,0 +1,139 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useId } from 'react';
+import { Box, Text } from 'ink';
+;
+import { theme } from '../../semantic-colors.js';
+import { isSubagentProgress, checkExhaustive, SubagentState, } from '@google/gemini-cli-core';
+import { SubagentProgressDisplay, formatToolArgs, } from './SubagentProgressDisplay.js';
+import { useOverflowActions } from '../../contexts/OverflowContext.js';
+export const SubagentGroupDisplay = ({ toolCalls, availableTerminalHeight, terminalWidth, borderColor, borderDimColor, isFirst, isExpandable = true, }) => {
+    const isExpanded = availableTerminalHeight === undefined;
+    const overflowActions = useOverflowActions();
+    const uniqueId = useId();
+    const overflowId = `subagent-${uniqueId}`;
+    useEffect(() => {
+        if (isExpandable && overflowActions) {
+            // Register with the global overflow system so "ctrl+o to expand" shows in the sticky footer
+            // and AppContainer passes the shortcut through.
+            overflowActions.addOverflowingId(overflowId);
+        }
+        return () => {
+            if (overflowActions) {
+                overflowActions.removeOverflowingId(overflowId);
+            }
+        };
+    }, [isExpandable, overflowActions, overflowId]);
+    if (toolCalls.length === 0) {
+        return null;
+    }
+    let headerText = '';
+    if (toolCalls.length === 1) {
+        const singleAgent = toolCalls[0].resultDisplay;
+        if (isSubagentProgress(singleAgent)) {
+            switch (singleAgent.state) {
+                case SubagentState.COMPLETED:
+                    headerText = 'Agent Completed';
+                    break;
+                case SubagentState.CANCELLED:
+                    headerText = 'Agent Cancelled';
+                    break;
+                case SubagentState.ERROR:
+                    headerText = 'Agent Error';
+                    break;
+                default:
+                    headerText = 'Running Agent...';
+                    break;
+            }
+        }
+        else {
+            headerText = 'Running Agent...';
+        }
+    }
+    else {
+        let completedCount = 0;
+        let runningCount = 0;
+        for (const tc of toolCalls) {
+            const progress = tc.resultDisplay;
+            if (isSubagentProgress(progress)) {
+                if (progress.state === SubagentState.COMPLETED)
+                    completedCount++;
+                else if (progress.state === SubagentState.RUNNING)
+                    runningCount++;
+            }
+            else {
+                // It hasn't emitted progress yet, but it is "running"
+                runningCount++;
+            }
+        }
+        if (completedCount === toolCalls.length) {
+            headerText = `${toolCalls.length} Agents Completed`;
+        }
+        else if (completedCount > 0) {
+            headerText = `${toolCalls.length} Agents (${runningCount} running, ${completedCount} completed)...`;
+        }
+        else {
+            headerText = `Running ${toolCalls.length} Agents...`;
+        }
+    }
+    const toggleText = `(ctrl+o to ${isExpanded ? 'collapse' : 'expand'})`;
+    const renderCollapsedRow = (key, agentName, icon, content, displayArgs) => (_jsxs(Box, { flexDirection: "row", marginLeft: 0, marginTop: 0, children: [_jsx(Box, { minWidth: 2, flexShrink: 0, children: icon }), _jsx(Box, { flexShrink: 0, children: _jsx(Text, { bold: true, color: theme.text.primary, wrap: "truncate", children: agentName }) }), _jsx(Box, { flexShrink: 0, children: _jsx(Text, { color: theme.text.secondary, children: " \u00B7 " }) }), _jsx(Box, { flexShrink: 1, minWidth: 0, children: _jsxs(Text, { color: theme.text.secondary, wrap: "truncate", children: [content, displayArgs && ` ${displayArgs}`] }) })] }, key));
+    return (_jsxs(Box, { flexDirection: "column", width: terminalWidth, borderLeft: true, borderRight: true, borderTop: isFirst, borderBottom: false, borderColor: borderColor, borderDimColor: borderDimColor, borderStyle: "round", paddingLeft: 1, paddingTop: 0, paddingBottom: 0, children: [_jsxs(Box, { flexDirection: "row", gap: 1, marginBottom: isExpanded ? 1 : 0, children: [_jsx(Text, { color: theme.text.secondary, children: "\u2261" }), _jsx(Text, { bold: true, color: theme.text.primary, children: headerText }), isExpandable && _jsx(Text, { color: theme.text.secondary, children: toggleText })] }), toolCalls.map((toolCall) => {
+                const progress = toolCall.resultDisplay;
+                if (!isSubagentProgress(progress)) {
+                    const agentName = toolCall.name || 'agent';
+                    if (!isExpanded) {
+                        return renderCollapsedRow(toolCall.callId, agentName, _jsx(Text, { color: theme.text.primary, children: "!" }), 'Starting...');
+                    }
+                    else {
+                        return (_jsxs(Box, { flexDirection: "column", marginLeft: 0, marginBottom: 1, children: [_jsxs(Box, { flexDirection: "row", gap: 1, children: [_jsx(Text, { color: theme.text.primary, children: "!" }), _jsx(Text, { bold: true, color: theme.text.primary, children: agentName })] }), _jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: theme.text.secondary, children: "Starting..." }) })] }, toolCall.callId));
+                    }
+                }
+                const history = toolCall.subagentHistory ?? progress.recentActivity;
+                const lastActivity = history[history.length - 1];
+                // Collapsed View: Show single compact line per agent
+                if (!isExpanded) {
+                    let content = 'Starting...';
+                    let formattedArgs;
+                    if (progress.state === SubagentState.COMPLETED) {
+                        if (progress.terminateReason &&
+                            progress.terminateReason !== 'GOAL') {
+                            content = `Finished Early (${progress.terminateReason})`;
+                        }
+                        else {
+                            content = 'Completed successfully';
+                        }
+                    }
+                    else if (lastActivity) {
+                        // Match expanded view logic exactly:
+                        // Primary text: displayName || content
+                        content = lastActivity.displayName || lastActivity.content;
+                        // Secondary text: description || formatToolArgs(args)
+                        if (lastActivity.description) {
+                            formattedArgs = lastActivity.description;
+                        }
+                        else if (lastActivity.type === 'tool_call' && lastActivity.args) {
+                            formattedArgs = formatToolArgs(lastActivity.args);
+                        }
+                    }
+                    const displayArgs = progress.state === SubagentState.COMPLETED ? '' : formattedArgs;
+                    const renderStatusIcon = () => {
+                        const state = progress.state ?? SubagentState.RUNNING;
+                        switch (state) {
+                            case SubagentState.RUNNING:
+                                return _jsx(Text, { color: theme.text.primary, children: "!" });
+                            case SubagentState.COMPLETED:
+                                return _jsx(Text, { color: theme.status.success, children: "\u2713" });
+                            case SubagentState.CANCELLED:
+                                return _jsx(Text, { color: theme.status.warning, children: "\u2139" });
+                            case SubagentState.ERROR:
+                                return _jsx(Text, { color: theme.status.error, children: "\u2717" });
+                            default:
+                                return checkExhaustive(state);
+                        }
+                    };
+                    return renderCollapsedRow(toolCall.callId, progress.agentName, renderStatusIcon(), lastActivity?.type === 'thought' ? `💭 ${content}` : content, displayArgs);
+                }
+                // Expanded View: Render full history
+                return (_jsx(Box, { flexDirection: "column", marginLeft: 0, marginBottom: 1, children: _jsx(SubagentProgressDisplay, { progress: progress, terminalWidth: terminalWidth, historyOverrides: toolCall.subagentHistory }) }, toolCall.callId));
+            })] }));
+};

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

@@ -0,0 +1,4 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+;
+export const SubagentHistoryMessage = ({ item, terminalWidth, }) => (_jsxs(Box, { flexDirection: "column", width: terminalWidth, marginBottom: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "cyan", children: ["\uD83E\uDD16 ", item.agentName, " Trace (", item.history.length, " items)"] }) }), item.history.map((activity) => (_jsx(Box, { marginLeft: 2, marginBottom: 0, children: _jsxs(Text, { color: activity.type === 'thought' ? 'gray' : 'white', children: [activity.type === 'thought' ? '🧠' : '🛠️', " ", activity.content, activity.status === 'running' && ' (Running...)', activity.status === 'completed' && ' ✅', activity.status === 'error' && ' ❌'] }) }, activity.id)))] }));