@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/services/BuiltinCommandLoader.js

@@ -0,0 +1,207 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isDevelopment } from '../utils/installationInfo.js';
+import { CommandKind, } from '../ui/commands/types.js';
+import { isNightly, startupProfiler, getAdminErrorMessage, AuthType, } from '@google/gemini-cli-core';
+import { aboutCommand } from '../ui/commands/aboutCommand.js';
+import { agentsCommand } from '../ui/commands/agentsCommand.js';
+import { authCommand } from '../ui/commands/authCommand.js';
+import { bugCommand } from '../ui/commands/bugCommand.js';
+import { bugMemoryCommand } from '../ui/commands/bugMemoryCommand.js';
+import { chatCommand, debugCommand } from '../ui/commands/chatCommand.js';
+import { clearCommand } from '../ui/commands/clearCommand.js';
+import { commandsCommand } from '../ui/commands/commandsCommand.js';
+import { compressCommand } from '../ui/commands/compressCommand.js';
+import { copyCommand } from '../ui/commands/copyCommand.js';
+import { corgiCommand } from '../ui/commands/corgiCommand.js';
+import { docsCommand } from '../ui/commands/docsCommand.js';
+import { exportSessionCommand } from '../ui/commands/exportSessionCommand.js';
+import { directoryCommand } from '../ui/commands/directoryCommand.js';
+import { editorCommand } from '../ui/commands/editorCommand.js';
+import { extensionsCommand } from '../ui/commands/extensionsCommand.js';
+import { footerCommand } from '../ui/commands/footerCommand.js';
+import { helpCommand } from '../ui/commands/helpCommand.js';
+import { shortcutsCommand } from '../ui/commands/shortcutsCommand.js';
+import { rewindCommand } from '../ui/commands/rewindCommand.js';
+import { hooksCommand } from '../ui/commands/hooksCommand.js';
+import { ideCommand } from '../ui/commands/ideCommand.js';
+import { initCommand } from '../ui/commands/initCommand.js';
+import { mcpCommand } from '../ui/commands/mcpCommand.js';
+import { memoryCommand } from '../ui/commands/memoryCommand.js';
+import { modelCommand } from '../ui/commands/modelCommand.js';
+import { oncallCommand } from '../ui/commands/oncallCommand.js';
+import { permissionsCommand } from '../ui/commands/permissionsCommand.js';
+import { planCommand } from '../ui/commands/planCommand.js';
+import { policiesCommand } from '../ui/commands/policiesCommand.js';
+import { privacyCommand } from '../ui/commands/privacyCommand.js';
+import { profileCommand } from '../ui/commands/profileCommand.js';
+import { quitCommand } from '../ui/commands/quitCommand.js';
+import { restoreCommand } from '../ui/commands/restoreCommand.js';
+import { resumeCommand } from '../ui/commands/resumeCommand.js';
+import { statsCommand } from '../ui/commands/statsCommand.js';
+import { themeCommand } from '../ui/commands/themeCommand.js';
+import { toolsCommand } from '../ui/commands/toolsCommand.js';
+import { skillsCommand } from '../ui/commands/skillsCommand.js';
+import { settingsCommand } from '../ui/commands/settingsCommand.js';
+import { tasksCommand } from '../ui/commands/tasksCommand.js';
+import { vimCommand } from '../ui/commands/vimCommand.js';
+import { setupGithubCommand } from '../ui/commands/setupGithubCommand.js';
+import { terminalSetupCommand } from '../ui/commands/terminalSetupCommand.js';
+import { upgradeCommand } from '../ui/commands/upgradeCommand.js';
+import { gemmaStatusCommand } from '../ui/commands/gemmaStatusCommand.js';
+import { voiceCommand } from '../ui/commands/voiceCommand.js';
+/**
+ * Loads the core, hard-coded slash commands that are an integral part
+ * of the Gemini CLI application.
+ */
+export class BuiltinCommandLoader {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Gathers all raw built-in command definitions, injects dependencies where
+     * needed (e.g., config) and filters out any that are not available.
+     *
+     * @param _signal An AbortSignal (unused for this synchronous loader).
+     * @returns A promise that resolves to an array of `SlashCommand` objects.
+     */
+    async loadCommands(_signal) {
+        const handle = startupProfiler.start('load_builtin_commands');
+        const isNightlyBuild = await isNightly(process.cwd());
+        const addDebugToChatResumeSubCommands = (subCommands) => {
+            if (!subCommands) {
+                return subCommands;
+            }
+            const withNestedCompatibility = subCommands.map((subCommand) => {
+                if (subCommand.name !== 'checkpoints') {
+                    return subCommand;
+                }
+                return {
+                    ...subCommand,
+                    subCommands: addDebugToChatResumeSubCommands(subCommand.subCommands),
+                };
+            });
+            if (!isNightlyBuild) {
+                return withNestedCompatibility;
+            }
+            return withNestedCompatibility.some((cmd) => cmd.name === debugCommand.name)
+                ? withNestedCompatibility
+                : [
+                    ...withNestedCompatibility,
+                    { ...debugCommand, suggestionGroup: 'checkpoints' },
+                ];
+        };
+        const chatResumeSubCommands = addDebugToChatResumeSubCommands(chatCommand.subCommands);
+        const allDefinitions = [
+            aboutCommand,
+            ...(this.config?.isAgentsEnabled() ? [agentsCommand] : []),
+            authCommand,
+            bugCommand,
+            bugMemoryCommand,
+            {
+                ...chatCommand,
+                subCommands: chatResumeSubCommands,
+            },
+            clearCommand,
+            commandsCommand,
+            compressCommand,
+            copyCommand,
+            corgiCommand,
+            docsCommand,
+            exportSessionCommand,
+            directoryCommand,
+            editorCommand,
+            ...(this.config?.getExtensionsEnabled() === false
+                ? [
+                    {
+                        name: 'extensions',
+                        description: 'Manage extensions',
+                        kind: CommandKind.BUILT_IN,
+                        autoExecute: false,
+                        subCommands: [],
+                        action: async (_context) => ({
+                            type: 'message',
+                            messageType: 'error',
+                            content: getAdminErrorMessage('Extensions', this.config ?? undefined),
+                        }),
+                    },
+                ]
+                : [extensionsCommand(this.config?.getEnableExtensionReloading())]),
+            helpCommand,
+            footerCommand,
+            shortcutsCommand,
+            ...(this.config?.getEnableHooksUI() ? [hooksCommand] : []),
+            rewindCommand,
+            await ideCommand(),
+            initCommand,
+            ...(isNightlyBuild ? [oncallCommand] : []),
+            ...(this.config?.getMcpEnabled() === false
+                ? [
+                    {
+                        name: 'mcp',
+                        description: 'Manage configured Model Context Protocol (MCP) servers',
+                        kind: CommandKind.BUILT_IN,
+                        autoExecute: false,
+                        subCommands: [],
+                        action: async (_context) => ({
+                            type: 'message',
+                            messageType: 'error',
+                            content: getAdminErrorMessage('MCP', this.config ?? undefined),
+                        }),
+                    },
+                ]
+                : [mcpCommand]),
+            memoryCommand(this.config),
+            modelCommand,
+            ...(this.config?.getFolderTrust() ? [permissionsCommand] : []),
+            ...(this.config?.isPlanEnabled() ? [planCommand] : []),
+            policiesCommand,
+            privacyCommand,
+            ...(isDevelopment ? [profileCommand] : []),
+            quitCommand,
+            restoreCommand(this.config),
+            {
+                ...resumeCommand,
+                subCommands: addDebugToChatResumeSubCommands(resumeCommand.subCommands),
+            },
+            statsCommand,
+            themeCommand,
+            toolsCommand,
+            ...(this.config?.isSkillsSupportEnabled()
+                ? this.config?.getSkillManager()?.isAdminEnabled() === false
+                    ? [
+                        {
+                            name: 'skills',
+                            description: 'Manage agent skills',
+                            kind: CommandKind.BUILT_IN,
+                            autoExecute: false,
+                            subCommands: [],
+                            action: async (_context) => ({
+                                type: 'message',
+                                messageType: 'error',
+                                content: getAdminErrorMessage('Agent skills', this.config ?? undefined),
+                            }),
+                        },
+                    ]
+                    : [skillsCommand]
+                : []),
+            settingsCommand,
+            gemmaStatusCommand,
+            tasksCommand,
+            vimCommand,
+            setupGithubCommand,
+            terminalSetupCommand,
+            ...(this.config?.isVoiceModeEnabled() ? [voiceCommand] : []),
+            ...(this.config?.getContentGeneratorConfig()?.authType ===
+                AuthType.LOGIN_WITH_GOOGLE
+                ? [upgradeCommand]
+                : []),
+        ];
+        handle?.end();
+        return allDefinitions.filter((cmd) => cmd !== null);
+    }
+}

