@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/ui/utils/rewindFileOps.js

@@ -0,0 +1,190 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs/promises';
+import * as Diff from 'diff';
+import { coreEvents, debugLogger, getFileDiffFromResultDisplay, computeModelAddedAndRemovedLines, } from '@google/gemini-cli-core';
+/**
+ * Calculates file change statistics for a single turn.
+ * A turn is defined as the sequence of messages starting after the given user message
+ * and continuing until the next user message or the end of the conversation.
+ *
+ * @param conversation The full conversation record.
+ * @param userMessage The starting user message for the turn.
+ * @returns Statistics about lines added/removed and files touched, or null if no edits occurred.
+ */
+export function calculateTurnStats(conversation, userMessage) {
+    const msgIndex = conversation.messages.indexOf(userMessage);
+    if (msgIndex === -1)
+        return null;
+    let addedLines = 0;
+    let removedLines = 0;
+    const files = new Set();
+    let hasEdits = false;
+    // Look ahead until the next user message (single turn)
+    for (let i = msgIndex + 1; i < conversation.messages.length; i++) {
+        const msg = conversation.messages[i];
+        if (msg.type === 'user')
+            break; // Stop at next user message
+        if (msg.type === 'gemini' && msg.toolCalls) {
+            for (const toolCall of msg.toolCalls) {
+                const fileDiff = getFileDiffFromResultDisplay(toolCall.resultDisplay);
+                if (fileDiff) {
+                    hasEdits = true;
+                    const stats = fileDiff.diffStat;
+                    const calculations = computeModelAddedAndRemovedLines(stats);
+                    addedLines += calculations.addedLines;
+                    removedLines += calculations.removedLines;
+                    files.add(fileDiff.fileName);
+                }
+            }
+        }
+    }
+    if (!hasEdits)
+        return null;
+    return {
+        addedLines,
+        removedLines,
+        fileCount: files.size,
+    };
+}
+/**
+ * Calculates the cumulative file change statistics from a specific message
+ * to the end of the conversation.
+ *
+ * @param conversation The full conversation record.
+ * @param userMessage The message to start calculating impact from (exclusive).
+ * @returns Aggregate statistics about lines added/removed and files touched, or null if no edits occurred.
+ */
+export function calculateRewindImpact(conversation, userMessage) {
+    const msgIndex = conversation.messages.indexOf(userMessage);
+    if (msgIndex === -1)
+        return null;
+    let addedLines = 0;
+    let removedLines = 0;
+    const files = new Set();
+    const details = [];
+    let hasEdits = false;
+    // Look ahead to the end of conversation (cumulative)
+    for (let i = msgIndex + 1; i < conversation.messages.length; i++) {
+        const msg = conversation.messages[i];
+        // Do NOT break on user message - we want total impact
+        if (msg.type === 'gemini' && msg.toolCalls) {
+            for (const toolCall of msg.toolCalls) {
+                const fileDiff = getFileDiffFromResultDisplay(toolCall.resultDisplay);
+                if (fileDiff) {
+                    hasEdits = true;
+                    const stats = fileDiff.diffStat;
+                    const calculations = computeModelAddedAndRemovedLines(stats);
+                    addedLines += calculations.addedLines;
+                    removedLines += calculations.removedLines;
+                    files.add(fileDiff.fileName);
+                    details.push({
+                        fileName: fileDiff.fileName,
+                        diff: fileDiff.fileDiff,
+                    });
+                }
+            }
+        }
+    }
+    if (!hasEdits)
+        return null;
+    return {
+        addedLines,
+        removedLines,
+        fileCount: files.size,
+        details,
+    };
+}
+/**
+ * Reverts file changes made by the model from the end of the conversation
+ * back to a specific target message.
+ *
+ * It iterates backwards through the conversation history and attempts to undo
+ * any file modifications. It handles cases where the user might have subsequently
+ * modified the file by attempting a smart patch (using the `diff` library).
+ *
+ * @param conversation The full conversation record.
+ * @param targetMessageId The ID of the message to revert back to. Changes *after* this message will be undone.
+ */
+export async function revertFileChanges(conversation, targetMessageId) {
+    const messageIndex = conversation.messages.findIndex((m) => m.id === targetMessageId);
+    if (messageIndex === -1) {
+        debugLogger.error('Requested message to rewind to was not found ');
+        return;
+    }
+    // Iterate backwards from the end to the message being rewound (exclusive of the messageId itself)
+    for (let i = conversation.messages.length - 1; i > messageIndex; i--) {
+        const msg = conversation.messages[i];
+        if (msg.type === 'gemini' && msg.toolCalls) {
+            for (let j = msg.toolCalls.length - 1; j >= 0; j--) {
+                const toolCall = msg.toolCalls[j];
+                const fileDiff = getFileDiffFromResultDisplay(toolCall.resultDisplay);
+                if (fileDiff) {
+                    const { filePath, fileName, newContent, originalContent, isNewFile } = fileDiff;
+                    try {
+                        let currentContent = null;
+                        try {
+                            currentContent = await fs.readFile(filePath, 'utf8');
+                        }
+                        catch (e) {
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                            const error = e;
+                            if ('code' in error && error.code === 'ENOENT') {
+                                // File does not exist, which is fine in some revert scenarios.
+                                debugLogger.debug(`File ${fileName} not found during revert, proceeding as it may be a new file deletion.`);
+                            }
+                            else {
+                                // Other read errors are unexpected.
+                                coreEvents.emitFeedback('error', `Error reading ${fileName} during revert: ${error.message}`, e);
+                                // Continue to next tool call
+                                return;
+                            }
+                        }
+                        // 1. Exact Match: Safe to revert directly
+                        if (currentContent === newContent) {
+                            if (!isNewFile) {
+                                await fs.writeFile(filePath, originalContent ?? '');
+                            }
+                            else {
+                                // Original content was null (new file), so we delete the file
+                                await fs.unlink(filePath);
+                            }
+                        }
+                        // 2. Mismatch: Attempt Smart Revert (Patch)
+                        else if (currentContent !== null) {
+                            const originalText = originalContent ?? '';
+                            // Create a patch that transforms Agent -> Original
+                            const undoPatch = Diff.createPatch(fileName, newContent, originalText);
+                            // Apply that patch to the Current content
+                            const patchedContent = Diff.applyPatch(currentContent, undoPatch);
+                            if (typeof patchedContent === 'string') {
+                                if (patchedContent === '' && isNewFile) {
+                                    // If the result is empty and the file didn't exist originally, delete it
+                                    await fs.unlink(filePath);
+                                }
+                                else {
+                                    await fs.writeFile(filePath, patchedContent);
+                                }
+                            }
+                            else {
+                                // Patch failed
+                                coreEvents.emitFeedback('warning', `Smart revert for ${fileName} failed. The file may have been modified in a way that conflicts with the undo operation.`);
+                            }
+                        }
+                        else {
+                            // File was deleted by the user, but we expected content.
+                            // This can happen if a file created by the agent is deleted before rewind.
+                            coreEvents.emitFeedback('warning', `Cannot revert changes for ${fileName} because it was not found on disk. This is expected if a file created by the agent was deleted before rewind`);
+                        }
+                    }
+                    catch (e) {
+                        coreEvents.emitFeedback('error', `An unexpected error occurred while reverting ${fileName}.`, e);
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/ui/utils/shortcutsHelp.js

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Command } from '../key/keyMatchers.js';
+import { useKeyMatchers } from '../hooks/useKeyMatchers.js';
+export function useIsHelpDismissKey() {
+    const keyMatchers = useKeyMatchers();
+    return (key) => Object.values(Command).some((command) => keyMatchers[command](key));
+}

package/dist/ui/utils/terminalCapabilityManager.js

@@ -0,0 +1,259 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as fs from 'node:fs';
+import { debugLogger, enableKittyKeyboardProtocol, disableKittyKeyboardProtocol, enableModifyOtherKeys, disableModifyOtherKeys, enableBracketedPasteMode, disableBracketedPasteMode, disableMouseEvents, } from '@google/gemini-cli-core';
+import { parseColor } from '../themes/color-utils.js';
+const TERMINAL_CLEANUP_SEQUENCE = '\x1b[<u\x1b[>4;0m\x1b[?2004l\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l';
+export function cleanupTerminalOnExit() {
+    try {
+        if (process.stdout?.fd !== undefined) {
+            fs.writeSync(process.stdout.fd, TERMINAL_CLEANUP_SEQUENCE);
+            return;
+        }
+    }
+    catch (e) {
+        debugLogger.warn('Failed to synchronously cleanup terminal modes:', e);
+    }
+    disableKittyKeyboardProtocol();
+    disableModifyOtherKeys();
+    disableBracketedPasteMode();
+    disableMouseEvents();
+}
+export class TerminalCapabilityManager {
+    static instance;
+    static KITTY_QUERY = '\x1b[?u';
+    static OSC_11_QUERY = '\x1b]11;?\x1b\\';
+    static TERMINAL_NAME_QUERY = '\x1b[>q';
+    static DEVICE_ATTRIBUTES_QUERY = '\x1b[c';
+    static MODIFY_OTHER_KEYS_QUERY = '\x1b[>4;?m';
+    static HIDDEN_MODE = '\x1b[8m';
+    static CLEAR_LINE_AND_RETURN = '\x1b[2K\r';
+    static RESET_ATTRIBUTES = '\x1b[0m';
+    /**
+     * Triggers a terminal background color query.
+     * @param stdout The stdout stream to write to.
+     */
+    static queryBackgroundColor(stdout) {
+        stdout.write(TerminalCapabilityManager.OSC_11_QUERY);
+    }
+    // Kitty keyboard flags: CSI ? flags u
+    // eslint-disable-next-line no-control-regex
+    static KITTY_REGEX = /\x1b\[\?(\d+)u/;
+    // Terminal Name/Version response: DCS > | text ST (or BEL)
+    // eslint-disable-next-line no-control-regex
+    static TERMINAL_NAME_REGEX = /\x1bP>\|(.+?)(\x1b\\|\x07)/;
+    // Primary Device Attributes: CSI ? ID ; ... c
+    // eslint-disable-next-line no-control-regex
+    static DEVICE_ATTRIBUTES_REGEX = /\x1b\[\?(\d+)(;\d+)*c/;
+    // OSC 11 response: OSC 11 ; rgb:rrrr/gggg/bbbb ST (or BEL)
+    static OSC_11_REGEX = 
+    // eslint-disable-next-line no-control-regex
+    /\x1b\]11;rgb:([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})(\x1b\\|\x07)/;
+    // modifyOtherKeys response: CSI > 4 ; level m
+    // eslint-disable-next-line no-control-regex
+    static MODIFY_OTHER_KEYS_REGEX = /\x1b\[>4;(\d+)m/;
+    detectionComplete = false;
+    terminalBackgroundColor;
+    kittySupported = false;
+    kittyEnabled = false;
+    modifyOtherKeysSupported = false;
+    terminalName;
+    constructor() { }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new TerminalCapabilityManager();
+        }
+        return this.instance;
+    }
+    static resetInstanceForTesting() {
+        this.instance = undefined;
+    }
+    /**
+     * Detects terminal capabilities (Kitty protocol support, terminal name,
+     * background color).
+     * This should be called once at app startup.
+     */
+    async detectCapabilities() {
+        if (this.detectionComplete)
+            return;
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            this.detectionComplete = true;
+            return;
+        }
+        process.off('exit', cleanupTerminalOnExit);
+        process.off('SIGTERM', cleanupTerminalOnExit);
+        process.off('SIGINT', cleanupTerminalOnExit);
+        process.on('exit', cleanupTerminalOnExit);
+        process.on('SIGTERM', cleanupTerminalOnExit);
+        process.on('SIGINT', cleanupTerminalOnExit);
+        return new Promise((resolve) => {
+            const originalRawMode = process.stdin.isRaw;
+            if (!originalRawMode) {
+                process.stdin.setRawMode(true);
+            }
+            let buffer = '';
+            let kittyKeyboardReceived = false;
+            let terminalNameReceived = false;
+            let deviceAttributesReceived = false;
+            let bgReceived = false;
+            let modifyOtherKeysReceived = false;
+            // eslint-disable-next-line prefer-const
+            let timeoutId;
+            const cleanup = () => {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+                process.stdin.removeListener('data', onData);
+                if (!originalRawMode) {
+                    process.stdin.setRawMode(false);
+                }
+                this.detectionComplete = true;
+                resolve();
+            };
+            // A somewhat long timeout is acceptable as all terminals should respond
+            // to the device attributes query used as a sentinel.
+            timeoutId = setTimeout(cleanup, 1000);
+            const onData = (data) => {
+                buffer += data.toString();
+                // Check OSC 11
+                if (!bgReceived) {
+                    const match = buffer.match(TerminalCapabilityManager.OSC_11_REGEX);
+                    if (match) {
+                        bgReceived = true;
+                        this.terminalBackgroundColor = parseColor(match[1], match[2], match[3]);
+                        // Heuristic: tmux 3.5+ may report #ffffff when it doesn't know the
+                        // actual host terminal color (e.g. over mosh). We ignore this specific
+                        // fallback value to prevent blinding the user with a light theme in a
+                        // likely dark terminal.
+                        if (this.terminalBackgroundColor === '#ffffff' && this.isTmux()) {
+                            debugLogger.log('Ignored #ffffff background in tmux (common false positive over mosh).');
+                            this.terminalBackgroundColor = undefined;
+                        }
+                        else {
+                            debugLogger.log(`Detected terminal background color: ${this.terminalBackgroundColor}`);
+                        }
+                    }
+                }
+                if (!kittyKeyboardReceived &&
+                    TerminalCapabilityManager.KITTY_REGEX.test(buffer)) {
+                    kittyKeyboardReceived = true;
+                    this.kittySupported = true;
+                }
+                // check for modifyOtherKeys support
+                if (!modifyOtherKeysReceived) {
+                    const match = buffer.match(TerminalCapabilityManager.MODIFY_OTHER_KEYS_REGEX);
+                    if (match) {
+                        modifyOtherKeysReceived = true;
+                        const level = parseInt(match[1], 10);
+                        this.modifyOtherKeysSupported = level >= 2;
+                        debugLogger.log(`Detected modifyOtherKeys support: ${this.modifyOtherKeysSupported} (level ${level})`);
+                    }
+                }
+                // Check for Terminal Name/Version response.
+                if (!terminalNameReceived) {
+                    const match = buffer.match(TerminalCapabilityManager.TERMINAL_NAME_REGEX);
+                    if (match) {
+                        terminalNameReceived = true;
+                        this.terminalName = match[1];
+                        debugLogger.log(`Detected terminal name: ${this.terminalName}`);
+                    }
+                }
+                // We use the Primary Device Attributes response as a sentinel to know
+                // that the terminal has processed all our queries. Since we send it
+                // last, receiving it means we can stop waiting.
+                if (!deviceAttributesReceived) {
+                    const match = buffer.match(TerminalCapabilityManager.DEVICE_ATTRIBUTES_REGEX);
+                    if (match) {
+                        deviceAttributesReceived = true;
+                        cleanup();
+                    }
+                }
+            };
+            process.stdin.on('data', onData);
+            try {
+                fs.writeSync(process.stdout.fd, 
+                // Use hidden mode to prevent potential "m" character from being printed
+                // to the terminal during startup when querying for modifyOtherKeys.
+                // This can happen on some terminals that might echo the query or
+                // malform the response. We hide the output, send queries, then
+                // immediately clear the line and reset attributes.
+                TerminalCapabilityManager.HIDDEN_MODE +
+                    TerminalCapabilityManager.KITTY_QUERY +
+                    TerminalCapabilityManager.OSC_11_QUERY +
+                    TerminalCapabilityManager.TERMINAL_NAME_QUERY +
+                    TerminalCapabilityManager.MODIFY_OTHER_KEYS_QUERY +
+                    TerminalCapabilityManager.DEVICE_ATTRIBUTES_QUERY +
+                    TerminalCapabilityManager.CLEAR_LINE_AND_RETURN +
+                    TerminalCapabilityManager.RESET_ATTRIBUTES);
+            }
+            catch (e) {
+                debugLogger.warn('Failed to write terminal capability queries:', e);
+                cleanup();
+            }
+        });
+    }
+    enableSupportedModes() {
+        try {
+            if (this.kittySupported) {
+                debugLogger.log('Enabling Kitty keyboard protocol');
+                enableKittyKeyboardProtocol();
+                this.kittyEnabled = true;
+            }
+            else if (this.modifyOtherKeysSupported) {
+                debugLogger.log('Enabling modifyOtherKeys');
+                enableModifyOtherKeys();
+            }
+            // Always enable bracketed paste since it'll be ignored if unsupported.
+            enableBracketedPasteMode();
+        }
+        catch (e) {
+            debugLogger.warn('Failed to enable keyboard protocols:', e);
+        }
+    }
+    getTerminalBackgroundColor() {
+        return this.terminalBackgroundColor;
+    }
+    getTerminalName() {
+        return this.terminalName;
+    }
+    isKittyProtocolEnabled() {
+        return this.kittyEnabled;
+    }
+    isGhosttyTerminal(env = process.env) {
+        const termProgram = env['TERM_PROGRAM']?.toLowerCase();
+        const term = env['TERM']?.toLowerCase();
+        const name = this.getTerminalName()?.toLowerCase();
+        return !!(name?.includes('ghostty') ||
+            termProgram?.includes('ghostty') ||
+            term?.includes('ghostty'));
+    }
+    isTmux(env = process.env) {
+        return !!env['TMUX'];
+    }
+    isScreen(env = process.env) {
+        return !!env['STY'];
+    }
+    isITerm2(env = process.env) {
+        return !!(this.getTerminalName()?.toLowerCase().includes('iterm') ||
+            env['TERM_PROGRAM']?.toLowerCase().includes('iterm'));
+    }
+    isAlacritty(env = process.env) {
+        return !!(this.getTerminalName()?.toLowerCase().includes('alacritty') ||
+            env['ALACRITTY_WINDOW_ID'] ||
+            env['TERM']?.toLowerCase().includes('alacritty'));
+    }
+    isAppleTerminal(env = process.env) {
+        return !!(this.getTerminalName()?.toLowerCase().includes('apple_terminal') ||
+            env['TERM_PROGRAM']?.toLowerCase().includes('apple_terminal'));
+    }
+    isVSCodeTerminal(env = process.env) {
+        return !!env['TERM_PROGRAM']?.toLowerCase().includes('vscode');
+    }
+    isWindowsTerminal(env = process.env) {
+        return !!env['WT_SESSION'];
+    }
+}
+export const terminalCapabilityManager = TerminalCapabilityManager.getInstance();