@quantum-ai/gemini-cli 0.45.8 → 0.45.10

package/dist/ui/utils/fileUtils.js

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as path from 'node:path';
+/**
+ * Gets the file extension from a filename or path, excluding the leading dot.
+ * Returns null if no extension is found.
+ */
+export function getFileExtension(filename) {
+    if (!filename)
+        return null;
+    const ext = path.extname(filename);
+    return ext ? ext.slice(1) : null;
+}

package/dist/ui/utils/formatters.js

@@ -0,0 +1,126 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { REFERENCE_CONTENT_START, REFERENCE_CONTENT_END, } from '@google/gemini-cli-core';
+export const formatBytes = (bytes) => {
+    const gb = bytes / (1024 * 1024 * 1024);
+    if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    }
+    if (bytes < 1024 * 1024 * 1024) {
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    }
+    return `${gb.toFixed(2)} GB`;
+};
+/**
+ * Formats a duration in milliseconds into a concise, human-readable string (e.g., "1h 5s").
+ * It omits any time units that are zero.
+ * @param milliseconds The duration in milliseconds.
+ * @returns A formatted string representing the duration.
+ */
+export const formatDuration = (milliseconds) => {
+    if (milliseconds <= 0) {
+        return '0s';
+    }
+    if (milliseconds < 1000) {
+        return `${Math.round(milliseconds)}ms`;
+    }
+    const totalSeconds = milliseconds / 1000;
+    if (totalSeconds < 60) {
+        return `${totalSeconds.toFixed(1)}s`;
+    }
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = Math.floor(totalSeconds % 60);
+    const parts = [];
+    if (hours > 0) {
+        parts.push(`${hours}h`);
+    }
+    if (minutes > 0) {
+        parts.push(`${minutes}m`);
+    }
+    if (seconds > 0) {
+        parts.push(`${seconds}s`);
+    }
+    // If all parts are zero (e.g., exactly 1 hour), return the largest unit.
+    if (parts.length === 0) {
+        if (hours > 0)
+            return `${hours}h`;
+        if (minutes > 0)
+            return `${minutes}m`;
+        return `${seconds}s`;
+    }
+    return parts.join(' ');
+};
+export const formatTimeAgo = (date) => {
+    const past = new Date(date);
+    if (isNaN(past.getTime())) {
+        return 'invalid date';
+    }
+    const now = new Date();
+    const diffMs = now.getTime() - past.getTime();
+    if (diffMs < 60000) {
+        return 'just now';
+    }
+    return `${formatDuration(diffMs)} ago`;
+};
+/**
+ * Removes content bounded by reference content markers from the given text.
+ * The markers are "${REFERENCE_CONTENT_START}" and "${REFERENCE_CONTENT_END}".
+ *
+ * @param text The input text containing potential reference blocks.
+ * @returns The text with reference blocks removed and trimmed.
+ */
+export function stripReferenceContent(text) {
+    // Match optional newline, the start marker, content (non-greedy), and the end marker
+    const pattern = new RegExp(`\\n?${REFERENCE_CONTENT_START}[\\s\\S]*?${REFERENCE_CONTENT_END}`, 'g');
+    return text.replace(pattern, '').trim();
+}
+export const formatResetTime = (resetTime, format = 'full') => {
+    if (!resetTime)
+        return '';
+    const resetDate = new Date(resetTime);
+    if (isNaN(resetDate.getTime()))
+        return '';
+    const diff = resetDate.getTime() - Date.now();
+    if (diff <= 0)
+        return '';
+    const totalMinutes = Math.ceil(diff / (1000 * 60));
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    const isTerse = format === 'terse';
+    const isColumn = format === 'column';
+    if (isTerse || isColumn) {
+        const hoursStr = hours > 0 ? `${hours}h` : '';
+        const minutesStr = minutes > 0 ? `${minutes}m` : '';
+        const duration = hoursStr && minutesStr
+            ? `${hoursStr} ${minutesStr}`
+            : hoursStr || minutesStr;
+        if (isColumn) {
+            const timeStr = new Intl.DateTimeFormat('en-US', {
+                hour: 'numeric',
+                minute: 'numeric',
+            }).format(resetDate);
+            return duration ? `${timeStr} (${duration})` : timeStr;
+        }
+        return duration;
+    }
+    let duration = '';
+    if (hours > 0) {
+        duration = `${hours} hour${hours > 1 ? 's' : ''}`;
+        if (minutes > 0) {
+            duration += ` ${minutes} minute${minutes > 1 ? 's' : ''}`;
+        }
+    }
+    else {
+        duration = `${minutes} minute${minutes > 1 ? 's' : ''}`;
+    }
+    const timeStr = new Intl.DateTimeFormat('en-US', {
+        hour: 'numeric',
+        minute: 'numeric',
+        timeZoneName: 'short',
+    }).format(resetDate);
+    return `${duration} at ${timeStr}`;
+};

