@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/ui/commands/footerCommand.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CommandKind, } from './types.js';
+import { FooterConfigDialog } from '../components/FooterConfigDialog.js';
+export const footerCommand = {
+    name: 'footer',
+    altNames: ['statusline'],
+    description: 'Configure which items appear in the footer (statusline)',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: (context) => ({
+        type: 'custom_dialog',
+        component: _jsx(FooterConfigDialog, { onClose: context.ui.removeComponent }),
+    }),
+};

package/dist/ui/commands/gemmaStatusCommand.js

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CommandKind } from './types.js';
+import { MessageType } from '../types.js';
+import { checkGemmaStatus } from '../../commands/gemma/status.js';
+import { GEMMA_MODEL_NAME } from '../../commands/gemma/constants.js';
+export const gemmaStatusCommand = {
+    name: 'gemma',
+    description: 'Check local Gemma model routing status',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    isSafeConcurrent: true,
+    action: async (context) => {
+        const port = parseInt(context.services.settings.merged.experimental?.gemmaModelRouter?.classifier?.host?.match(/:(\d+)/)?.[1] ?? '', 10) || undefined;
+        const status = await checkGemmaStatus(port);
+        const item = {
+            type: MessageType.GEMMA_STATUS,
+            binaryInstalled: status.binaryInstalled,
+            binaryPath: status.binaryPath,
+            modelName: GEMMA_MODEL_NAME,
+            modelDownloaded: status.modelDownloaded,
+            serverRunning: status.serverRunning,
+            serverPid: status.serverPid,
+            serverPort: status.port,
+            settingsEnabled: status.settingsEnabled,
+            allPassing: status.allPassing,
+        };
+        context.ui.addItem(item);
+    },
+};

package/dist/ui/commands/helpCommand.js

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CommandKind } from './types.js';
+import { MessageType } from '../types.js';
+import { getAntigravityInstallInfo } from '../utils/antigravityUtils.js';
+export const helpCommand = {
+    name: 'help',
+    kind: CommandKind.BUILT_IN,
+    description: 'For help on gemini-cli',
+    autoExecute: true,
+    action: async (context, args) => {
+        const lowerArgs = args?.toLowerCase() || '';
+        const hasAntigravity = lowerArgs.includes('antigravity');
+        const hasInstallOrMigrate = lowerArgs.includes('install') || lowerArgs.includes('migrate');
+        if (hasAntigravity && hasInstallOrMigrate) {
+            const info = getAntigravityInstallInfo();
+            if (info) {
+                context.ui.addItem({
+                    type: MessageType.INFO,
+                    text: `To install the Antigravity CLI on ${info.platformName}, run the following command:\n\n'${info.installCmd}'`,
+                });
+            }
+            else {
+                context.ui.addItem({
+                    type: MessageType.INFO,
+                    text: `Learn more about Antigravity CLI at https://antigravity.google/docs/cli-getting-started`,
+                });
+            }
+            return;
+        }
+        const helpItem = {
+            type: MessageType.HELP,
+            timestamp: new Date(),
+        };
+        context.ui.addItem(helpItem);
+    },
+};

package/dist/ui/commands/hooksCommand.js

