@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/ui/utils/CodeColorizer.js

@@ -0,0 +1,130 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import React from 'react';
+import { Text, Box } from 'ink';
+;
+import { common, createLowlight } from 'lowlight';
+import stripAnsi from 'strip-ansi';
+import { themeManager } from '../themes/theme-manager.js';
+import { MaxSizedBox, MINIMUM_MAX_HEIGHT, } from '../components/shared/MaxSizedBox.js';
+import { debugLogger } from '@google/gemini-cli-core';
+// Configure theming and parsing utilities.
+const lowlight = createLowlight(common);
+function renderHastNode(node, theme, inheritedColor) {
+    if (node.type === 'text') {
+        // Use the color passed down from parent element, or the theme's default.
+        const color = inheritedColor || theme.defaultColor;
+        return _jsx(Text, { color: color, children: node.value });
+    }
+    // Handle Element Nodes: Determine color and pass it down, don't wrap
+    if (node.type === 'element') {
+        const nodeClasses = 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        node.properties?.['className'] || [];
+        let elementColor = undefined;
+        // Find color defined specifically for this element's class
+        for (let i = nodeClasses.length - 1; i >= 0; i--) {
+            const color = theme.getInkColor(nodeClasses[i]);
+            if (color) {
+                elementColor = color;
+                break;
+            }
+        }
+        // Determine the color to pass down: Use this element's specific color
+        // if found; otherwise, continue passing down the already inherited color.
+        const colorToPassDown = elementColor || inheritedColor;
+        // Recursively render children, passing the determined color down
+        // Ensure child type matches expected HAST structure (ElementContent is common)
+        const children = node.children?.map((child, index) => (_jsx(React.Fragment, { children: renderHastNode(child, theme, colorToPassDown) }, index)));
+        // Element nodes now only group children; color is applied by Text nodes.
+        // Use a React Fragment to avoid adding unnecessary elements.
+        return _jsx(React.Fragment, { children: children });
+    }
+    // Handle Root Node: Start recursion with initially inherited color
+    if (node.type === 'root') {
+        // Check if children array is empty - this happens when lowlight can't detect language – fall back to plain text
+        if (!node.children || node.children.length === 0) {
+            return null;
+        }
+        // Pass down the initial inheritedColor (likely undefined from the top call)
+        // Ensure child type matches expected HAST structure (RootContent is common)
+        return node.children?.map((child, index) => (_jsx(React.Fragment, { children: renderHastNode(child, theme, inheritedColor) }, index)));
+    }
+    // Handle unknown or unsupported node types
+    return null;
+}
+function highlightAndRenderLine(line, language, theme) {
+    try {
+        const strippedLine = stripAnsi(line);
+        const getHighlightedLine = () => !language || !lowlight.registered(language)
+            ? lowlight.highlightAuto(strippedLine)
+            : lowlight.highlight(language, strippedLine);
+        const renderedNode = renderHastNode(getHighlightedLine(), theme, undefined);
+        return renderedNode !== null ? renderedNode : strippedLine;
+    }
+    catch {
+        return stripAnsi(line);
+    }
+}
+export function colorizeLine(line, language, theme, disableColor = false) {
+    if (disableColor) {
+        return _jsx(Text, { children: line });
+    }
+    const activeTheme = theme || themeManager.getActiveTheme();
+    return highlightAndRenderLine(line, language, activeTheme);
+}
+export function colorizeCode({ code, language = null, availableHeight, maxWidth, theme = null, settings, hideLineNumbers = false, disableColor = false, returnLines = false, paddingX = 0, }) {
+    const codeToHighlight = code.replace(/\n$/, '');
+    const activeTheme = theme || themeManager.getActiveTheme();
+    const showLineNumbers = hideLineNumbers
+        ? false
+        : settings.merged.ui.showLineNumbers;
+    // We force MaxSizedBox if availableHeight is provided, even if alternate buffer is enabled,
+    // because this might be rendered in a constrained UI box (like tool confirmation).
+    const useMaxSizedBox = (!settings.merged.ui.useAlternateBuffer || availableHeight !== undefined) &&
+        !returnLines;
+    let hiddenLinesCount = 0;
+    let finalLines = codeToHighlight.split(/\r?\n/);
+    try {
+        // Optimization to avoid highlighting lines that cannot possibly be displayed.
+        if (availableHeight !== undefined && useMaxSizedBox) {
+            availableHeight = Math.max(availableHeight, MINIMUM_MAX_HEIGHT);
+            if (finalLines.length > availableHeight) {
+                const sliceIndex = finalLines.length - availableHeight;
+                hiddenLinesCount = sliceIndex;
+                finalLines = finalLines.slice(sliceIndex);
+            }
+        }
+        const padWidth = String(finalLines.length + hiddenLinesCount).length;
+        const renderedLines = finalLines.map((line, index) => {
+            const contentToRender = disableColor
+                ? line
+                : highlightAndRenderLine(line, language, activeTheme);
+            return (_jsxs(Box, { minHeight: 1, children: [showLineNumbers && (_jsx(Box, { minWidth: padWidth + 1, flexShrink: 0, paddingRight: 1, alignItems: "flex-start", justifyContent: "flex-end", children: _jsx(Text, { color: disableColor ? undefined : activeTheme.colors.Gray, children: `${index + 1 + hiddenLinesCount}` }) })), _jsx(Text, { color: disableColor ? undefined : activeTheme.defaultColor, wrap: "wrap", children: contentToRender })] }, index));
+        });
+        if (returnLines) {
+            return renderedLines;
+        }
+        if (useMaxSizedBox) {
+            return (_jsx(MaxSizedBox, { paddingX: paddingX, maxHeight: availableHeight, maxWidth: maxWidth, additionalHiddenLinesCount: hiddenLinesCount, overflowDirection: "top", children: renderedLines }));
+        }
+        return (_jsx(Box, { flexDirection: "column", width: maxWidth, children: renderedLines }));
+    }
+    catch (error) {
+        debugLogger.warn(`[colorizeCode] Error highlighting code for language "${language}":`, error);
+        // Fall back to plain text with default color on error
+        const padWidth = String(finalLines.length + hiddenLinesCount).length;
+        const fallbackLines = finalLines.map((line, index) => (_jsxs(Box, { minHeight: 1, children: [showLineNumbers && (_jsx(Box, { minWidth: padWidth + 1, flexShrink: 0, paddingRight: 1, alignItems: "flex-start", justifyContent: "flex-end", children: _jsx(Text, { color: disableColor ? undefined : activeTheme.defaultColor, children: `${index + 1 + hiddenLinesCount}` }) })), _jsx(Text, { color: disableColor ? undefined : activeTheme.colors.Gray, children: stripAnsi(line) })] }, index)));
+        if (returnLines) {
+            return fallbackLines;
+        }
+        if (useMaxSizedBox) {
+            return (_jsx(MaxSizedBox, { paddingX: paddingX, maxHeight: availableHeight, maxWidth: maxWidth, additionalHiddenLinesCount: hiddenLinesCount, overflowDirection: "top", children: fallbackLines }));
+        }
+        return (_jsx(Box, { flexDirection: "column", width: maxWidth, children: fallbackLines }));
+    }
+}

