@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/ui/commands/chatCommand.js

@@ -0,0 +1,361 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as fsPromises from 'node:fs/promises';
+import React from 'react';
+import { Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { CommandKind } from './types.js';
+import { decodeTagName, INITIAL_HISTORY_LENGTH, } from '@google/gemini-cli-core';
+import path from 'node:path';
+import { MessageType } from '../types.js';
+import { exportHistoryToFile } from '../utils/historyExportUtils.js';
+import { convertToRestPayload } from '@google/gemini-cli-core';
+const CHECKPOINT_MENU_GROUP = 'checkpoints';
+const getSavedChatTags = async (context, mtSortDesc) => {
+    const cfg = context.services.agentContext?.config;
+    const geminiDir = cfg?.storage?.getProjectTempDir();
+    if (!geminiDir) {
+        return [];
+    }
+    try {
+        const file_head = 'checkpoint-';
+        const file_tail = '.json';
+        const files = await fsPromises.readdir(geminiDir);
+        const chatDetails = [];
+        for (const file of files) {
+            if (file.startsWith(file_head) && file.endsWith(file_tail)) {
+                const filePath = path.join(geminiDir, file);
+                const stats = await fsPromises.stat(filePath);
+                const tagName = file.slice(file_head.length, -file_tail.length);
+                chatDetails.push({
+                    name: decodeTagName(tagName),
+                    mtime: stats.mtime.toISOString(),
+                });
+            }
+        }
+        chatDetails.sort((a, b) => mtSortDesc
+            ? b.mtime.localeCompare(a.mtime)
+            : a.mtime.localeCompare(b.mtime));
+        return chatDetails;
+    }
+    catch {
+        return [];
+    }
+};
+const listCommand = {
+    name: 'list',
+    description: 'List saved manual conversation checkpoints',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    takesArgs: false,
+    action: async (context) => {
+        const chatDetails = await getSavedChatTags(context, false);
+        const item = {
+            type: MessageType.CHAT_LIST,
+            chats: chatDetails,
+        };
+        context.ui.addItem(item);
+    },
+};
+const saveCommand = {
+    name: 'save',
+    description: 'Save the current conversation as a checkpoint. Usage: /resume save <tag>',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: false,
+    action: async (context, args) => {
+        const tag = args.trim();
+        if (!tag) {
+            return {
+                type: 'message',
+                messageType: 'error',
+                content: 'Missing tag. Usage: /resume save <tag>',
+            };
+        }
+        const { logger } = context.services;
+        const config = context.services.agentContext?.config;
+        await logger.initialize();
+        if (!context.overwriteConfirmed) {
+            const exists = await logger.checkpointExists(tag);
+            if (exists) {
+                return {
+                    type: 'confirm_action',
+                    prompt: React.createElement(Text, null, 'A checkpoint with the tag ', React.createElement(Text, { color: theme.text.accent }, tag), ' already exists. Do you want to overwrite it?'),
+                    originalInvocation: {
+                        raw: context.invocation?.raw || `/resume save ${tag}`,
+                    },
+                };
+            }
+        }
+        const chat = context.services.agentContext?.geminiClient?.getChat();
+        if (!chat) {
+            return {
+                type: 'message',
+                messageType: 'error',
+                content: 'No chat client available to save conversation.',
+            };
+        }
+        const history = chat.getHistory();
+        if (history.length > INITIAL_HISTORY_LENGTH) {
+            const authType = config?.getContentGeneratorConfig()?.authType;
+            await logger.saveCheckpoint({ history, authType }, tag);
+            return {
+                type: 'message',
+                messageType: 'info',
+                content: `Conversation checkpoint saved with tag: ${decodeTagName(tag)}.`,
+            };
+        }
+        else {
+            return {
+                type: 'message',
+                messageType: 'info',
+                content: 'No conversation found to save.',
+            };
+        }
+    },
+};
+const resumeCheckpointCommand = {
+    name: 'resume',
+    altNames: ['load'],
+    description: 'Resume a conversation from a checkpoint. Usage: /resume resume <tag>',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: async (context, args) => {
+        const tag = args.trim();
+        if (!tag) {
+            return {
+                type: 'message',
+                messageType: 'error',
+                content: 'Missing tag. Usage: /resume resume <tag>',
+            };
+        }
+        const { logger } = context.services;
+        const config = context.services.agentContext?.config;
+        await logger.initialize();
+        const checkpoint = await logger.loadCheckpoint(tag);
+        const conversation = checkpoint.history;
+        if (conversation.length === 0) {
+            return {
+                type: 'message',
+                messageType: 'info',
+                content: `No saved checkpoint found with tag: ${decodeTagName(tag)}.`,
+            };
+        }
+        const currentAuthType = config?.getContentGeneratorConfig()?.authType;
+        if (checkpoint.authType &&
+            currentAuthType &&
+            checkpoint.authType !== currentAuthType) {
+            return {
+                type: 'message',
+                messageType: 'error',
+                content: `Cannot resume chat. It was saved with a different authentication method (${checkpoint.authType}) than the current one (${currentAuthType}).`,
+            };
+        }
+        const rolemap = {
+            user: MessageType.USER,
+            model: MessageType.GEMINI,
+        };
+        const uiHistory = [];
+        for (const item of conversation.slice(INITIAL_HISTORY_LENGTH)) {
+            const text = item.parts
+                ?.filter((m) => !!m.text)
+                .map((m) => m.text)
+                .join('') || '';
+            if (!text) {
+                continue;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            uiHistory.push({
+                type: (item.role && rolemap[item.role]) || MessageType.GEMINI,
+                text,
+            });
+        }
+        return {
+            type: 'load_history',
+            history: uiHistory,
+            clientHistory: conversation,
+        };
+    },
+    completion: async (context, partialArg) => {
+        const chatDetails = await getSavedChatTags(context, true);
+        return chatDetails
+            .map((chat) => chat.name)
+            .filter((name) => name.startsWith(partialArg));
+    },
+};
+const deleteCommand = {
+    name: 'delete',
+    description: 'Delete a conversation checkpoint. Usage: /resume delete <tag>',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: async (context, args) => {
+        const tag = args.trim();
+        if (!tag) {
+            return {
+                type: 'message',
+                messageType: 'error',
+                content: 'Missing tag. Usage: /resume delete <tag>',
+            };
+        }
+        const { logger } = context.services;
+        await logger.initialize();
+        const deleted = await logger.deleteCheckpoint(tag);
+        if (deleted) {
+            return {
+                type: 'message',
+                messageType: 'info',
+                content: `Conversation checkpoint '${decodeTagName(tag)}' has been deleted.`,
+            };
+        }
+        else {
+            return {
+                type: 'message',
+                messageType: 'error',
+                content: `Error: No checkpoint found with tag '${decodeTagName(tag)}'.`,
+            };
+        }
+    },
+    completion: async (context, partialArg) => {
+        const chatDetails = await getSavedChatTags(context, true);
+        return chatDetails
+            .map((chat) => chat.name)
+            .filter((name) => name.startsWith(partialArg));
+    },
+};
+const shareCommand = {
+    name: 'share',
+    description: 'Share the current conversation to a markdown or json file. Usage: /resume share <file>',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: false,
+    action: async (context, args) => {
+        let filePathArg = args.trim();
+        if (!filePathArg) {
+            filePathArg = `gemini-conversation-${Date.now()}.json`;
+        }
+        const filePath = path.resolve(filePathArg);
+        const extension = path.extname(filePath);
+        if (extension !== '.md' && extension !== '.json') {
+            return {
+                type: 'message',
+                messageType: 'error',
+                content: 'Invalid file format. Only .md and .json are supported.',
+            };
+        }
+        const chat = context.services.agentContext?.geminiClient?.getChat();
+        if (!chat) {
+            return {
+                type: 'message',
+                messageType: 'error',
+                content: 'No chat client available to share conversation.',
+            };
+        }
+        const history = chat.getHistory();
+        // An empty conversation has a hidden message that sets up the context for
+        // the chat. Thus, to check whether a conversation has been started, we
+        // can't check for length 0.
+        if (history.length <= INITIAL_HISTORY_LENGTH) {
+            return {
+                type: 'message',
+                messageType: 'info',
+                content: 'No conversation found to share.',
+            };
+        }
+        try {
+            await exportHistoryToFile({ history, filePath });
+            return {
+                type: 'message',
+                messageType: 'info',
+                content: `Conversation shared to ${filePath}`,
+            };
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            return {
+                type: 'message',
+                messageType: 'error',
+                content: `Error sharing conversation: ${errorMessage}`,
+            };
+        }
+    },
+};
+export const debugCommand = {
+    name: 'debug',
+    description: 'Export the most recent API request as a JSON payload',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: async (context) => {
+        const req = context.services.agentContext?.config.getLatestApiRequest();
+        if (!req) {
+            return {
+                type: 'message',
+                messageType: 'error',
+                content: 'No recent API request found to export.',
+            };
+        }
+        const restPayload = convertToRestPayload(req);
+        const filename = `gcli-request-${Date.now()}.json`;
+        const filePath = path.join(process.cwd(), filename);
+        try {
+            await fsPromises.writeFile(filePath, JSON.stringify(restPayload, null, 2));
+            return {
+                type: 'message',
+                messageType: 'info',
+                content: `Debug API request saved to ${filename}`,
+            };
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            return {
+                type: 'message',
+                messageType: 'error',
+                content: `Error saving debug request: ${errorMessage}`,
+            };
+        }
+    },
+};
+export const checkpointSubCommands = [
+    listCommand,
+    saveCommand,
+    resumeCheckpointCommand,
+    deleteCommand,
+    shareCommand,
+];
+const checkpointCompatibilityCommand = {
+    name: 'checkpoints',
+    altNames: ['checkpoint'],
+    description: 'Compatibility command for nested checkpoint operations',
+    kind: CommandKind.BUILT_IN,
+    hidden: true,
+    autoExecute: false,
+    subCommands: checkpointSubCommands,
+};
+export const chatResumeSubCommands = [
+    ...checkpointSubCommands.map((subCommand) => ({
+        ...subCommand,
+        suggestionGroup: CHECKPOINT_MENU_GROUP,
+    })),
+    checkpointCompatibilityCommand,
+];
+import { parseSlashCommand } from '../../utils/commands.js';
+export const chatCommand = {
+    name: 'chat',
+    description: 'Browse auto-saved conversations and manage chat checkpoints',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: async (context, args) => {
+        if (args) {
+            const parsed = parseSlashCommand(`/${args}`, chatResumeSubCommands);
+            if (parsed.commandToExecute?.action) {
+                return parsed.commandToExecute.action(context, parsed.args);
+            }
+        }
+        return {
+            type: 'dialog',
+            dialog: 'sessionBrowser',
+        };
+    },
+    subCommands: chatResumeSubCommands,
+};

package/dist/ui/commands/clearCommand.js

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { uiTelemetryService, SessionEndReason, SessionStartSource, flushTelemetry, resetBrowserSession, } from '@google/gemini-cli-core';
+import { CommandKind } from './types.js';
+import { MessageType } from '../types.js';
+import { randomUUID } from 'node:crypto';
+export const clearCommand = {
+    name: 'clear',
+    altNames: ['new'],
+    description: 'Clear the screen and start a new session',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: async (context, _args) => {
+        const geminiClient = context.services.agentContext?.geminiClient;
+        const config = context.services.agentContext?.config;
+        // Fire SessionEnd hook before clearing
+        const hookSystem = config?.getHookSystem();
+        if (hookSystem) {
+            await hookSystem.fireSessionEndEvent(SessionEndReason.Clear);
+        }
+        // Reset user steering hints
+        config?.injectionService.clear();
+        // Start a new conversation recording with a new session ID
+        // We MUST do this before calling resetChat() so the new ChatRecordingService
+        // initialized by GeminiChat picks up the new session ID.
+        let newSessionId;
+        if (config) {
+            newSessionId = randomUUID();
+            config.resetNewSessionState(newSessionId);
+        }
+        if (geminiClient) {
+            context.ui.setDebugMessage('Clearing terminal and resetting chat.');
+            // Close persistent browser sessions before resetting chat
+            await resetBrowserSession();
+            // If resetChat fails, the exception will propagate and halt the command,
+            // which is the correct behavior to signal a failure to the user.
+            await geminiClient.resetChat();
+        }
+        else {
+            context.ui.setDebugMessage('Clearing terminal.');
+        }
+        // Fire SessionStart hook after clearing
+        let result;
+        if (hookSystem) {
+            result = await hookSystem.fireSessionStartEvent(SessionStartSource.Clear);
+        }
+        // Give the event loop a chance to process any pending telemetry operations
+        // This ensures logger.emit() calls have fully propagated to the BatchLogRecordProcessor
+        await new Promise((resolve) => setImmediate(resolve));
+        // Flush telemetry to ensure hooks are written to disk immediately
+        // This is critical for tests and environments with I/O latency
+        if (config) {
+            await flushTelemetry(config);
+        }
+        uiTelemetryService.clear(newSessionId);
+        context.ui.clear();
+        if (result?.systemMessage) {
+            context.ui.addItem({
+                type: MessageType.INFO,
+                text: result.systemMessage,
+            }, Date.now());
+        }
+    },
+};

package/dist/ui/commands/commandsCommand.js

@@ -0,0 +1,103 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FileCommandLoader } from '../../services/FileCommandLoader.js';
+import { CommandKind, } from './types.js';
+import { MessageType, } from '../types.js';
+/**
+ * Action for the default `/commands` invocation.
+ * Displays a message prompting the user to use a subcommand.
+ */
+async function defaultAction(_context, _args) {
+    return {
+        type: 'message',
+        messageType: 'info',
+        content: 'Use "/commands list" to view available .toml files, or "/commands reload" to reload custom command definitions.',
+    };
+}
+/**
+ * Action for `/commands list`.
+ * Lists available .toml command files from user, project, and extension directories.
+ */
+async function listSubcommandAction(context) {
+    try {
+        const config = context.services.agentContext?.config ?? null;
+        const loader = new FileCommandLoader(config);
+        const groups = await loader.listAvailableFiles();
+        const results = [];
+        for (const group of groups) {
+            results.push(`### ${group.displayName} Commands (${group.path})`);
+            if (group.error) {
+                results.push(`- (Error reading directory: ${group.error})`);
+            }
+            else {
+                group.files.forEach((file) => results.push(`- ${file}`));
+            }
+        }
+        results.push('\n_Note: MCP prompts are dynamically loaded from configured MCP servers._');
+        if (results.length === 1) {
+            // Only the note is present
+            return {
+                type: 'message',
+                messageType: 'info',
+                content: 'No custom command files (.toml) found.\n\n_Note: MCP prompts are dynamically loaded from configured MCP servers._',
+            };
+        }
+        context.ui.addItem({
+            type: MessageType.INFO,
+            text: results.join('\n'),
+        }, Date.now());
+    }
+    catch (error) {
+        context.ui.addItem({
+            type: MessageType.ERROR,
+            text: `Failed to list commands: ${error instanceof Error ? error.message : String(error)}`,
+        }, Date.now());
+    }
+}
+/**
+ * Action for `/commands reload`.
+ * Triggers a full re-discovery and reload of all slash commands, including
+ * user/project-level .toml files, MCP prompts, and extension commands.
+ */
+async function reloadAction(context) {
+    try {
+        context.ui.reloadCommands();
+        context.ui.addItem({
+            type: MessageType.INFO,
+            text: 'Custom commands reloaded successfully.',
+        }, Date.now());
+    }
+    catch (error) {
+        context.ui.addItem({
+            type: MessageType.ERROR,
+            text: `Failed to reload commands: ${error instanceof Error ? error.message : String(error)}`,
+        }, Date.now());
+    }
+}
+export const commandsCommand = {
+    name: 'commands',
+    description: 'Manage custom slash commands. Usage: /commands [list|reload]',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: false,
+    subCommands: [
+        {
+            name: 'list',
+            description: 'List available custom command .toml files. Usage: /commands list',
+            kind: CommandKind.BUILT_IN,
+            autoExecute: true,
+            action: listSubcommandAction,
+        },
+        {
+            name: 'reload',
+            altNames: ['refresh'],
+            description: 'Reload custom command definitions from .toml files. Usage: /commands reload',
+            kind: CommandKind.BUILT_IN,
+            autoExecute: true,
+            action: reloadAction,
+        },
+    ],
+    action: defaultAction,
+};

package/dist/ui/commands/compressCommand.js

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MessageType } from '../types.js';
+import { CommandKind } from './types.js';
+export const compressCommand = {
+    name: 'compress',
+    altNames: ['summarize', 'compact'],
+    description: 'Compresses the context by replacing it with a summary',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: async (context) => {
+        const { ui } = context;
+        if (ui.pendingItem) {
+            ui.addItem({
+                type: MessageType.ERROR,
+                text: 'Already compressing, wait for previous request to complete',
+            }, Date.now());
+            return;
+        }
+        const pendingMessage = {
+            type: MessageType.COMPRESSION,
+            compression: {
+                isPending: true,
+                originalTokenCount: null,
+                newTokenCount: null,
+                compressionStatus: null,
+            },
+        };
+        ui.setPendingItem(pendingMessage);
+        void (async () => {
+            try {
+                const promptId = `compress-${Date.now()}`;
+                const compressed = await context.services.agentContext?.geminiClient?.tryCompressChat(promptId, true);
+                if (compressed) {
+                    ui.addItem({
+                        type: MessageType.COMPRESSION,
+                        compression: {
+                            isPending: false,
+                            originalTokenCount: compressed.originalTokenCount,
+                            newTokenCount: compressed.newTokenCount,
+                            compressionStatus: compressed.compressionStatus,
+                        },
+                    }, Date.now());
+                }
+                else {
+                    ui.addItem({
+                        type: MessageType.ERROR,
+                        text: 'Failed to compress chat history.',
+                    }, Date.now());
+                }
+            }
+            catch (e) {
+                ui.addItem({
+                    type: MessageType.ERROR,
+                    text: `Failed to compress chat history: ${e instanceof Error ? e.message : String(e)}`,
+                }, Date.now());
+            }
+            finally {
+                ui.setPendingItem(null);
+            }
+        })();
+    },
+};