package/dist/ui/utils/highlight.js

@@ -0,0 +1,116 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { PASTED_TEXT_PLACEHOLDER_REGEX, } from '../components/shared/text-buffer.js';
+import { LRUCache } from 'mnemonist';
+import { cpLen, cpSlice } from './textUtils.js';
+import { LRU_BUFFER_PERF_CACHE_LIMIT } from '../constants.js';
+import { AT_COMMAND_PATH_REGEX_SOURCE } from '../hooks/atCommandProcessor.js';
+// Matches slash commands (e.g., /help), @ references (files or MCP resource URIs),
+// and large paste placeholders (e.g., [Pasted Text: 6 lines]).
+//
+// The @ pattern uses the same source as the command processor to ensure consistency.
+// It matches any character except strict delimiters (ASCII whitespace, comma, etc.).
+// This supports URIs like `@file:///example.txt` and filenames with Unicode spaces (like NNBSP).
+const HIGHLIGHT_REGEX = new RegExp(`(^/[a-zA-Z0-9_-]+|(?<!\\\\)@${AT_COMMAND_PATH_REGEX_SOURCE}|${PASTED_TEXT_PLACEHOLDER_REGEX.source})`, 'g');
+const highlightCache = new LRUCache(LRU_BUFFER_PERF_CACHE_LIMIT);
+export function parseInputForHighlighting(text, index, transformations = [], cursorCol) {
+    let isCursorInsideTransform = false;
+    if (cursorCol !== undefined) {
+        for (const transform of transformations) {
+            if (cursorCol >= transform.logStart && cursorCol <= transform.logEnd) {
+                isCursorInsideTransform = true;
+                break;
+            }
+        }
+    }
+    const cacheKey = `${index === 0 ? 'F' : 'N'}:${isCursorInsideTransform ? cursorCol : 'NC'}:${text}`;
+    const cached = highlightCache.get(cacheKey);
+    if (cached !== undefined)
+        return cached;
+    HIGHLIGHT_REGEX.lastIndex = 0;
+    if (!text) {
+        return [{ text: '', type: 'default' }];
+    }
+    const parseUntransformedInput = (text) => {
+        const tokens = [];
+        if (!text)
+            return tokens;
+        HIGHLIGHT_REGEX.lastIndex = 0;
+        let last = 0;
+        let match;
+        while ((match = HIGHLIGHT_REGEX.exec(text)) !== null) {
+            const [fullMatch] = match;
+            const matchIndex = match.index;
+            if (matchIndex > last) {
+                tokens.push({ text: text.slice(last, matchIndex), type: 'default' });
+            }
+            const type = fullMatch.startsWith('/')
+                ? 'command'
+                : fullMatch.startsWith('@')
+                    ? 'file'
+                    : 'paste';
+            if (type === 'command' && index !== 0) {
+                tokens.push({ text: fullMatch, type: 'default' });
+            }
+            else {
+                tokens.push({ text: fullMatch, type });
+            }
+            last = matchIndex + fullMatch.length;
+        }
+        if (last < text.length) {
+            tokens.push({ text: text.slice(last), type: 'default' });
+        }
+        return tokens;
+    };
+    const tokens = [];
+    let column = 0;
+    const sortedTransformations = (transformations ?? [])
+        .slice()
+        .sort((a, b) => a.logStart - b.logStart);
+    for (const transformation of sortedTransformations) {
+        const textBeforeTransformation = cpSlice(text, column, transformation.logStart);
+        tokens.push(...parseUntransformedInput(textBeforeTransformation));
+        const isCursorInside = cursorCol !== undefined &&
+            cursorCol >= transformation.logStart &&
+            cursorCol <= transformation.logEnd;
+        const transformationText = isCursorInside
+            ? transformation.logicalText
+            : transformation.collapsedText;
+        tokens.push({ text: transformationText, type: 'file' });
+        column = transformation.logEnd;
+    }
+    const textAfterFinalTransformation = cpSlice(text, column);
+    tokens.push(...parseUntransformedInput(textAfterFinalTransformation));
+    highlightCache.set(cacheKey, tokens);
+    return tokens;
+}
+export function parseSegmentsFromTokens(tokens, sliceStart, sliceEnd) {
+    if (sliceStart >= sliceEnd)
+        return [];
+    const segments = [];
+    let tokenCpStart = 0;
+    for (const token of tokens) {
+        const tokenLen = cpLen(token.text);
+        const tokenStart = tokenCpStart;
+        const tokenEnd = tokenStart + tokenLen;
+        const overlapStart = Math.max(tokenStart, sliceStart);
+        const overlapEnd = Math.min(tokenEnd, sliceEnd);
+        if (overlapStart < overlapEnd) {
+            const sliceStartInToken = overlapStart - tokenStart;
+            const sliceEndInToken = overlapEnd - tokenStart;
+            const rawSlice = cpSlice(token.text, sliceStartInToken, sliceEndInToken);
+            const last = segments[segments.length - 1];
+            if (last && last.type === token.type) {
+                last.text += rawSlice;
+            }
+            else {
+                segments.push({ type: token.type, text: rawSlice });
+            }
+        }
+        tokenCpStart += tokenLen;
+    }
+    return segments;
+}