package/dist/ui/utils/ConsolePatcher.js

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/* eslint-disable no-console */
+import util from 'node:util';
+export class ConsolePatcher {
+    originalConsoleLog = console.log;
+    originalConsoleWarn = console.warn;
+    originalConsoleError = console.error;
+    originalConsoleDebug = console.debug;
+    originalConsoleInfo = console.info;
+    params;
+    constructor(params) {
+        this.params = params;
+    }
+    patch() {
+        console.log = this.patchConsoleMethod('log');
+        console.warn = this.patchConsoleMethod('warn');
+        console.error = this.patchConsoleMethod('error');
+        console.debug = this.patchConsoleMethod('debug');
+        console.info = this.patchConsoleMethod('info');
+    }
+    cleanup = () => {
+        console.log = this.originalConsoleLog;
+        console.warn = this.originalConsoleWarn;
+        console.error = this.originalConsoleError;
+        console.debug = this.originalConsoleDebug;
+        console.info = this.originalConsoleInfo;
+    };
+    formatArgs = (args) => util.format(...args);
+    patchConsoleMethod = (type) => (...args) => {
+        // When it is non interactive mode, do not show info logging unless
+        // it is debug mode. default to true if it is undefined.
+        if (this.params.interactive === false) {
+            if ((type === 'info' || type === 'log') && !this.params.debugMode) {
+                return;
+            }
+        }
+        // When it is in the debug mode, redirect console output to stderr
+        // depending on if it is stderr only mode.
+        if (type !== 'debug' || this.params.debugMode) {
+            if (this.params.stderr) {
+                this.originalConsoleError(this.formatArgs(args));
+            }
+            else {
+                this.params.onNewMessage?.({
+                    type,
+                    content: this.formatArgs(args),
+                    count: 1,
+                });
+            }
+        }
+    };
+}