package/dist/services/CommandService.js

@@ -0,0 +1,99 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { debugLogger, coreEvents } from '@google/gemini-cli-core';
+import { SlashCommandResolver } from './SlashCommandResolver.js';
+/**
+ * Orchestrates the discovery and loading of all slash commands for the CLI.
+ *
+ * This service operates on a provider-based loader pattern. It is initialized
+ * with an array of `ICommandLoader` instances, each responsible for fetching
+ * commands from a specific source (e.g., built-in code, local files).
+ *
+ * It uses a delegating resolver to reconcile name conflicts, ensuring that
+ * all commands are uniquely addressable via source-specific prefixes while
+ * allowing built-in commands to retain their primary names.
+ */
+export class CommandService {
+    commands;
+    conflicts;
+    /**
+     * Private constructor to enforce the use of the async factory.
+     * @param commands A readonly array of the fully loaded and de-duplicated commands.
+     * @param conflicts A readonly array of conflicts that occurred during loading.
+     */
+    constructor(commands, conflicts) {
+        this.commands = commands;
+        this.conflicts = conflicts;
+    }
+    /**
+     * Asynchronously creates and initializes a new CommandService instance.
+     *
+     * This factory method orchestrates the loading process and delegates
+     * conflict resolution to the SlashCommandResolver.
+     *
+     * @param loaders An array of loaders to fetch commands from.
+     * @param signal An AbortSignal to allow cancellation.
+     * @returns A promise that resolves to a fully initialized CommandService.
+     */
+    static async create(loaders, signal) {
+        const allCommands = await this.loadAllCommands(loaders, signal);
+        const { finalCommands, conflicts } = SlashCommandResolver.resolve(allCommands);
+        if (conflicts.length > 0) {
+            this.emitConflictEvents(conflicts);
+        }
+        return new CommandService(Object.freeze(finalCommands), Object.freeze(conflicts));
+    }
+    /**
+     * Invokes all loaders in parallel and flattens the results.
+     */
+    static async loadAllCommands(loaders, signal) {
+        const results = await Promise.allSettled(loaders.map((loader) => loader.loadCommands(signal)));
+        const commands = [];
+        for (const result of results) {
+            if (result.status === 'fulfilled') {
+                commands.push(...result.value);
+            }
+            else {
+                debugLogger.debug('A command loader failed:', result.reason);
+            }
+        }
+        return commands;
+    }
+    /**
+     * Formats and emits telemetry for command conflicts.
+     */
+    static emitConflictEvents(conflicts) {
+        coreEvents.emitSlashCommandConflicts(conflicts.flatMap((c) => c.losers.map((l) => ({
+            name: c.name,
+            renamedTo: l.renamedTo,
+            loserExtensionName: l.command.extensionName,
+            winnerExtensionName: l.reason.extensionName,
+            loserMcpServerName: l.command.mcpServerName,
+            winnerMcpServerName: l.reason.mcpServerName,
+            loserKind: l.command.kind,
+            winnerKind: l.reason.kind,
+        }))));
+    }
+    /**
+     * Retrieves the currently loaded and de-duplicated list of slash commands.
+     *
+     * This method is a safe accessor for the service's state. It returns a
+     * readonly array, preventing consumers from modifying the service's internal state.
+     *
+     * @returns A readonly, unified array of available `SlashCommand` objects.
+     */
+    getCommands() {
+        return this.commands;
+    }
+    /**
+     * Retrieves the list of conflicts that occurred during command loading.
+     *
+     * @returns A readonly array of command conflicts.
+     */
+    getConflicts() {
+        return this.conflicts;
+    }
+}

