@google/gemini-cli 0.1.9-rc.1 → 0.1.10-dev.0

package/dist/src/ui/hooks/slashCommandProcessor.js

@@ -1,965 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { useCallback, useMemo } from 'react';
-import open from 'open';
-import process from 'node:process';
-import { useStateAndRef } from './useStateAndRef.js';
-import { GitService, Logger, MCPDiscoveryState, MCPServerStatus, getMCPDiscoveryState, getMCPServerStatus, } from '@google/gemini-cli-core';
-import { useSessionStats } from '../contexts/SessionContext.js';
-import { MessageType, } from '../types.js';
-import { promises as fs } from 'fs';
-import path from 'path';
-import { createShowMemoryAction } from './useShowMemoryCommand.js';
-import { GIT_COMMIT_INFO } from '../../generated/git-commit.js';
-import { formatDuration, formatMemoryUsage } from '../utils/formatters.js';
-import { getCliVersion } from '../../utils/version.js';
-/**
- * Hook to define and process slash commands (e.g., /help, /clear).
- */
-export const useSlashCommandProcessor = (config, settings, history, addItem, clearItems, loadHistory, refreshStatic, setShowHelp, onDebugMessage, openThemeDialog, openAuthDialog, openEditorDialog, performMemoryRefresh, toggleCorgiMode, showToolDescriptions = false, setQuittingMessages, openPrivacyNotice) => {
-    const session = useSessionStats();
-    const gitService = useMemo(() => {
-        if (!config?.getProjectRoot()) {
-            return;
-        }
-        return new GitService(config.getProjectRoot());
-    }, [config]);
-    const pendingHistoryItems = [];
-    const [pendingCompressionItemRef, setPendingCompressionItem] = useStateAndRef(null);
-    if (pendingCompressionItemRef.current != null) {
-        pendingHistoryItems.push(pendingCompressionItemRef.current);
-    }
-    const addMessage = useCallback((message) => {
-        // Convert Message to HistoryItemWithoutId
-        let historyItemContent;
-        if (message.type === MessageType.ABOUT) {
-            historyItemContent = {
-                type: 'about',
-                cliVersion: message.cliVersion,
-                osVersion: message.osVersion,
-                sandboxEnv: message.sandboxEnv,
-                modelVersion: message.modelVersion,
-                selectedAuthType: message.selectedAuthType,
-                gcpProject: message.gcpProject,
-            };
-        }
-        else if (message.type === MessageType.STATS) {
-            historyItemContent = {
-                type: 'stats',
-                duration: message.duration,
-            };
-        }
-        else if (message.type === MessageType.MODEL_STATS) {
-            historyItemContent = {
-                type: 'model_stats',
-            };
-        }
-        else if (message.type === MessageType.TOOL_STATS) {
-            historyItemContent = {
-                type: 'tool_stats',
-            };
-        }
-        else if (message.type === MessageType.QUIT) {
-            historyItemContent = {
-                type: 'quit',
-                duration: message.duration,
-            };
-        }
-        else if (message.type === MessageType.COMPRESSION) {
-            historyItemContent = {
-                type: 'compression',
-                compression: message.compression,
-            };
-        }
-        else {
-            historyItemContent = {
-                type: message.type,
-                text: message.content,
-            };
-        }
-        addItem(historyItemContent, message.timestamp.getTime());
-    }, [addItem]);
-    const showMemoryAction = useCallback(async () => {
-        const actionFn = createShowMemoryAction(config, settings, addMessage);
-        await actionFn();
-    }, [config, settings, addMessage]);
-    const addMemoryAction = useCallback((_mainCommand, _subCommand, args) => {
-        if (!args || args.trim() === '') {
-            addMessage({
-                type: MessageType.ERROR,
-                content: 'Usage: /memory add <text to remember>',
-                timestamp: new Date(),
-            });
-            return;
-        }
-        // UI feedback for attempting to schedule
-        addMessage({
-            type: MessageType.INFO,
-            content: `Attempting to save to memory: "${args.trim()}"`,
-            timestamp: new Date(),
-        });
-        // Return info for scheduling the tool call
-        return {
-            shouldScheduleTool: true,
-            toolName: 'save_memory',
-            toolArgs: { fact: args.trim() },
-        };
-    }, [addMessage]);
-    const savedChatTags = useCallback(async () => {
-        const geminiDir = config?.getProjectTempDir();
-        if (!geminiDir) {
-            return [];
-        }
-        try {
-            const files = await fs.readdir(geminiDir);
-            return files
-                .filter((file) => file.startsWith('checkpoint-') && file.endsWith('.json'))
-                .map((file) => file.replace('checkpoint-', '').replace('.json', ''));
-        }
-        catch (_err) {
-            return [];
-        }
-    }, [config]);
-    const slashCommands = useMemo(() => {
-        const commands = [
-            {
-                name: 'help',
-                altName: '?',
-                description: 'for help on gemini-cli',
-                action: (_mainCommand, _subCommand, _args) => {
-                    onDebugMessage('Opening help.');
-                    setShowHelp(true);
-                },
-            },
-            {
-                name: 'docs',
-                description: 'open full Gemini CLI documentation in your browser',
-                action: async (_mainCommand, _subCommand, _args) => {
-                    const docsUrl = 'https://goo.gle/gemini-cli-docs';
-                    if (process.env.SANDBOX && process.env.SANDBOX !== 'sandbox-exec') {
-                        addMessage({
-                            type: MessageType.INFO,
-                            content: `Please open the following URL in your browser to view the documentation:\n${docsUrl}`,
-                            timestamp: new Date(),
-                        });
-                    }
-                    else {
-                        addMessage({
-                            type: MessageType.INFO,
-                            content: `Opening documentation in your browser: ${docsUrl}`,
-                            timestamp: new Date(),
-                        });
-                        await open(docsUrl);
-                    }
-                },
-            },
-            {
-                name: 'clear',
-                description: 'clear the screen and conversation history',
-                action: async (_mainCommand, _subCommand, _args) => {
-                    onDebugMessage('Clearing terminal and resetting chat.');
-                    clearItems();
-                    await config?.getGeminiClient()?.resetChat();
-                    console.clear();
-                    refreshStatic();
-                },
-            },
-            {
-                name: 'theme',
-                description: 'change the theme',
-                action: (_mainCommand, _subCommand, _args) => {
-                    openThemeDialog();
-                },
-            },
-            {
-                name: 'auth',
-                description: 'change the auth method',
-                action: (_mainCommand, _subCommand, _args) => {
-                    openAuthDialog();
-                },
-            },
-            {
-                name: 'editor',
-                description: 'set external editor preference',
-                action: (_mainCommand, _subCommand, _args) => {
-                    openEditorDialog();
-                },
-            },
-            {
-                name: 'privacy',
-                description: 'display the privacy notice',
-                action: (_mainCommand, _subCommand, _args) => {
-                    openPrivacyNotice();
-                },
-            },
-            {
-                name: 'stats',
-                altName: 'usage',
-                description: 'check session stats. Usage: /stats [model|tools]',
-                action: (_mainCommand, subCommand, _args) => {
-                    if (subCommand === 'model') {
-                        addMessage({
-                            type: MessageType.MODEL_STATS,
-                            timestamp: new Date(),
-                        });
-                        return;
-                    }
-                    else if (subCommand === 'tools') {
-                        addMessage({
-                            type: MessageType.TOOL_STATS,
-                            timestamp: new Date(),
-                        });
-                        return;
-                    }
-                    const now = new Date();
-                    const { sessionStartTime } = session.stats;
-                    const wallDuration = now.getTime() - sessionStartTime.getTime();
-                    addMessage({
-                        type: MessageType.STATS,
-                        duration: formatDuration(wallDuration),
-                        timestamp: new Date(),
-                    });
-                },
-            },
-            {
-                name: 'mcp',
-                description: 'list configured MCP servers and tools',
-                action: async (_mainCommand, _subCommand, _args) => {
-                    // Check if the _subCommand includes a specific flag to control description visibility
-                    let useShowDescriptions = showToolDescriptions;
-                    if (_subCommand === 'desc' || _subCommand === 'descriptions') {
-                        useShowDescriptions = true;
-                    }
-                    else if (_subCommand === 'nodesc' ||
-                        _subCommand === 'nodescriptions') {
-                        useShowDescriptions = false;
-                    }
-                    else if (_args === 'desc' || _args === 'descriptions') {
-                        useShowDescriptions = true;
-                    }
-                    else if (_args === 'nodesc' || _args === 'nodescriptions') {
-                        useShowDescriptions = false;
-                    }
-                    // Check if the _subCommand includes a specific flag to show detailed tool schema
-                    let useShowSchema = false;
-                    if (_subCommand === 'schema' || _args === 'schema') {
-                        useShowSchema = true;
-                    }
-                    const toolRegistry = await config?.getToolRegistry();
-                    if (!toolRegistry) {
-                        addMessage({
-                            type: MessageType.ERROR,
-                            content: 'Could not retrieve tool registry.',
-                            timestamp: new Date(),
-                        });
-                        return;
-                    }
-                    const mcpServers = config?.getMcpServers() || {};
-                    const serverNames = Object.keys(mcpServers);
-                    if (serverNames.length === 0) {
-                        const docsUrl = 'https://goo.gle/gemini-cli-docs-mcp';
-                        if (process.env.SANDBOX && process.env.SANDBOX !== 'sandbox-exec') {
-                            addMessage({
-                                type: MessageType.INFO,
-                                content: `No MCP servers configured. Please open the following URL in your browser to view documentation:\n${docsUrl}`,
-                                timestamp: new Date(),
-                            });
-                        }
-                        else {
-                            addMessage({
-                                type: MessageType.INFO,
-                                content: `No MCP servers configured. Opening documentation in your browser: ${docsUrl}`,
-                                timestamp: new Date(),
-                            });
-                            await open(docsUrl);
-                        }
-                        return;
-                    }
-                    // Check if any servers are still connecting
-                    const connectingServers = serverNames.filter((name) => getMCPServerStatus(name) === MCPServerStatus.CONNECTING);
-                    const discoveryState = getMCPDiscoveryState();
-                    let message = '';
-                    // Add overall discovery status message if needed
-                    if (discoveryState === MCPDiscoveryState.IN_PROGRESS ||
-                        connectingServers.length > 0) {
-                        message += `\u001b[33m⏳ MCP servers are starting up (${connectingServers.length} initializing)...\u001b[0m\n`;
-                        message += `\u001b[90mNote: First startup may take longer. Tool availability will update automatically.\u001b[0m\n\n`;
-                    }
-                    message += 'Configured MCP servers:\n\n';
-                    for (const serverName of serverNames) {
-                        const serverTools = toolRegistry.getToolsByServer(serverName);
-                        const status = getMCPServerStatus(serverName);
-                        // Add status indicator with descriptive text
-                        let statusIndicator = '';
-                        let statusText = '';
-                        switch (status) {
-                            case MCPServerStatus.CONNECTED:
-                                statusIndicator = '🟢';
-                                statusText = 'Ready';
-                                break;
-                            case MCPServerStatus.CONNECTING:
-                                statusIndicator = '🔄';
-                                statusText = 'Starting... (first startup may take longer)';
-                                break;
-                            case MCPServerStatus.DISCONNECTED:
-                            default:
-                                statusIndicator = '🔴';
-                                statusText = 'Disconnected';
-                                break;
-                        }
-                        // Get server description if available
-                        const server = mcpServers[serverName];
-                        // Format server header with bold formatting and status
-                        message += `${statusIndicator} \u001b[1m${serverName}\u001b[0m - ${statusText}`;
-                        // Add tool count with conditional messaging
-                        if (status === MCPServerStatus.CONNECTED) {
-                            message += ` (${serverTools.length} tools)`;
-                        }
-                        else if (status === MCPServerStatus.CONNECTING) {
-                            message += ` (tools will appear when ready)`;
-                        }
-                        else {
-                            message += ` (${serverTools.length} tools cached)`;
-                        }
-                        // Add server description with proper handling of multi-line descriptions
-                        if ((useShowDescriptions || useShowSchema) && server?.description) {
-                            const greenColor = '\u001b[32m';
-                            const resetColor = '\u001b[0m';
-                            const descLines = server.description.trim().split('\n');
-                            if (descLines) {
-                                message += ':\n';
-                                for (const descLine of descLines) {
-                                    message += `    ${greenColor}${descLine}${resetColor}\n`;
-                                }
-                            }
-                            else {
-                                message += '\n';
-                            }
-                        }
-                        else {
-                            message += '\n';
-                        }
-                        // Reset formatting after server entry
-                        message += '\u001b[0m';
-                        if (serverTools.length > 0) {
-                            serverTools.forEach((tool) => {
-                                if ((useShowDescriptions || useShowSchema) &&
-                                    tool.description) {
-                                    // Format tool name in cyan using simple ANSI cyan color
-                                    message += `  - \u001b[36m${tool.name}\u001b[0m`;
-                                    // Apply green color to the description text
-                                    const greenColor = '\u001b[32m';
-                                    const resetColor = '\u001b[0m';
-                                    // Handle multi-line descriptions by properly indenting and preserving formatting
-                                    const descLines = tool.description.trim().split('\n');
-                                    if (descLines) {
-                                        message += ':\n';
-                                        for (const descLine of descLines) {
-                                            message += `      ${greenColor}${descLine}${resetColor}\n`;
-                                        }
-                                    }
-                                    else {
-                                        message += '\n';
-                                    }
-                                    // Reset is handled inline with each line now
-                                }
-                                else {
-                                    // Use cyan color for the tool name even when not showing descriptions
-                                    message += `  - \u001b[36m${tool.name}\u001b[0m\n`;
-                                }
-                                if (useShowSchema) {
-                                    // Prefix the parameters in cyan
-                                    message += `    \u001b[36mParameters:\u001b[0m\n`;
-                                    // Apply green color to the parameter text
-                                    const greenColor = '\u001b[32m';
-                                    const resetColor = '\u001b[0m';
-                                    const paramsLines = JSON.stringify(tool.schema.parameters, null, 2)
-                                        .trim()
-                                        .split('\n');
-                                    if (paramsLines) {
-                                        for (const paramsLine of paramsLines) {
-                                            message += `      ${greenColor}${paramsLine}${resetColor}\n`;
-                                        }
-                                    }
-                                }
-                            });
-                        }
-                        else {
-                            message += '  No tools available\n';
-                        }
-                        message += '\n';
-                    }
-                    // Make sure to reset any ANSI formatting at the end to prevent it from affecting the terminal
-                    message += '\u001b[0m';
-                    addMessage({
-                        type: MessageType.INFO,
-                        content: message,
-                        timestamp: new Date(),
-                    });
-                },
-            },
-            {
-                name: 'memory',
-                description: 'manage memory. Usage: /memory <show|refresh|add> [text for add]',
-                action: (mainCommand, subCommand, args) => {
-                    switch (subCommand) {
-                        case 'show':
-                            showMemoryAction();
-                            return;
-                        case 'refresh':
-                            performMemoryRefresh();
-                            return;
-                        case 'add':
-                            return addMemoryAction(mainCommand, subCommand, args); // Return the object
-                        case undefined:
-                            addMessage({
-                                type: MessageType.ERROR,
-                                content: 'Missing command\nUsage: /memory <show|refresh|add> [text for add]',
-                                timestamp: new Date(),
-                            });
-                            return;
-                        default:
-                            addMessage({
-                                type: MessageType.ERROR,
-                                content: `Unknown /memory command: ${subCommand}. Available: show, refresh, add`,
-                                timestamp: new Date(),
-                            });
-                            return;
-                    }
-                },
-            },
-            {
-                name: 'tools',
-                description: 'list available Gemini CLI tools',
-                action: async (_mainCommand, _subCommand, _args) => {
-                    // Check if the _subCommand includes a specific flag to control description visibility
-                    let useShowDescriptions = showToolDescriptions;
-                    if (_subCommand === 'desc' || _subCommand === 'descriptions') {
-                        useShowDescriptions = true;
-                    }
-                    else if (_subCommand === 'nodesc' ||
-                        _subCommand === 'nodescriptions') {
-                        useShowDescriptions = false;
-                    }
-                    else if (_args === 'desc' || _args === 'descriptions') {
-                        useShowDescriptions = true;
-                    }
-                    else if (_args === 'nodesc' || _args === 'nodescriptions') {
-                        useShowDescriptions = false;
-                    }
-                    const toolRegistry = await config?.getToolRegistry();
-                    const tools = toolRegistry?.getAllTools();
-                    if (!tools) {
-                        addMessage({
-                            type: MessageType.ERROR,
-                            content: 'Could not retrieve tools.',
-                            timestamp: new Date(),
-                        });
-                        return;
-                    }
-                    // Filter out MCP tools by checking if they have a serverName property
-                    const geminiTools = tools.filter((tool) => !('serverName' in tool));
-                    let message = 'Available Gemini CLI tools:\n\n';
-                    if (geminiTools.length > 0) {
-                        geminiTools.forEach((tool) => {
-                            if (useShowDescriptions && tool.description) {
-                                // Format tool name in cyan using simple ANSI cyan color
-                                message += `  - \u001b[36m${tool.displayName} (${tool.name})\u001b[0m:\n`;
-                                // Apply green color to the description text
-                                const greenColor = '\u001b[32m';
-                                const resetColor = '\u001b[0m';
-                                // Handle multi-line descriptions by properly indenting and preserving formatting
-                                const descLines = tool.description.trim().split('\n');
-                                // If there are multiple lines, add proper indentation for each line
-                                if (descLines) {
-                                    for (const descLine of descLines) {
-                                        message += `      ${greenColor}${descLine}${resetColor}\n`;
-                                    }
-                                }
-                            }
-                            else {
-                                // Use cyan color for the tool name even when not showing descriptions
-                                message += `  - \u001b[36m${tool.displayName}\u001b[0m\n`;
-                            }
-                        });
-                    }
-                    else {
-                        message += '  No tools available\n';
-                    }
-                    message += '\n';
-                    // Make sure to reset any ANSI formatting at the end to prevent it from affecting the terminal
-                    message += '\u001b[0m';
-                    addMessage({
-                        type: MessageType.INFO,
-                        content: message,
-                        timestamp: new Date(),
-                    });
-                },
-            },
-            {
-                name: 'corgi',
-                action: (_mainCommand, _subCommand, _args) => {
-                    toggleCorgiMode();
-                },
-            },
-            {
-                name: 'about',
-                description: 'show version info',
-                action: async (_mainCommand, _subCommand, _args) => {
-                    const osVersion = process.platform;
-                    let sandboxEnv = 'no sandbox';
-                    if (process.env.SANDBOX && process.env.SANDBOX !== 'sandbox-exec') {
-                        sandboxEnv = process.env.SANDBOX;
-                    }
-                    else if (process.env.SANDBOX === 'sandbox-exec') {
-                        sandboxEnv = `sandbox-exec (${process.env.SEATBELT_PROFILE || 'unknown'})`;
-                    }
-                    const modelVersion = config?.getModel() || 'Unknown';
-                    const cliVersion = await getCliVersion();
-                    const selectedAuthType = settings.merged.selectedAuthType || '';
-                    const gcpProject = process.env.GOOGLE_CLOUD_PROJECT || '';
-                    addMessage({
-                        type: MessageType.ABOUT,
-                        timestamp: new Date(),
-                        cliVersion,
-                        osVersion,
-                        sandboxEnv,
-                        modelVersion,
-                        selectedAuthType,
-                        gcpProject,
-                    });
-                },
-            },
-            {
-                name: 'bug',
-                description: 'submit a bug report',
-                action: async (_mainCommand, _subCommand, args) => {
-                    let bugDescription = _subCommand || '';
-                    if (args) {
-                        bugDescription += ` ${args}`;
-                    }
-                    bugDescription = bugDescription.trim();
-                    const osVersion = `${process.platform} ${process.version}`;
-                    let sandboxEnv = 'no sandbox';
-                    if (process.env.SANDBOX && process.env.SANDBOX !== 'sandbox-exec') {
-                        sandboxEnv = process.env.SANDBOX.replace(/^gemini-(?:code-)?/, '');
-                    }
-                    else if (process.env.SANDBOX === 'sandbox-exec') {
-                        sandboxEnv = `sandbox-exec (${process.env.SEATBELT_PROFILE || 'unknown'})`;
-                    }
-                    const modelVersion = config?.getModel() || 'Unknown';
-                    const cliVersion = await getCliVersion();
-                    const memoryUsage = formatMemoryUsage(process.memoryUsage().rss);
-                    const info = `
-*   **CLI Version:** ${cliVersion}
-*   **Git Commit:** ${GIT_COMMIT_INFO}
-*   **Operating System:** ${osVersion}
-*   **Sandbox Environment:** ${sandboxEnv}
-*   **Model Version:** ${modelVersion}
-*   **Memory Usage:** ${memoryUsage}
-`;
-                    let bugReportUrl = 'https://github.com/google-gemini/gemini-cli/issues/new?template=bug_report.yml&title={title}&info={info}';
-                    const bugCommand = config?.getBugCommand();
-                    if (bugCommand?.urlTemplate) {
-                        bugReportUrl = bugCommand.urlTemplate;
-                    }
-                    bugReportUrl = bugReportUrl
-                        .replace('{title}', encodeURIComponent(bugDescription))
-                        .replace('{info}', encodeURIComponent(info));
-                    addMessage({
-                        type: MessageType.INFO,
-                        content: `To submit your bug report, please open the following URL in your browser:\n${bugReportUrl}`,
-                        timestamp: new Date(),
-                    });
-                    (async () => {
-                        try {
-                            await open(bugReportUrl);
-                        }
-                        catch (error) {
-                            const errorMessage = error instanceof Error ? error.message : String(error);
-                            addMessage({
-                                type: MessageType.ERROR,
-                                content: `Could not open URL in browser: ${errorMessage}`,
-                                timestamp: new Date(),
-                            });
-                        }
-                    })();
-                },
-            },
-            {
-                name: 'chat',
-                description: 'Manage conversation history. Usage: /chat <list|save|resume> [tag]',
-                action: async (_mainCommand, subCommand, args) => {
-                    const tag = (args || '').trim();
-                    const logger = new Logger(config?.getSessionId() || '');
-                    await logger.initialize();
-                    const chat = await config?.getGeminiClient()?.getChat();
-                    if (!chat) {
-                        addMessage({
-                            type: MessageType.ERROR,
-                            content: 'No chat client available for conversation status.',
-                            timestamp: new Date(),
-                        });
-                        return;
-                    }
-                    if (!subCommand) {
-                        addMessage({
-                            type: MessageType.ERROR,
-                            content: 'Missing command\nUsage: /chat <list|save|resume> [tag]',
-                            timestamp: new Date(),
-                        });
-                        return;
-                    }
-                    switch (subCommand) {
-                        case 'save': {
-                            const history = chat.getHistory();
-                            if (history.length > 0) {
-                                await logger.saveCheckpoint(chat?.getHistory() || [], tag);
-                                addMessage({
-                                    type: MessageType.INFO,
-                                    content: `Conversation checkpoint saved${tag ? ' with tag: ' + tag : ''}.`,
-                                    timestamp: new Date(),
-                                });
-                            }
-                            else {
-                                addMessage({
-                                    type: MessageType.INFO,
-                                    content: 'No conversation found to save.',
-                                    timestamp: new Date(),
-                                });
-                            }
-                            return;
-                        }
-                        case 'resume':
-                        case 'restore':
-                        case 'load': {
-                            const conversation = await logger.loadCheckpoint(tag);
-                            if (conversation.length === 0) {
-                                addMessage({
-                                    type: MessageType.INFO,
-                                    content: `No saved checkpoint found${tag ? ' with tag: ' + tag : ''}.`,
-                                    timestamp: new Date(),
-                                });
-                                return;
-                            }
-                            clearItems();
-                            chat.clearHistory();
-                            const rolemap = {
-                                user: MessageType.USER,
-                                model: MessageType.GEMINI,
-                            };
-                            let hasSystemPrompt = false;
-                            let i = 0;
-                            for (const item of conversation) {
-                                i += 1;
-                                // Add each item to history regardless of whether we display
-                                // it.
-                                chat.addHistory(item);
-                                const text = item.parts
-                                    ?.filter((m) => !!m.text)
-                                    .map((m) => m.text)
-                                    .join('') || '';
-                                if (!text) {
-                                    // Parsing Part[] back to various non-text output not yet implemented.
-                                    continue;
-                                }
-                                if (i === 1 && text.match(/context for our chat/)) {
-                                    hasSystemPrompt = true;
-                                }
-                                if (i > 2 || !hasSystemPrompt) {
-                                    addItem({
-                                        type: (item.role && rolemap[item.role]) || MessageType.GEMINI,
-                                        text,
-                                    }, i);
-                                }
-                            }
-                            console.clear();
-                            refreshStatic();
-                            return;
-                        }
-                        case 'list':
-                            addMessage({
-                                type: MessageType.INFO,
-                                content: 'list of saved conversations: ' +
-                                    (await savedChatTags()).join(', '),
-                                timestamp: new Date(),
-                            });
-                            return;
-                        default:
-                            addMessage({
-                                type: MessageType.ERROR,
-                                content: `Unknown /chat command: ${subCommand}. Available: list, save, resume`,
-                                timestamp: new Date(),
-                            });
-                            return;
-                    }
-                },
-                completion: async () => (await savedChatTags()).map((tag) => 'resume ' + tag),
-            },
-            {
-                name: 'quit',
-                altName: 'exit',
-                description: 'exit the cli',
-                action: async (mainCommand, _subCommand, _args) => {
-                    const now = new Date();
-                    const { sessionStartTime } = session.stats;
-                    const wallDuration = now.getTime() - sessionStartTime.getTime();
-                    setQuittingMessages([
-                        {
-                            type: 'user',
-                            text: `/${mainCommand}`,
-                            id: now.getTime() - 1,
-                        },
-                        {
-                            type: 'quit',
-                            duration: formatDuration(wallDuration),
-                            id: now.getTime(),
-                        },
-                    ]);
-                    setTimeout(() => {
-                        process.exit(0);
-                    }, 100);
-                },
-            },
-            {
-                name: 'compress',
-                altName: 'summarize',
-                description: 'Compresses the context by replacing it with a summary.',
-                action: async (_mainCommand, _subCommand, _args) => {
-                    if (pendingCompressionItemRef.current !== null) {
-                        addMessage({
-                            type: MessageType.ERROR,
-                            content: 'Already compressing, wait for previous request to complete',
-                            timestamp: new Date(),
-                        });
-                        return;
-                    }
-                    setPendingCompressionItem({
-                        type: MessageType.COMPRESSION,
-                        compression: {
-                            isPending: true,
-                            originalTokenCount: null,
-                            newTokenCount: null,
-                        },
-                    });
-                    try {
-                        const compressed = await config
-                            .getGeminiClient()
-                            .tryCompressChat(true);
-                        if (compressed) {
-                            addMessage({
-                                type: MessageType.COMPRESSION,
-                                compression: {
-                                    isPending: false,
-                                    originalTokenCount: compressed.originalTokenCount,
-                                    newTokenCount: compressed.newTokenCount,
-                                },
-                                timestamp: new Date(),
-                            });
-                        }
-                        else {
-                            addMessage({
-                                type: MessageType.ERROR,
-                                content: 'Failed to compress chat history.',
-                                timestamp: new Date(),
-                            });
-                        }
-                    }
-                    catch (e) {
-                        addMessage({
-                            type: MessageType.ERROR,
-                            content: `Failed to compress chat history: ${e instanceof Error ? e.message : String(e)}`,
-                            timestamp: new Date(),
-                        });
-                    }
-                    setPendingCompressionItem(null);
-                },
-            },
-        ];
-        if (config?.getCheckpointingEnabled()) {
-            commands.push({
-                name: 'restore',
-                description: 'restore a tool call. This will reset the conversation and file history to the state it was in when the tool call was suggested',
-                completion: async () => {
-                    const checkpointDir = config?.getProjectTempDir()
-                        ? path.join(config.getProjectTempDir(), 'checkpoints')
-                        : undefined;
-                    if (!checkpointDir) {
-                        return [];
-                    }
-                    try {
-                        const files = await fs.readdir(checkpointDir);
-                        return files
-                            .filter((file) => file.endsWith('.json'))
-                            .map((file) => file.replace('.json', ''));
-                    }
-                    catch (_err) {
-                        return [];
-                    }
-                },
-                action: async (_mainCommand, subCommand, _args) => {
-                    const checkpointDir = config?.getProjectTempDir()
-                        ? path.join(config.getProjectTempDir(), 'checkpoints')
-                        : undefined;
-                    if (!checkpointDir) {
-                        addMessage({
-                            type: MessageType.ERROR,
-                            content: 'Could not determine the .gemini directory path.',
-                            timestamp: new Date(),
-                        });
-                        return;
-                    }
-                    try {
-                        // Ensure the directory exists before trying to read it.
-                        await fs.mkdir(checkpointDir, { recursive: true });
-                        const files = await fs.readdir(checkpointDir);
-                        const jsonFiles = files.filter((file) => file.endsWith('.json'));
-                        if (!subCommand) {
-                            if (jsonFiles.length === 0) {
-                                addMessage({
-                                    type: MessageType.INFO,
-                                    content: 'No restorable tool calls found.',
-                                    timestamp: new Date(),
-                                });
-                                return;
-                            }
-                            const truncatedFiles = jsonFiles.map((file) => {
-                                const components = file.split('.');
-                                if (components.length <= 1) {
-                                    return file;
-                                }
-                                components.pop();
-                                return components.join('.');
-                            });
-                            const fileList = truncatedFiles.join('\n');
-                            addMessage({
-                                type: MessageType.INFO,
-                                content: `Available tool calls to restore:\n\n${fileList}`,
-                                timestamp: new Date(),
-                            });
-                            return;
-                        }
-                        const selectedFile = subCommand.endsWith('.json')
-                            ? subCommand
-                            : `${subCommand}.json`;
-                        if (!jsonFiles.includes(selectedFile)) {
-                            addMessage({
-                                type: MessageType.ERROR,
-                                content: `File not found: ${selectedFile}`,
-                                timestamp: new Date(),
-                            });
-                            return;
-                        }
-                        const filePath = path.join(checkpointDir, selectedFile);
-                        const data = await fs.readFile(filePath, 'utf-8');
-                        const toolCallData = JSON.parse(data);
-                        if (toolCallData.history) {
-                            loadHistory(toolCallData.history);
-                        }
-                        if (toolCallData.clientHistory) {
-                            await config
-                                ?.getGeminiClient()
-                                ?.setHistory(toolCallData.clientHistory);
-                        }
-                        if (toolCallData.commitHash) {
-                            await gitService?.restoreProjectFromSnapshot(toolCallData.commitHash);
-                            addMessage({
-                                type: MessageType.INFO,
-                                content: `Restored project to the state before the tool call.`,
-                                timestamp: new Date(),
-                            });
-                        }
-                        return {
-                            shouldScheduleTool: true,
-                            toolName: toolCallData.toolCall.name,
-                            toolArgs: toolCallData.toolCall.args,
-                        };
-                    }
-                    catch (error) {
-                        addMessage({
-                            type: MessageType.ERROR,
-                            content: `Could not read restorable tool calls. This is the error: ${error}`,
-                            timestamp: new Date(),
-                        });
-                    }
-                },
-            });
-        }
-        return commands;
-    }, [
-        onDebugMessage,
-        setShowHelp,
-        refreshStatic,
-        openThemeDialog,
-        openAuthDialog,
-        openEditorDialog,
-        clearItems,
-        performMemoryRefresh,
-        showMemoryAction,
-        addMemoryAction,
-        addMessage,
-        toggleCorgiMode,
-        savedChatTags,
-        config,
-        settings,
-        showToolDescriptions,
-        session,
-        gitService,
-        loadHistory,
-        addItem,
-        setQuittingMessages,
-        pendingCompressionItemRef,
-        setPendingCompressionItem,
-        openPrivacyNotice,
-    ]);
-    const handleSlashCommand = useCallback(async (rawQuery) => {
-        if (typeof rawQuery !== 'string') {
-            return false;
-        }
-        const trimmed = rawQuery.trim();
-        if (!trimmed.startsWith('/') && !trimmed.startsWith('?')) {
-            return false;
-        }
-        const userMessageTimestamp = Date.now();
-        if (trimmed !== '/quit' && trimmed !== '/exit') {
-            addItem({ type: MessageType.USER, text: trimmed }, userMessageTimestamp);
-        }
-        let subCommand;
-        let args;
-        const commandToMatch = (() => {
-            if (trimmed.startsWith('?')) {
-                return 'help';
-            }
-            const parts = trimmed.substring(1).trim().split(/\s+/);
-            if (parts.length > 1) {
-                subCommand = parts[1];
-            }
-            if (parts.length > 2) {
-                args = parts.slice(2).join(' ');
-            }
-            return parts[0];
-        })();
-        const mainCommand = commandToMatch;
-        for (const cmd of slashCommands) {
-            if (mainCommand === cmd.name || mainCommand === cmd.altName) {
-                const actionResult = await cmd.action(mainCommand, subCommand, args);
-                if (typeof actionResult === 'object' &&
-                    actionResult?.shouldScheduleTool) {
-                    return actionResult; // Return the object for useGeminiStream
-                }
-                return true; // Command was handled, but no tool to schedule
-            }
-        }
-        addMessage({
-            type: MessageType.ERROR,
-            content: `Unknown command: ${trimmed}`,
-            timestamp: new Date(),
-        });
-        return true; // Indicate command was processed (even if unknown)
-    }, [addItem, slashCommands, addMessage]);
-    return { handleSlashCommand, slashCommands, pendingHistoryItems };
-};
-//# sourceMappingURL=slashCommandProcessor.js.map