@@ -0,0 +1,336 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createElement } from 'react';
+import { CommandKind } from './types.js';
+import { getErrorMessage } from '@google/gemini-cli-core';
+import { SettingScope, isLoadableSettingScope } from '../../config/settings.js';
+import { enableHook, disableHook } from '../../utils/hookSettings.js';
+import { renderHookActionFeedback } from '../../utils/hookUtils.js';
+import { HooksDialog } from '../components/HooksDialog.js';
+/**
+ * Display a formatted list of hooks with their status in a dialog
+ */
+function panelAction(context) {
+    const agentContext = context.services.agentContext;
+    const config = agentContext?.config;
+    if (!config) {
+        return {
+            type: 'message',
+            messageType: 'error',
+            content: 'Config not loaded.',
+        };
+    }
+    const hookSystem = config.getHookSystem();
+    const allHooks = hookSystem?.getAllHooks() || [];
+    return {
+        type: 'custom_dialog',
+        component: createElement(HooksDialog, {
+            hooks: allHooks,
+            onClose: () => context.ui.removeComponent(),
+        }),
+    };
+}
+/**
+ * Enable a hook by name
+ */
+async function enableAction(context, args) {
+    const agentContext = context.services.agentContext;
+    const config = agentContext?.config;
+    if (!config) {
+        return {
+            type: 'message',
+            messageType: 'error',
+            content: 'Config not loaded.',
+        };
+    }
+    const hookSystem = config.getHookSystem();
+    if (!hookSystem) {
+        return {
+            type: 'message',
+            messageType: 'error',
+            content: 'Hook system is not enabled.',
+        };
+    }
+    const hookName = args.trim();
+    if (!hookName) {
+        return {
+            type: 'message',
+            messageType: 'error',
+            content: 'Usage: /hooks enable <hook-name>',
+        };
+    }
+    const settings = context.services.settings;
+    const result = enableHook(settings, hookName);
+    if (result.status === 'success') {
+        hookSystem.setHookEnabled(hookName, true);
+    }
+    const feedback = renderHookActionFeedback(result, (label, path) => `${label} (${path})`);
+    return {
+        type: 'message',
+        messageType: result.status === 'error' ? 'error' : 'info',
+        content: feedback,
+    };
+}
+/**
+ * Disable a hook by name
+ */
+async function disableAction(context, args) {
+    const agentContext = context.services.agentContext;
+    const config = agentContext?.config;
+    if (!config) {
+        return {
+            type: 'message',
+            messageType: 'error',
+            content: 'Config not loaded.',
+        };
+    }
+    const hookSystem = config.getHookSystem();
+    if (!hookSystem) {
+        return {
+            type: 'message',
+            messageType: 'error',
+            content: 'Hook system is not enabled.',
+        };
+    }
+    const hookName = args.trim();
+    if (!hookName) {
+        return {
+            type: 'message',
+            messageType: 'error',
+            content: 'Usage: /hooks disable <hook-name>',
+        };
+    }
+    const settings = context.services.settings;
+    const scope = settings.workspace ? SettingScope.Workspace : SettingScope.User;
+    const result = disableHook(settings, hookName, scope);
+    if (result.status === 'success') {
+        hookSystem.setHookEnabled(hookName, false);
+    }
+    const feedback = renderHookActionFeedback(result, (label, path) => `${label} (${path})`);
+    return {
+        type: 'message',
+        messageType: result.status === 'error' ? 'error' : 'info',
+        content: feedback,
+    };
+}
+/**
+ * Completion function for enabled hook names (to be disabled)
+ */
+function completeEnabledHookNames(context, partialArg) {
+    const agentContext = context.services.agentContext;
+    const config = agentContext?.config;
+    if (!config)
+        return [];
+    const hookSystem = config.getHookSystem();
+    if (!hookSystem)
+        return [];
+    const allHooks = hookSystem.getAllHooks();
+    return allHooks
+        .filter((hook) => hook.enabled)
+        .map((hook) => getHookDisplayName(hook))
+        .filter((name) => name.startsWith(partialArg));
+}
+/**
+ * Completion function for disabled hook names (to be enabled)
+ */
+function completeDisabledHookNames(context, partialArg) {
+    const agentContext = context.services.agentContext;
+    const config = agentContext?.config;
+    if (!config)
+        return [];
+    const hookSystem = config.getHookSystem();
+    if (!hookSystem)
+        return [];
+    const allHooks = hookSystem.getAllHooks();
+    return allHooks
+        .filter((hook) => !hook.enabled)
+        .map((hook) => getHookDisplayName(hook))
+        .filter((name) => name.startsWith(partialArg));
+}
+/**
+ * Get a display name for a hook
+ */
+function getHookDisplayName(hook) {
+    return hook.config.name || hook.config.command || 'unknown-hook';
+}
+/**
+ * Enable all hooks by clearing the disabled list
+ */
+async function enableAllAction(context) {
+    const agentContext = context.services.agentContext;
+    const config = agentContext?.config;
+    if (!config) {
+        return {
+            type: 'message',
+            messageType: 'error',
+            content: 'Config not loaded.',
+        };
+    }
+    const hookSystem = config.getHookSystem();
+    if (!hookSystem) {
+        return {
+            type: 'message',
+            messageType: 'error',
+            content: 'Hook system is not enabled.',
+        };
+    }
+    const settings = context.services.settings;
+    const allHooks = hookSystem.getAllHooks();
+    if (allHooks.length === 0) {
+        return {
+            type: 'message',
+            messageType: 'info',
+            content: 'No hooks configured.',
+        };
+    }
+    const disabledHooks = allHooks.filter((hook) => !hook.enabled);
+    if (disabledHooks.length === 0) {
+        return {
+            type: 'message',
+            messageType: 'info',
+            content: 'All hooks are already enabled.',
+        };
+    }
+    try {
+        const scopes = [SettingScope.Workspace, SettingScope.User];
+        for (const scope of scopes) {
+            if (isLoadableSettingScope(scope)) {
+                settings.setValue(scope, 'hooksConfig.disabled', []);
+            }
+        }
+        for (const hook of disabledHooks) {
+            const hookName = getHookDisplayName(hook);
+            hookSystem.setHookEnabled(hookName, true);
+        }
+        return {
+            type: 'message',
+            messageType: 'info',
+            content: `Enabled ${disabledHooks.length} hook(s) successfully.`,
+        };
+    }
+    catch (error) {
+        return {
+            type: 'message',
+            messageType: 'error',
+            content: `Failed to enable hooks: ${getErrorMessage(error)}`,
+        };
+    }
+}
+/**
+ * Disable all hooks by adding all hooks to the disabled list
+ */
+async function disableAllAction(context) {
+    const agentContext = context.services.agentContext;
+    const config = agentContext?.config;
+    if (!config) {
+        return {
+            type: 'message',
+            messageType: 'error',
+            content: 'Config not loaded.',
+        };
+    }
+    const hookSystem = config.getHookSystem();
+    if (!hookSystem) {
+        return {
+            type: 'message',
+            messageType: 'error',
+            content: 'Hook system is not enabled.',
+        };
+    }
+    const settings = context.services.settings;
+    const allHooks = hookSystem.getAllHooks();
+    if (allHooks.length === 0) {
+        return {
+            type: 'message',
+            messageType: 'info',
+            content: 'No hooks configured.',
+        };
+    }
+    const enabledHooks = allHooks.filter((hook) => hook.enabled);
+    if (enabledHooks.length === 0) {
+        return {
+            type: 'message',
+            messageType: 'info',
+            content: 'All hooks are already disabled.',
+        };
+    }
+    try {
+        const allHookNames = allHooks.map((hook) => getHookDisplayName(hook));
+        const scope = settings.workspace
+            ? SettingScope.Workspace
+            : SettingScope.User;
+        settings.setValue(scope, 'hooksConfig.disabled', allHookNames);
+        for (const hook of enabledHooks) {
+            const hookName = getHookDisplayName(hook);
+            hookSystem.setHookEnabled(hookName, false);
+        }
+        return {
+            type: 'message',
+            messageType: 'info',
+            content: `Disabled ${enabledHooks.length} hook(s) successfully.`,
+        };
+    }
+    catch (error) {
+        return {
+            type: 'message',
+            messageType: 'error',
+            content: `Failed to disable hooks: ${getErrorMessage(error)}`,
+        };
+    }
+}
+const panelCommand = {
+    name: 'panel',
+    altNames: ['list', 'show'],
+    description: 'Display all registered hooks with their status',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: panelAction,
+};
+const enableCommand = {
+    name: 'enable',
+    description: 'Enable a hook by name',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: enableAction,
+    completion: completeDisabledHookNames,
+};
+const disableCommand = {
+    name: 'disable',
+    description: 'Disable a hook by name',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: disableAction,
+    completion: completeEnabledHookNames,
+};
+const enableAllCommand = {
+    name: 'enable-all',
+    altNames: ['enableall'],
+    description: 'Enable all disabled hooks',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: enableAllAction,
+};
+const disableAllCommand = {
+    name: 'disable-all',
+    altNames: ['disableall'],
+    description: 'Disable all enabled hooks',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: disableAllAction,
+};
+export const hooksCommand = {
+    name: 'hooks',
+    description: 'Manage hooks',
+    kind: CommandKind.BUILT_IN,
+    subCommands: [
+        panelCommand,
+        enableCommand,
+        disableCommand,
+        enableAllCommand,
+        disableAllCommand,
+    ],
+    action: (context) => panelCommand.action(context, ''),
+};