package/dist/services/FileCommandLoader.js

@@ -0,0 +1,298 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import toml from '@iarna/toml';
+import { glob } from 'glob';
+import { z } from 'zod';
+import { Storage, coreEvents } from '@google/gemini-cli-core';
+import { CommandKind } from '../ui/commands/types.js';
+import { DefaultArgumentProcessor } from './prompt-processors/argumentProcessor.js';
+import { SHORTHAND_ARGS_PLACEHOLDER, SHELL_INJECTION_TRIGGER, AT_FILE_INJECTION_TRIGGER, } from './prompt-processors/types.js';
+import { ConfirmationRequiredError, ShellProcessor, } from './prompt-processors/shellProcessor.js';
+import { AtFileProcessor } from './prompt-processors/atFileProcessor.js';
+import { sanitizeForDisplay } from '../ui/utils/textUtils.js';
+/**
+ * Defines the Zod schema for a command definition file. This serves as the
+ * single source of truth for both validation and type inference.
+ */
+const TomlCommandDefSchema = z.object({
+    prompt: z.string({
+        required_error: "The 'prompt' field is required.",
+        invalid_type_error: "The 'prompt' field must be a string.",
+    }),
+    description: z.string().optional(),
+});
+/**
+ * Discovers and loads custom slash commands from .toml files in both the
+ * user's global config directory and the current project's directory.
+ *
+ * This loader is responsible for:
+ * - Recursively scanning command directories.
+ * - Parsing and validating TOML files.
+ * - Adapting valid definitions into executable SlashCommand objects.
+ * - Handling file system errors and malformed files gracefully.
+ */
+export class FileCommandLoader {
+    config;
+    projectRoot;
+    folderTrustEnabled;
+    isTrustedFolder;
+    constructor(config) {
+        this.config = config;
+        this.folderTrustEnabled = !!config?.getFolderTrust();
+        this.isTrustedFolder = !!config?.isTrustedFolder();
+        this.projectRoot = config?.getProjectRoot() || process.cwd();
+    }
+    /**
+     * Loads all commands from user, project, and extension directories.
+     * Returns commands in order: user → project → extensions (alphabetically).
+     *
+     * Order is important for conflict resolution in CommandService:
+     * - User/project commands (without extensionName) use "last wins" strategy
+     * - Extension commands (with extensionName) get renamed if conflicts exist
+     *
+     * @param signal An AbortSignal to cancel the loading process.
+     * @returns A promise that resolves to an array of all loaded SlashCommands.
+     */
+    async loadCommands(signal) {
+        if (this.folderTrustEnabled && !this.isTrustedFolder) {
+            return [];
+        }
+        const allCommands = [];
+        const globOptions = {
+            nodir: true,
+            dot: true,
+            signal,
+            follow: true,
+        };
+        // Load commands from each directory
+        const commandDirs = this.getCommandDirectories();
+        for (const dirInfo of commandDirs) {
+            try {
+                const files = await glob('**/*.toml', {
+                    ...globOptions,
+                    cwd: dirInfo.path,
+                });
+                const commandPromises = files.map((file) => this.parseAndAdaptFile(path.join(dirInfo.path, file), dirInfo.path, dirInfo.kind, dirInfo.extensionName, dirInfo.extensionId));
+                const commands = (await Promise.all(commandPromises)).filter((cmd) => cmd !== null);
+                // Add all commands without deduplication
+                allCommands.push(...commands);
+            }
+            catch (error) {
+                if (!signal.aborted &&
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                    error?.code !== 'ENOENT') {
+                    coreEvents.emitFeedback('error', `[FileCommandLoader] Error loading commands from ${dirInfo.path}:`, error);
+                }
+            }
+        }
+        return allCommands;
+    }
+    /**
+     * Lists available .toml command files from user, project, and extension directories.
+     */
+    async listAvailableFiles() {
+        const directories = this.getCommandDirectories();
+        const groups = [];
+        for (const dir of directories) {
+            const displayName = this.getDisplayName(dir);
+            try {
+                const files = await glob('**/*.toml', { cwd: dir.path });
+                if (files.length > 0) {
+                    groups.push({
+                        displayName,
+                        path: dir.path,
+                        files: [...files].sort(),
+                    });
+                }
+            }
+            catch (e) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                if (e.code === 'ENOENT') {
+                    continue;
+                }
+                groups.push({
+                    displayName,
+                    path: dir.path,
+                    files: [],
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
+        return groups;
+    }
+    /**
+     * Returns a human-readable display name for the command directory source.
+     */
+    getDisplayName(dir) {
+        switch (dir.kind) {
+            case CommandKind.USER_FILE:
+                return 'User';
+            case CommandKind.WORKSPACE_FILE:
+                return 'Project';
+            case CommandKind.EXTENSION_FILE:
+                return `Extension: ${dir.extensionName || 'Unknown'}`;
+            default:
+                return 'Custom';
+        }
+    }
+    /**
+     * Get all command directories in order for loading.
+     * User commands → Project commands → Extension commands
+     * This order ensures extension commands can detect all conflicts.
+     */
+    getCommandDirectories() {
+        const dirs = [];
+        const storage = this.config?.storage ?? new Storage(this.projectRoot);
+        // 1. User commands
+        const userCommandsDir = Storage.getUserCommandsDir();
+        dirs.push({
+            path: userCommandsDir,
+            kind: CommandKind.USER_FILE,
+        });
+        // 2. Project commands (skip if same directory as user commands, e.g. when
+        //    cwd is the user's home directory, to avoid false conflict warnings)
+        if (!storage.isWorkspaceHomeDir()) {
+            dirs.push({
+                path: storage.getProjectCommandsDir(),
+                kind: CommandKind.WORKSPACE_FILE,
+            });
+        }
+        // 3. Extension commands (processed last to detect all conflicts)
+        if (this.config) {
+            const activeExtensions = this.config
+                .getExtensions()
+                .filter((ext) => ext.isActive)
+                .sort((a, b) => a.name.localeCompare(b.name)); // Sort alphabetically for deterministic loading
+            const extensionCommandDirs = activeExtensions.map((ext) => ({
+                path: path.join(ext.path, 'commands'),
+                kind: CommandKind.EXTENSION_FILE,
+                extensionName: ext.name,
+                extensionId: ext.id,
+            }));
+            dirs.push(...extensionCommandDirs);
+        }
+        return dirs;
+    }
+    /**
+     * Parses a single .toml file and transforms it into a SlashCommand object.
+     * @param filePath The absolute path to the .toml file.
+     * @param baseDir The root command directory for name calculation.
+     * @param kind The CommandKind.
+     * @param extensionName Optional extension name to prefix commands with.
+     * @returns A promise resolving to a SlashCommand, or null if the file is invalid.
+     */
+    async parseAndAdaptFile(filePath, baseDir, kind, extensionName, extensionId) {
+        let fileContent;
+        try {
+            fileContent = await fs.readFile(filePath, 'utf-8');
+        }
+        catch (error) {
+            coreEvents.emitFeedback('error', `[FileCommandLoader] Failed to read file ${filePath}:`, error instanceof Error ? error.message : String(error));
+            return null;
+        }
+        let parsed;
+        try {
+            parsed = toml.parse(fileContent);
+        }
+        catch (error) {
+            coreEvents.emitFeedback('error', `[FileCommandLoader] Failed to parse TOML file ${filePath}:`, error instanceof Error ? error.message : String(error));
+            return null;
+        }
+        const validationResult = TomlCommandDefSchema.safeParse(parsed);
+        if (!validationResult.success) {
+            coreEvents.emitFeedback('error', `[FileCommandLoader] Skipping invalid command file: ${filePath}. Validation errors:`, validationResult.error.flatten());
+            return null;
+        }
+        const validDef = validationResult.data;
+        const relativePathWithExt = path.relative(baseDir, filePath);
+        const relativePath = relativePathWithExt.substring(0, relativePathWithExt.length - 5);
+        const baseCommandName = relativePath
+            .split(path.sep)
+            // Sanitize each path segment to prevent ambiguity, replacing non-allowlisted characters with underscores.
+            // Since ':' is our namespace separator, this ensures that colons do not cause naming conflicts.
+            .map((segment) => {
+            let sanitized = segment.replace(/[^a-zA-Z0-9_\-.]/g, '_');
+            // Truncate excessively long segments to prevent UI overflow
+            if (sanitized.length > 50) {
+                sanitized = sanitized.substring(0, 47) + '...';
+            }
+            return sanitized;
+        })
+            .join(':');
+        // Add extension name tag for extension commands
+        const defaultDescription = `Custom command from ${path.basename(filePath)}`;
+        let description = validDef.description || defaultDescription;
+        description = sanitizeForDisplay(description, 100);
+        if (extensionName) {
+            description = `[${extensionName}] ${description}`;
+        }
+        const processors = [];
+        const usesArgs = validDef.prompt.includes(SHORTHAND_ARGS_PLACEHOLDER);
+        const usesShellInjection = validDef.prompt.includes(SHELL_INJECTION_TRIGGER);
+        const usesAtFileInjection = validDef.prompt.includes(AT_FILE_INJECTION_TRIGGER);
+        // 1. @-File Injection (Security First).
+        // This runs first to ensure we're not executing shell commands that
+        // could dynamically generate malicious @-paths.
+        if (usesAtFileInjection) {
+            processors.push(new AtFileProcessor(baseCommandName));
+        }
+        // 2. Argument and Shell Injection.
+        // This runs after file content has been safely injected.
+        if (usesShellInjection || usesArgs) {
+            processors.push(new ShellProcessor(baseCommandName));
+        }
+        // 3. Default Argument Handling.
+        // Appends the raw invocation if no explicit {{args}} are used.
+        if (!usesArgs) {
+            processors.push(new DefaultArgumentProcessor());
+        }
+        return {
+            name: baseCommandName,
+            description,
+            kind,
+            extensionName,
+            extensionId,
+            action: async (context, _args) => {
+                if (!context.invocation) {
+                    coreEvents.emitFeedback('error', `[FileCommandLoader] Critical error: Command '${baseCommandName}' was executed without invocation context.`);
+                    return {
+                        type: 'submit_prompt',
+                        content: [{ text: validDef.prompt }], // Fallback to unprocessed prompt
+                    };
+                }
+                try {
+                    let processedContent = [
+                        { text: validDef.prompt },
+                    ];
+                    for (const processor of processors) {
+                        processedContent = await processor.process(processedContent, context);
+                    }
+                    return {
+                        type: 'submit_prompt',
+                        content: processedContent,
+                    };
+                }
+                catch (e) {
+                    // Check if it's our specific error type
+                    if (e instanceof ConfirmationRequiredError) {
+                        // Halt and request confirmation from the UI layer.
+                        return {
+                            type: 'confirm_shell_commands',
+                            commandsToConfirm: e.commandsToConfirm,
+                            originalInvocation: {
+                                raw: context.invocation.raw,
+                            },
+                        };
+                    }
+                    // Re-throw other errors to be handled by the global error handler.
+                    throw e;
+                }
+            },
+        };
+    }
+}