package/dist/ui/utils/historyExportUtils.js

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as fsPromises from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Serializes chat history to a Markdown string.
+ */
+export function serializeHistoryToMarkdown(history) {
+    return history
+        .map((item) => {
+        const text = item.parts
+            ?.map((part) => {
+            if (part.text) {
+                return part.text;
+            }
+            if (part.functionCall) {
+                return (`**Tool Command**:\n` +
+                    '```json\n' +
+                    JSON.stringify(part.functionCall, null, 2) +
+                    '\n```');
+            }
+            if (part.functionResponse) {
+                return (`**Tool Response**:\n` +
+                    '```json\n' +
+                    JSON.stringify(part.functionResponse, null, 2) +
+                    '\n```');
+            }
+            return '';
+        })
+            .join('') || '';
+        const roleIcon = item.role === 'user' ? '🧑‍💻' : '✨';
+        return `## ${(item.role || 'model').toUpperCase()} ${roleIcon}\n\n${text}`;
+    })
+        .join('\n\n---\n\n');
+}
+/**
+ * Exports chat history to a file (JSON or Markdown).
+ */
+export async function exportHistoryToFile(options) {
+    const { history, filePath } = options;
+    const extension = path.extname(filePath).toLowerCase();
+    let content;
+    if (extension === '.json') {
+        content = JSON.stringify(history, null, 2);
+    }
+    else if (extension === '.md') {
+        content = serializeHistoryToMarkdown(history);
+    }
+    else {
+        throw new Error(`Unsupported file extension: ${extension}. Use .json or .md.`);
+    }
+    const dir = path.dirname(filePath);
+    await fsPromises.mkdir(dir, { recursive: true });
+    await fsPromises.writeFile(filePath, content, 'utf-8');
+}