package/dist/ui/commands/copyCommand.js

@@ -0,0 +1,61 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { debugLogger } from '@google/gemini-cli-core';
+import { copyToClipboard } from '../utils/commandUtils.js';
+import { CommandKind, } from './types.js';
+export const copyCommand = {
+    name: 'copy',
+    description: 'Copy the last result or code snippet to clipboard',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: async (context, _args) => {
+        const chat = context.services.agentContext?.geminiClient?.getChat();
+        const history = chat?.getHistory();
+        // Get the last message from the AI (model role)
+        const lastAiMessage = history
+            ? history.filter((item) => item.role === 'model').pop()
+            : undefined;
+        if (!lastAiMessage) {
+            return {
+                type: 'message',
+                messageType: 'info',
+                content: 'No output in history',
+            };
+        }
+        // Extract text from the parts
+        const lastAiOutput = lastAiMessage.parts
+            ?.filter((part) => part.text)
+            .map((part) => part.text)
+            .join('');
+        if (lastAiOutput) {
+            try {
+                const settings = context.services.settings.merged;
+                await copyToClipboard(lastAiOutput, settings);
+                return {
+                    type: 'message',
+                    messageType: 'info',
+                    content: 'Last output copied to the clipboard',
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                debugLogger.debug(message);
+                return {
+                    type: 'message',
+                    messageType: 'error',
+                    content: `Failed to copy to the clipboard. ${message}`,
+                };
+            }
+        }
+        else {
+            return {
+                type: 'message',
+                messageType: 'info',
+                content: 'Last AI output contains no text to copy.',
+            };
+        }
+    },
+};

package/dist/ui/commands/corgiCommand.js

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CommandKind } from './types.js';
+export const corgiCommand = {
+    name: 'corgi',
+    description: 'Toggles corgi mode',
+    hidden: true,
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: (context, _args) => {
+        context.ui.toggleCorgiMode();
+    },
+};