package/dist/ui/commands/ideCommand.js

@@ -0,0 +1,232 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { IdeClient, logIdeConnection, IdeConnectionEvent, IdeConnectionType, } from '@google/gemini-cli-core';
+import { getIdeInstaller, IDEConnectionStatus, ideContextStore, GEMINI_CLI_COMPANION_EXTENSION_NAME, } from '@google/gemini-cli-core';
+import path from 'node:path';
+import { CommandKind } from './types.js';
+import { SettingScope } from '../../config/settings.js';
+function getIdeStatusMessage(ideClient) {
+    const connection = ideClient.getConnectionStatus();
+    switch (connection.status) {
+        case IDEConnectionStatus.Connected:
+            return {
+                messageType: 'info',
+                content: `🟢 Connected to ${ideClient.getDetectedIdeDisplayName()}`,
+            };
+        case IDEConnectionStatus.Connecting:
+            return {
+                messageType: 'info',
+                content: `🟡 Connecting...`,
+            };
+        default: {
+            let content = `🔴 Disconnected`;
+            if (connection?.details) {
+                content += `: ${connection.details}`;
+            }
+            return {
+                messageType: 'error',
+                content,
+            };
+        }
+    }
+}
+function formatFileList(openFiles) {
+    const basenameCounts = new Map();
+    for (const file of openFiles) {
+        const basename = path.basename(file.path);
+        basenameCounts.set(basename, (basenameCounts.get(basename) || 0) + 1);
+    }
+    const fileList = openFiles
+        .map((file) => {
+        const basename = path.basename(file.path);
+        const isDuplicate = (basenameCounts.get(basename) || 0) > 1;
+        const parentDir = path.basename(path.dirname(file.path));
+        const displayName = isDuplicate
+            ? `${basename} (/${parentDir})`
+            : basename;
+        return `  - ${displayName}${file.isActive ? ' (active)' : ''}`;
+    })
+        .join('\n');
+    const infoMessage = `
+(Note: The file list is limited to a number of recently accessed files within your workspace and only includes local files on disk)`;
+    return `\n\nOpen files:\n${fileList}\n${infoMessage}`;
+}
+async function getIdeStatusMessageWithFiles(ideClient) {
+    const connection = ideClient.getConnectionStatus();
+    switch (connection.status) {
+        case IDEConnectionStatus.Connected: {
+            let content = `🟢 Connected to ${ideClient.getDetectedIdeDisplayName()}`;
+            const context = ideContextStore.get();
+            const openFiles = context?.workspaceState?.openFiles;
+            if (openFiles && openFiles.length > 0) {
+                content += formatFileList(openFiles);
+            }
+            return {
+                messageType: 'info',
+                content,
+            };
+        }
+        case IDEConnectionStatus.Connecting:
+            return {
+                messageType: 'info',
+                content: `🟡 Connecting...`,
+            };
+        default: {
+            let content = `🔴 Disconnected`;
+            if (connection?.details) {
+                content += `: ${connection.details}`;
+            }
+            return {
+                messageType: 'error',
+                content,
+            };
+        }
+    }
+}
+async function setIdeModeAndSyncConnection(config, value, options = {}) {
+    config.setIdeMode(value);
+    const ideClient = await IdeClient.getInstance();
+    if (value) {
+        await ideClient.connect(options);
+        logIdeConnection(config, new IdeConnectionEvent(IdeConnectionType.SESSION));
+    }
+    else {
+        await ideClient.disconnect();
+    }
+}
+export const ideCommand = async () => {
+    const ideClient = await IdeClient.getInstance();
+    const currentIDE = ideClient.getCurrentIde();
+    if (!currentIDE) {
+        return {
+            name: 'ide',
+            description: 'Manage IDE integration',
+            kind: CommandKind.BUILT_IN,
+            autoExecute: false,
+            action: () => ({
+                type: 'message',
+                messageType: 'error',
+                content: `IDE integration is not supported in your current environment. To use this feature, run Gemini CLI in one of these supported IDEs: Antigravity, VS Code, or VS Code forks.`,
+            }),
+        };
+    }
+    const ideSlashCommand = {
+        name: 'ide',
+        description: 'Manage IDE integration',
+        kind: CommandKind.BUILT_IN,
+        autoExecute: false,
+        subCommands: [],
+    };
+    const statusCommand = {
+        name: 'status',
+        description: 'Check status of IDE integration',
+        kind: CommandKind.BUILT_IN,
+        autoExecute: true,
+        action: async () => {
+            const { messageType, content } = await getIdeStatusMessageWithFiles(ideClient);
+            return {
+                type: 'message',
+                messageType,
+                content,
+            };
+        },
+    };
+    const installCommand = {
+        name: 'install',
+        description: `Install required IDE companion for ${ideClient.getDetectedIdeDisplayName()}`,
+        kind: CommandKind.BUILT_IN,
+        autoExecute: true,
+        action: async (context) => {
+            const installer = getIdeInstaller(currentIDE);
+            if (!installer) {
+                context.ui.addItem({
+                    type: 'error',
+                    text: `No installer is available for ${ideClient.getDetectedIdeDisplayName()}. Please install the '${GEMINI_CLI_COMPANION_EXTENSION_NAME}' extension manually from the marketplace.`,
+                }, Date.now());
+                return;
+            }
+            context.ui.addItem({
+                type: 'info',
+                text: `Installing IDE companion...`,
+            }, Date.now());
+            const result = await installer.install();
+            context.ui.addItem({
+                type: result.success ? 'info' : 'error',
+                text: result.message,
+            }, Date.now());
+            if (result.success) {
+                context.services.settings.setValue(SettingScope.User, 'ide.enabled', true);
+                // Poll for up to 5 seconds for the extension to activate.
+                for (let i = 0; i < 10; i++) {
+                    await setIdeModeAndSyncConnection(context.services.agentContext.config, true, {
+                        logToConsole: false,
+                    });
+                    if (ideClient.getConnectionStatus().status ===
+                        IDEConnectionStatus.Connected) {
+                        break;
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 500));
+                }
+                const { messageType, content } = getIdeStatusMessage(ideClient);
+                if (messageType === 'error') {
+                    context.ui.addItem({
+                        type: messageType,
+                        text: `Failed to automatically enable IDE integration. To fix this, run the CLI in a new terminal window.`,
+                    }, Date.now());
+                }
+                else {
+                    context.ui.addItem({
+                        type: messageType,
+                        text: content,
+                    }, Date.now());
+                }
+            }
+        },
+    };
+    const enableCommand = {
+        name: 'enable',
+        description: 'Enable IDE integration',
+        kind: CommandKind.BUILT_IN,
+        autoExecute: true,
+        action: async (context) => {
+            context.services.settings.setValue(SettingScope.User, 'ide.enabled', true);
+            await setIdeModeAndSyncConnection(context.services.agentContext.config, true);
+            const { messageType, content } = getIdeStatusMessage(ideClient);
+            context.ui.addItem({
+                type: messageType,
+                text: content,
+            }, Date.now());
+        },
+    };
+    const disableCommand = {
+        name: 'disable',
+        description: 'Disable IDE integration',
+        kind: CommandKind.BUILT_IN,
+        autoExecute: true,
+        action: async (context) => {
+            context.services.settings.setValue(SettingScope.User, 'ide.enabled', false);
+            await setIdeModeAndSyncConnection(context.services.agentContext.config, false);
+            const { messageType, content } = getIdeStatusMessage(ideClient);
+            context.ui.addItem({
+                type: messageType,
+                text: content,
+            }, Date.now());
+        },
+    };
+    const { status } = ideClient.getConnectionStatus();
+    const isConnected = status === IDEConnectionStatus.Connected;
+    if (isConnected) {
+        ideSlashCommand.subCommands = [statusCommand, disableCommand];
+    }
+    else {
+        ideSlashCommand.subCommands = [
+            enableCommand,
+            statusCommand,
+            installCommand,
+        ];
+    }
+    return ideSlashCommand;
+};

package/dist/ui/commands/initCommand.js

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { CommandKind } from './types.js';
+import { performInit } from '@google/gemini-cli-core';
+export const initCommand = {
+    name: 'init',
+    description: 'Analyzes the project and creates a tailored GEMINI.md file',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: async (context, _args) => {
+        if (!context.services.agentContext?.config) {
+            return {
+                type: 'message',
+                messageType: 'error',
+                content: 'Configuration not available.',
+            };
+        }
+        const targetDir = context.services.agentContext.config.getTargetDir();
+        const geminiMdPath = path.join(targetDir, 'GEMINI.md');
+        const result = performInit(fs.existsSync(geminiMdPath));
+        if (result.type === 'submit_prompt') {
+            // Create an empty GEMINI.md file
+            fs.writeFileSync(geminiMdPath, '', 'utf8');
+            context.ui.addItem({
+                type: 'info',
+                text: 'Empty GEMINI.md created. Now analyzing the project to populate it.',
+            }, Date.now());
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        return result;
+    },
+};