package/dist/ui/utils/historyUtils.js

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CoreToolCallStatus } from '../types.js';
+/**
+ * Maps an IndividualToolCallDisplay from the CLI to a ToolVisibilityContext for core logic.
+ */
+export function buildToolVisibilityContextFromDisplay(tool) {
+    return {
+        name: tool.originalRequestName ?? tool.name,
+        displayName: tool.name, // In CLI, 'name' is usually the resolved display name
+        status: tool.status,
+        hasResult: !!tool.resultDisplay,
+        approvalMode: tool.approvalMode,
+        isClientInitiated: tool.isClientInitiated,
+        parentCallId: tool.parentCallId,
+    };
+}
+export function getLastTurnToolCallIds(history, pendingHistoryItems) {
+    const targetToolCallIds = [];
+    // Find the boundary of the last user prompt
+    let lastUserPromptIndex = -1;
+    for (let i = history.length - 1; i >= 0; i--) {
+        const type = history[i].type;
+        if (type === 'user' || type === 'user_shell') {
+            lastUserPromptIndex = i;
+            break;
+        }
+    }
+    // Collect IDs from history after last user prompt
+    history.forEach((item, index) => {
+        if (index > lastUserPromptIndex && item.type === 'tool_group') {
+            item.tools.forEach((t) => {
+                if (t.callId)
+                    targetToolCallIds.push(t.callId);
+            });
+        }
+    });
+    // Collect IDs from pending items
+    pendingHistoryItems.forEach((item) => {
+        if (item.type === 'tool_group') {
+            item.tools.forEach((t) => {
+                if (t.callId)
+                    targetToolCallIds.push(t.callId);
+            });
+        }
+    });
+    return targetToolCallIds;
+}
+export function isToolExecuting(pendingHistoryItems) {
+    return pendingHistoryItems.some((item) => {
+        if (item && item.type === 'tool_group') {
+            return item.tools.some((tool) => CoreToolCallStatus.Executing === tool.status);
+        }
+        return false;
+    });
+}
+export function isToolAwaitingConfirmation(pendingHistoryItems) {
+    return pendingHistoryItems
+        .filter((item) => item.type === 'tool_group')
+        .some((item) => item.tools.some((tool) => CoreToolCallStatus.AwaitingApproval === tool.status));
+}
+export function getAllToolCalls(historyItems) {
+    return historyItems
+        .filter((item) => item.type === 'tool_group')
+        .flatMap((group) => group.tools);
+}

package/dist/ui/utils/inlineThinkingMode.js

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export function getInlineThinkingMode(settings) {
+    return settings.merged.ui?.inlineThinkingMode ?? 'off';
+}

package/dist/ui/utils/input.js

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export const ESC = '\u001B';
+export const SGR_EVENT_PREFIX = `${ESC}[<`;
+export const X11_EVENT_PREFIX = `${ESC}[M`;
+// eslint-disable-next-line no-control-regex
+export const SGR_MOUSE_REGEX = /^\x1b\[<(\d+);(\d+);(\d+)([mM])/; // SGR mouse events
+// X11 is ESC [ M followed by 3 bytes.
+// eslint-disable-next-line no-control-regex
+export const X11_MOUSE_REGEX = /^\x1b\[M([\s\S]{3})/;
+export function couldBeSGRMouseSequence(buffer) {
+    if (buffer.length === 0)
+        return true;
+    // Check if buffer is a prefix of a mouse sequence starter
+    if (SGR_EVENT_PREFIX.startsWith(buffer))
+        return true;
+    // Check if buffer is a mouse sequence prefix
+    if (buffer.startsWith(SGR_EVENT_PREFIX))
+        return true;
+    return false;
+}
+export function couldBeMouseSequence(buffer) {
+    if (buffer.length === 0)
+        return true;
+    // Check SGR prefix
+    if (SGR_EVENT_PREFIX.startsWith(buffer) ||
+        buffer.startsWith(SGR_EVENT_PREFIX))
+        return true;
+    // Check X11 prefix
+    if (X11_EVENT_PREFIX.startsWith(buffer) ||
+        buffer.startsWith(X11_EVENT_PREFIX))
+        return true;
+    return false;
+}
+/**
+ * Checks if the buffer *starts* with a complete mouse sequence.
+ * Returns the length of the sequence if matched, or 0 if not.
+ */
+export function getMouseSequenceLength(buffer) {
+    const sgrMatch = buffer.match(SGR_MOUSE_REGEX);
+    if (sgrMatch)
+        return sgrMatch[0].length;
+    const x11Match = buffer.match(X11_MOUSE_REGEX);
+    if (x11Match)
+        return x11Match[0].length;
+    return 0;
+}

package/dist/ui/utils/isNarrowWidth.js

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export function isNarrowWidth(width) {
+    return width < 80;
+}