package/dist/ui/utils/InlineMarkdownRenderer.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import React from 'react';
+import { Text } from 'ink';
+;
+import { parseMarkdownToANSI } from './markdownParsingUtils.js';
+import { stripUnsafeCharacters } from './textUtils.js';
+const RenderInlineInternal = ({ text: rawText, defaultColor, }) => {
+    const text = stripUnsafeCharacters(rawText);
+    const ansiText = parseMarkdownToANSI(text, defaultColor);
+    return _jsx(Text, { children: ansiText });
+};
+export const RenderInline = React.memo(RenderInlineInternal);

package/dist/ui/utils/MarkdownDisplay.js

@@ -0,0 +1,243 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import React from 'react';
+import { Text, Box } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { colorizeCode } from './CodeColorizer.js';
+import { TableRenderer } from './TableRenderer.js';
+import { RenderInline } from './InlineMarkdownRenderer.js';
+import { useSettings } from '../contexts/SettingsContext.js';
+import { useAlternateBuffer } from '../hooks/useAlternateBuffer.js';
+// Constants for Markdown parsing and rendering
+const EMPTY_LINE_HEIGHT = 1;
+const CODE_BLOCK_PREFIX_PADDING = 1;
+const LIST_ITEM_PREFIX_PADDING = 1;
+const LIST_ITEM_TEXT_FLEX_GROW = 1;
+const MarkdownDisplayInternal = ({ text, isPending, availableTerminalHeight, terminalWidth, renderMarkdown = true, }) => {
+    const settings = useSettings();
+    const isAlternateBuffer = useAlternateBuffer();
+    const responseColor = theme.text.response ?? theme.text.primary;
+    if (!text)
+        return _jsx(_Fragment, {});
+    // Raw markdown mode - display syntax-highlighted markdown without rendering
+    if (!renderMarkdown) {
+        // Hide line numbers in raw markdown mode as they are confusing due to chunked output
+        const colorizedMarkdown = colorizeCode({
+            code: text,
+            language: 'markdown',
+            availableHeight: isAlternateBuffer ? undefined : availableTerminalHeight,
+            maxWidth: terminalWidth - CODE_BLOCK_PREFIX_PADDING,
+            settings,
+            hideLineNumbers: true,
+        });
+        return (_jsx(Box, { paddingLeft: CODE_BLOCK_PREFIX_PADDING, flexDirection: "column", children: colorizedMarkdown }));
+    }
+    const lines = text.split(/\r?\n/);
+    const headerRegex = /^ *(#{1,4}) +(.*)/;
+    const codeFenceRegex = /^ *(`{3,}|~{3,}) *(\w*?) *$/;
+    const ulItemRegex = /^([ \t]*)([-*+]) +(.*)/;
+    const olItemRegex = /^([ \t]*)(\d+)\. +(.*)/;
+    const hrRegex = /^ *([-*_] *){3,} *$/;
+    const tableRowRegex = /^\s*\|(.+)\|\s*$/;
+    const tableSeparatorRegex = /^\s*\|?\s*(:?-+:?)\s*(\|\s*(:?-+:?)\s*)+\|?\s*$/;
+    const contentBlocks = [];
+    let inCodeBlock = false;
+    let lastLineEmpty = true;
+    let codeBlockContent = [];
+    let codeBlockLang = null;
+    let codeBlockFence = '';
+    let inTable = false;
+    let tableRows = [];
+    let tableHeaders = [];
+    function addContentBlock(block) {
+        if (block) {
+            contentBlocks.push(block);
+            lastLineEmpty = false;
+        }
+    }
+    lines.forEach((line, index) => {
+        const key = `line-${index}`;
+        if (inCodeBlock) {
+            const fenceMatch = line.match(codeFenceRegex);
+            if (fenceMatch &&
+                fenceMatch[1].startsWith(codeBlockFence[0]) &&
+                fenceMatch[1].length >= codeBlockFence.length) {
+                addContentBlock(_jsx(RenderCodeBlock, { content: codeBlockContent, lang: codeBlockLang, isPending: isPending, availableTerminalHeight: isAlternateBuffer ? undefined : availableTerminalHeight, terminalWidth: terminalWidth }, key));
+                inCodeBlock = false;
+                codeBlockContent = [];
+                codeBlockLang = null;
+                codeBlockFence = '';
+            }
+            else {
+                codeBlockContent.push(line);
+            }
+            return;
+        }
+        const codeFenceMatch = line.match(codeFenceRegex);
+        const headerMatch = line.match(headerRegex);
+        const ulMatch = line.match(ulItemRegex);
+        const olMatch = line.match(olItemRegex);
+        const hrMatch = line.match(hrRegex);
+        const tableRowMatch = line.match(tableRowRegex);
+        const tableSeparatorMatch = line.match(tableSeparatorRegex);
+        if (codeFenceMatch) {
+            inCodeBlock = true;
+            codeBlockFence = codeFenceMatch[1];
+            codeBlockLang = codeFenceMatch[2] || null;
+        }
+        else if (tableRowMatch && !inTable) {
+            // Potential table start - check if next line is separator
+            if (index + 1 < lines.length &&
+                lines[index + 1].match(tableSeparatorRegex)) {
+                inTable = true;
+                tableHeaders = tableRowMatch[1].split('|').map((cell) => cell.trim());
+                tableRows = [];
+            }
+            else {
+                // Not a table, treat as regular text
+                addContentBlock(_jsx(Box, { children: _jsx(Text, { wrap: "wrap", color: responseColor, children: _jsx(RenderInline, { text: line, defaultColor: responseColor }) }) }, key));
+            }
+        }
+        else if (inTable && tableSeparatorMatch) {
+            // Skip separator line - already handled
+        }
+        else if (inTable && tableRowMatch) {
+            // Add table row
+            const cells = tableRowMatch[1].split('|').map((cell) => cell.trim());
+            // Ensure row has same column count as headers
+            while (cells.length < tableHeaders.length) {
+                cells.push('');
+            }
+            if (cells.length > tableHeaders.length) {
+                cells.length = tableHeaders.length;
+            }
+            tableRows.push(cells);
+        }
+        else if (inTable && !tableRowMatch) {
+            // End of table
+            if (tableHeaders.length > 0 && tableRows.length > 0) {
+                addContentBlock(_jsx(RenderTable, { headers: tableHeaders, rows: tableRows, terminalWidth: terminalWidth }, `table-${contentBlocks.length}`));
+            }
+            inTable = false;
+            tableRows = [];
+            tableHeaders = [];
+            // Process current line as normal
+            if (line.trim().length > 0) {
+                addContentBlock(_jsx(Box, { children: _jsx(Text, { wrap: "wrap", color: responseColor, children: _jsx(RenderInline, { text: line, defaultColor: responseColor }) }) }, key));
+            }
+        }
+        else if (hrMatch) {
+            addContentBlock(_jsx(Box, { children: _jsx(Text, { dimColor: true, children: "---" }) }, key));
+        }
+        else if (headerMatch) {
+            const level = headerMatch[1].length;
+            const headerText = headerMatch[2];
+            let headerNode = null;
+            switch (level) {
+                case 1:
+                    headerNode = (_jsx(Text, { bold: true, color: theme.text.link, children: _jsx(RenderInline, { text: headerText, defaultColor: theme.text.link }) }));
+                    break;
+                case 2:
+                    headerNode = (_jsx(Text, { bold: true, color: theme.text.link, children: _jsx(RenderInline, { text: headerText, defaultColor: theme.text.link }) }));
+                    break;
+                case 3:
+                    headerNode = (_jsx(Text, { bold: true, color: responseColor, children: _jsx(RenderInline, { text: headerText, defaultColor: responseColor }) }));
+                    break;
+                case 4:
+                    headerNode = (_jsx(Text, { italic: true, color: theme.text.secondary, children: _jsx(RenderInline, { text: headerText, defaultColor: theme.text.secondary }) }));
+                    break;
+                default:
+                    headerNode = (_jsx(Text, { color: responseColor, children: _jsx(RenderInline, { text: headerText, defaultColor: responseColor }) }));
+                    break;
+            }
+            if (headerNode)
+                addContentBlock(_jsx(Box, { children: headerNode }, key));
+        }
+        else if (ulMatch) {
+            const leadingWhitespace = ulMatch[1];
+            const marker = ulMatch[2];
+            const itemText = ulMatch[3];
+            addContentBlock(_jsx(RenderListItem, { itemText: itemText, type: "ul", marker: marker, leadingWhitespace: leadingWhitespace }, key));
+        }
+        else if (olMatch) {
+            const leadingWhitespace = olMatch[1];
+            const marker = olMatch[2];
+            const itemText = olMatch[3];
+            addContentBlock(_jsx(RenderListItem, { itemText: itemText, type: "ol", marker: marker, leadingWhitespace: leadingWhitespace }, key));
+        }
+        else {
+            if (line.trim().length === 0 && !inCodeBlock) {
+                if (!lastLineEmpty) {
+                    contentBlocks.push(_jsx(Box, { height: EMPTY_LINE_HEIGHT }, `spacer-${index}`));
+                    lastLineEmpty = true;
+                }
+            }
+            else {
+                addContentBlock(_jsx(Box, { children: _jsx(Text, { wrap: "wrap", color: responseColor, children: _jsx(RenderInline, { text: line, defaultColor: responseColor }) }) }, key));
+            }
+        }
+    });
+    if (inCodeBlock) {
+        addContentBlock(_jsx(RenderCodeBlock, { content: codeBlockContent, lang: codeBlockLang, isPending: isPending, availableTerminalHeight: isAlternateBuffer ? undefined : availableTerminalHeight, terminalWidth: terminalWidth }, "line-eof"));
+    }
+    // Handle table at end of content
+    if (inTable && tableHeaders.length > 0 && tableRows.length > 0) {
+        addContentBlock(_jsx(RenderTable, { headers: tableHeaders, rows: tableRows, terminalWidth: terminalWidth }, `table-${contentBlocks.length}`));
+    }
+    return _jsx(_Fragment, { children: contentBlocks });
+};
+const RenderCodeBlockInternal = ({ content, lang, isPending, availableTerminalHeight, terminalWidth, }) => {
+    const settings = useSettings();
+    const isAlternateBuffer = useAlternateBuffer();
+    const MIN_LINES_FOR_MESSAGE = 1; // Minimum lines to show before the "generating more" message
+    const RESERVED_LINES = 2; // Lines reserved for the message itself and potential padding
+    // When not in alternate buffer mode we need to be careful that we don't
+    // trigger flicker when the pending code is too long to fit in the terminal
+    if (!isAlternateBuffer &&
+        isPending &&
+        availableTerminalHeight !== undefined) {
+        const MAX_CODE_LINES_WHEN_PENDING = Math.max(0, availableTerminalHeight - RESERVED_LINES);
+        if (content.length > MAX_CODE_LINES_WHEN_PENDING) {
+            if (MAX_CODE_LINES_WHEN_PENDING < MIN_LINES_FOR_MESSAGE) {
+                // Not enough space to even show the message meaningfully
+                return (_jsx(Box, { paddingLeft: CODE_BLOCK_PREFIX_PADDING, children: _jsx(Text, { color: theme.text.secondary, children: "... code is being written ..." }) }));
+            }
+            const truncatedContent = content.slice(0, MAX_CODE_LINES_WHEN_PENDING);
+            const colorizedTruncatedCode = colorizeCode({
+                code: truncatedContent.join('\n'),
+                language: lang,
+                availableHeight: availableTerminalHeight,
+                maxWidth: terminalWidth - CODE_BLOCK_PREFIX_PADDING,
+                settings,
+            });
+            return (_jsxs(Box, { paddingLeft: CODE_BLOCK_PREFIX_PADDING, flexDirection: "column", children: [colorizedTruncatedCode, _jsx(Text, { color: theme.text.secondary, children: "... generating more ..." })] }));
+        }
+    }
+    const fullContent = content.join('\n');
+    const colorizedCode = colorizeCode({
+        code: fullContent,
+        language: lang,
+        availableHeight: isAlternateBuffer ? undefined : availableTerminalHeight,
+        maxWidth: terminalWidth - CODE_BLOCK_PREFIX_PADDING,
+        settings,
+    });
+    return (_jsx(Box, { paddingLeft: CODE_BLOCK_PREFIX_PADDING, flexDirection: "column", width: terminalWidth, flexShrink: 0, children: colorizedCode }));
+};
+const RenderCodeBlock = React.memo(RenderCodeBlockInternal);
+const RenderListItemInternal = ({ itemText, type, marker, leadingWhitespace = '', }) => {
+    const prefix = type === 'ol' ? `${marker}. ` : `${marker} `;
+    const prefixWidth = prefix.length;
+    // Account for leading whitespace (indentation level) plus the standard prefix padding
+    const indentation = leadingWhitespace.length;
+    const listResponseColor = theme.text.response ?? theme.text.primary;
+    return (_jsxs(Box, { paddingLeft: indentation + LIST_ITEM_PREFIX_PADDING, flexDirection: "row", children: [_jsx(Box, { width: prefixWidth, flexShrink: 0, children: _jsx(Text, { color: listResponseColor, children: prefix }) }), _jsx(Box, { flexGrow: LIST_ITEM_TEXT_FLEX_GROW, children: _jsx(Text, { wrap: "wrap", color: listResponseColor, children: _jsx(RenderInline, { text: itemText, defaultColor: listResponseColor }) }) })] }));
+};
+const RenderListItem = React.memo(RenderListItemInternal);
+const RenderTableInternal = ({ headers, rows, terminalWidth, }) => (_jsx(TableRenderer, { headers: headers, rows: rows, terminalWidth: terminalWidth }));
+const RenderTable = React.memo(RenderTableInternal);
+export const MarkdownDisplay = React.memo(MarkdownDisplayInternal);

package/dist/ui/utils/TableRenderer.js

@@ -0,0 +1,161 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import React, { useMemo } from 'react';
+import { Text, Box } from 'ink';
+;
+import stringWidth from 'string-width';
+import wrapAnsi from 'wrap-ansi';
+import { theme } from '../semantic-colors.js';
+import { parseMarkdownToANSI } from './markdownParsingUtils.js';
+import { stripUnsafeCharacters } from './textUtils.js';
+const MIN_COLUMN_WIDTH = 5;
+const COLUMN_PADDING = 2;
+const TABLE_MARGIN = 2;
+/**
+ * Parses markdown to ANSI string.
+ */
+const parseMarkdownToAnsiString = (text, defaultColor) => {
+    return parseMarkdownToANSI(text, defaultColor);
+};
+const calculateWidths = (content) => {
+    const contentWidth = stringWidth(content);
+    // Split on whitespace to find words; preserve ANSI codes
+    const words = content.split(/\s+/).filter(w => w.length > 0);
+    const wordWidths = words.map(w => stringWidth(w));
+    const maxWordWidth = wordWidths.length > 0 ? Math.max(...wordWidths) : 0;
+    return { contentWidth, maxWordWidth };
+};
+/**
+ * Custom table renderer for markdown tables
+ * We implement our own instead of using ink-table due to module compatibility issues
+ */
+export const TableRenderer = ({ headers, rows, terminalWidth, }) => {
+    const ansiHeaders = useMemo(() => headers.map((header) => parseMarkdownToAnsiString(stripUnsafeCharacters(header), theme.text.link)), [headers]);
+    const ansiRows = useMemo(() => rows.map((row) => row.map((cell) => parseMarkdownToAnsiString(stripUnsafeCharacters(cell), theme.text.primary))), [rows]);
+    const { wrappedHeaders, wrappedRows, adjustedWidths } = useMemo(() => {
+        const numColumns = Math.max(ansiHeaders.length, ...ansiRows.map(r => r.length));
+        // --- Define Constraints per Column ---
+        const constraints = Array.from({ length: numColumns }).map((_, colIndex) => {
+            const headerContent = ansiHeaders[colIndex] || '';
+            let { contentWidth: maxContentWidth, maxWordWidth } = calculateWidths(headerContent);
+            ansiRows.forEach((row) => {
+                const cellContent = row[colIndex] || '';
+                const { contentWidth: cellWidth, maxWordWidth: cellWordWidth } = calculateWidths(cellContent);
+                maxContentWidth = Math.max(maxContentWidth, cellWidth);
+                maxWordWidth = Math.max(maxWordWidth, cellWordWidth);
+            });
+            const minWidth = maxWordWidth;
+            const maxWidth = Math.max(minWidth, maxContentWidth);
+            return { minWidth, maxWidth };
+        });
+        // --- Calculate Available Space ---
+        // Fixed overhead: borders (n+1) + padding (2n)
+        const fixedOverhead = numColumns + 1 + numColumns * COLUMN_PADDING;
+        const availableWidth = Math.max(0, terminalWidth - fixedOverhead - TABLE_MARGIN);
+        // --- Allocation Algorithm ---
+        const totalMinWidth = constraints.reduce((sum, c) => sum + c.minWidth, 0);
+        let finalContentWidths;
+        if (totalMinWidth > availableWidth) {
+            // We must scale all the columns except the ones that are very short(<=5 characters)
+            const shortColumns = constraints.filter((c) => c.maxWidth <= MIN_COLUMN_WIDTH);
+            const totalShortColumnWidth = shortColumns.reduce((sum, c) => sum + c.minWidth, 0);
+            const finalTotalShortColumnWidth = totalShortColumnWidth >= availableWidth ? 0 : totalShortColumnWidth;
+            const scale = (availableWidth - finalTotalShortColumnWidth) /
+                (totalMinWidth - finalTotalShortColumnWidth) || 0;
+            finalContentWidths = constraints.map((c) => {
+                if (c.maxWidth <= MIN_COLUMN_WIDTH && finalTotalShortColumnWidth > 0) {
+                    return c.minWidth;
+                }
+                return Math.floor(c.minWidth * scale);
+            });
+        }
+        else {
+            const surplus = availableWidth - totalMinWidth;
+            const totalGrowthNeed = constraints.reduce((sum, c) => sum + (c.maxWidth - c.minWidth), 0);
+            if (totalGrowthNeed === 0) {
+                finalContentWidths = constraints.map((c) => c.minWidth);
+            }
+            else {
+                finalContentWidths = constraints.map((c) => {
+                    const growthNeed = c.maxWidth - c.minWidth;
+                    const share = growthNeed / totalGrowthNeed;
+                    const extra = Math.floor(surplus * share);
+                    return Math.min(c.maxWidth, c.minWidth + extra);
+                });
+            }
+        }
+        // --- Pre-wrap and Optimize Widths ---
+        const actualColumnWidths = new Array(numColumns).fill(0);
+        const wrapAndProcessRow = (row) => {
+            const rowResult = [];
+            // Ensure we iterate up to numColumns, filling with empty cells if needed
+            for (let colIndex = 0; colIndex < numColumns; colIndex++) {
+                const cellContent = row[colIndex] || '';
+                const allocatedWidth = finalContentWidths[colIndex];
+                const contentWidth = Math.max(1, allocatedWidth);
+                // wrap-ansi returns a string with newlines
+                const wrapped = wrapAnsi(cellContent, contentWidth);
+                // Split into lines and compute width of each line
+                const lines = wrapped.split('\n');
+                const processedLines = lines.map(line => ({
+                    text: line,
+                    width: stringWidth(line),
+                }));
+                // Track the max line width for this column
+                const maxLineWidth = Math.max(...processedLines.map(l => l.width), 0);
+                actualColumnWidths[colIndex] = Math.max(actualColumnWidths[colIndex], maxLineWidth);
+                rowResult.push(processedLines);
+            }
+            return rowResult;
+        };
+        const wrappedHeaders = wrapAndProcessRow(ansiHeaders);
+        const wrappedRows = ansiRows.map((row) => wrapAndProcessRow(row));
+        // Use the TIGHTEST widths that fit the wrapped content + padding
+        const adjustedWidths = actualColumnWidths.map((w) => w + COLUMN_PADDING);
+        return { wrappedHeaders, wrappedRows, adjustedWidths };
+    }, [ansiHeaders, ansiRows, terminalWidth]);
+    // Helper function to render a cell with proper width
+    const renderCell = (content, width, isHeader = false) => {
+        const contentWidth = Math.max(0, width - COLUMN_PADDING);
+        // Use pre-calculated width to avoid re-parsing
+        const displayWidth = content.width;
+        const paddingNeeded = Math.max(0, contentWidth - displayWidth);
+        return (_jsxs(Text, { children: [isHeader ? (_jsx(Text, { bold: true, color: theme.text.link, children: content.text })) : (_jsx(Text, { children: content.text })), ' '.repeat(paddingNeeded)] }));
+    };
+    // Helper function to render border
+    const renderBorder = (type) => {
+        const chars = {
+            top: { left: '┌', middle: '┬', right: '┐', horizontal: '─' },
+            middle: { left: '├', middle: '┼', right: '┤', horizontal: '─' },
+            bottom: { left: '└', middle: '┴', right: '┘', horizontal: '─' },
+        };
+        const char = chars[type];
+        const borderParts = adjustedWidths.map((w) => char.horizontal.repeat(Math.max(0, w || 0)));
+        const border = char.left + borderParts.join(char.middle) + char.right;
+        return _jsx(Text, { color: theme.border.default, children: border });
+    };
+    // Helper function to render a single visual line of a row
+    const renderVisualRow = (cells, isHeader = false) => {
+        const renderedCells = cells.map((cell, index) => {
+            const width = adjustedWidths[index] || 0;
+            return renderCell(cell, width, isHeader);
+        });
+        return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.border.default, children: "\u2502" }), renderedCells.map((cell, index) => (_jsxs(React.Fragment, { children: [_jsx(Box, { paddingX: 1, children: cell }), index < renderedCells.length - 1 && (_jsx(Text, { color: theme.border.default, children: "\u2502" }))] }, index))), _jsx(Text, { color: theme.border.default, children: "\u2502" })] }));
+    };
+    // Handles the wrapping logic for a logical data row
+    const renderDataRow = (wrappedCells, rowIndex, isHeader = false) => {
+        const key = rowIndex === -1 ? 'header' : `${rowIndex}`;
+        const maxHeight = Math.max(...wrappedCells.map((lines) => lines.length), 1);
+        const visualRows = [];
+        for (let i = 0; i < maxHeight; i++) {
+            const visualRowCells = wrappedCells.map((lines) => lines[i] || { text: '', width: 0 });
+            visualRows.push(_jsx(React.Fragment, { children: renderVisualRow(visualRowCells, isHeader) }, `${key}-${i}`));
+        }
+        return _jsx(React.Fragment, { children: visualRows }, rowIndex);
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [renderBorder('top'), renderDataRow(wrappedHeaders, -1, true), renderBorder('middle'), wrappedRows.map((row, index) => renderDataRow(row, index)), renderBorder('bottom')] }));
+};

package/dist/ui/utils/antigravityUtils.js

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import process from 'node:process';
+const ANTIGRAVITY_SH_INSTALL = 'curl -fsSL https://antigravity.google/cli/install.sh | bash';
+/**
+ * Gets the platform-specific installation details for the Antigravity CLI.
+ * Returns null if the current platform is unsupported.
+ */
+export function getAntigravityInstallInfo() {
+    if (process.platform === 'win32') {
+        if (process.env['PSModulePath']) {
+            return {
+                platformName: 'Windows (PowerShell)',
+                installCmd: 'irm https://antigravity.google/cli/install.ps1 | iex',
+            };
+        }
+        else {
+            return {
+                platformName: 'Windows (Command Prompt)',
+                installCmd: 'curl -fsSL https://antigravity.google/cli/install.cmd -o install.cmd && install.cmd && del install.cmd',
+            };
+        }
+    }
+    else if (process.platform === 'darwin') {
+        return {
+            platformName: 'macOS',
+            installCmd: ANTIGRAVITY_SH_INSTALL,
+        };
+    }
+    else if (process.platform === 'linux') {
+        return {
+            platformName: 'Linux',
+            installCmd: ANTIGRAVITY_SH_INSTALL,
+        };
+    }
+    return null;
+}