@quantum-ai/gemini-cli 0.45.8 → 0.45.10

package/dist/ui/commands/oncallCommand.js

@@ -0,0 +1,90 @@
+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 { TriageDuplicates } from '../components/triage/TriageDuplicates.js';
+import { TriageIssues } from '../components/triage/TriageIssues.js';
+export const oncallCommand = {
+    name: 'oncall',
+    description: 'Oncall related commands',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: false,
+    subCommands: [
+        {
+            name: 'dedup',
+            description: 'Triage issues labeled as status/possible-duplicate',
+            kind: CommandKind.BUILT_IN,
+            autoExecute: true,
+            action: async (context, args) => {
+                const agentContext = context.services.agentContext;
+                const config = agentContext?.config;
+                if (!config) {
+                    throw new Error('Config not available');
+                }
+                let limit = 50;
+                if (args && args.trim().length > 0) {
+                    const argArray = args.trim().split(/\s+/);
+                    const parsedLimit = parseInt(argArray[0], 10);
+                    if (!isNaN(parsedLimit) && parsedLimit > 0) {
+                        limit = parsedLimit;
+                    }
+                }
+                return {
+                    type: 'custom_dialog',
+                    component: (_jsx(TriageDuplicates, { config: config, initialLimit: limit, onExit: () => context.ui.removeComponent() })),
+                };
+            },
+        },
+        {
+            name: 'audit',
+            description: 'Triage issues labeled as status/need-triage',
+            kind: CommandKind.BUILT_IN,
+            autoExecute: true,
+            action: async (context, args) => {
+                const agentContext = context.services.agentContext;
+                const config = agentContext?.config;
+                if (!config) {
+                    throw new Error('Config not available');
+                }
+                let limit = 100;
+                let until;
+                if (args && args.trim().length > 0) {
+                    const argArray = args.trim().split(/\s+/);
+                    for (let i = 0; i < argArray.length; i++) {
+                        const arg = argArray[i];
+                        if (arg === '--until') {
+                            if (i + 1 >= argArray.length) {
+                                throw new Error('Flag --until requires a value (YYYY-MM-DD).');
+                            }
+                            const val = argArray[i + 1];
+                            if (!/^\d{4}-\d{2}-\d{2}$/.test(val)) {
+                                throw new Error(`Invalid date format for --until: "${val}". Expected YYYY-MM-DD.`);
+                            }
+                            until = val;
+                            i++;
+                        }
+                        else if (arg.startsWith('--')) {
+                            throw new Error(`Unknown flag: ${arg}`);
+                        }
+                        else {
+                            const parsedLimit = parseInt(arg, 10);
+                            if (!isNaN(parsedLimit) && parsedLimit > 0) {
+                                limit = parsedLimit;
+                            }
+                            else {
+                                throw new Error(`Invalid argument: "${arg}". Expected a positive number or --until flag.`);
+                            }
+                        }
+                    }
+                }
+                return {
+                    type: 'custom_dialog',
+                    component: (_jsx(TriageIssues, { config: config, initialLimit: limit, until: until, onExit: () => context.ui.removeComponent() })),
+                };
+            },
+        },
+    ],
+};

package/dist/ui/commands/permissionsCommand.js

@@ -0,0 +1,74 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CommandKind } from './types.js';
+import * as process from 'node:process';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { expandHomeDir } from '../utils/directoryUtils.js';
+export const permissionsCommand = {
+    name: 'permissions',
+    description: 'Manage folder trust settings and other permissions',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: false,
+    subCommands: [
+        {
+            name: 'trust',
+            description: 'Manage folder trust settings. Usage: /permissions trust [<directory-path>]',
+            kind: CommandKind.BUILT_IN,
+            autoExecute: false,
+            action: (context, input) => {
+                const dirPath = input.trim();
+                let targetDirectory;
+                if (!dirPath) {
+                    targetDirectory = process.cwd();
+                }
+                else {
+                    targetDirectory = path.resolve(expandHomeDir(dirPath));
+                }
+                try {
+                    if (!fs.statSync(targetDirectory).isDirectory()) {
+                        return {
+                            type: 'message',
+                            messageType: 'error',
+                            content: `Path is not a directory: ${targetDirectory}`,
+                        };
+                    }
+                }
+                catch (e) {
+                    const message = e instanceof Error ? e.message : String(e);
+                    return {
+                        type: 'message',
+                        messageType: 'error',
+                        content: `Error accessing path: ${targetDirectory}. ${message}`,
+                    };
+                }
+                return {
+                    type: 'dialog',
+                    dialog: 'permissions',
+                    props: {
+                        targetDirectory,
+                    },
+                };
+            },
+        },
+    ],
+    action: (context, input) => {
+        const parts = input.trim().split(' ');
+        const subcommand = parts[0];
+        if (!subcommand) {
+            return {
+                type: 'message',
+                messageType: 'error',
+                content: `Please provide a subcommand for /permissions. Usage: /permissions trust [<directory-path>]`,
+            };
+        }
+        return {
+            type: 'message',
+            messageType: 'error',
+            content: `Invalid subcommand for /permissions: ${subcommand}. Usage: /permissions trust [<directory-path>]`,
+        };
+    },
+};

package/dist/ui/commands/planCommand.js

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CommandKind, } from './types.js';
+import { ApprovalMode, coreEvents, debugLogger, processSingleFileContent, partToString, readFileWithEncoding, } from '@google/gemini-cli-core';
+import { MessageType } from '../types.js';
+import * as path from 'node:path';
+import { copyToClipboard } from '../utils/commandUtils.js';
+async function copyAction(context) {
+    const config = context.services.agentContext?.config;
+    if (!config) {
+        debugLogger.debug('Plan copy command: config is not available in context');
+        return;
+    }
+    const planPath = config.getApprovedPlanPath();
+    if (!planPath) {
+        coreEvents.emitFeedback('warning', 'No approved plan found to copy.');
+        return;
+    }
+    try {
+        const content = await readFileWithEncoding(planPath);
+        await copyToClipboard(content);
+        coreEvents.emitFeedback('info', `Plan copied to clipboard (${path.basename(planPath)}).`);
+    }
+    catch (error) {
+        coreEvents.emitFeedback('error', `Failed to copy plan: ${error}`, error);
+    }
+}
+export const planCommand = {
+    name: 'plan',
+    description: 'Switch to Plan Mode and view current plan',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: false,
+    action: async (context) => {
+        const config = context.services.agentContext?.config;
+        if (!config) {
+            debugLogger.debug('Plan command: config is not available in context');
+            return;
+        }
+        const previousApprovalMode = config.getApprovalMode();
+        config.setApprovalMode(ApprovalMode.PLAN);
+        if (previousApprovalMode !== ApprovalMode.PLAN) {
+            coreEvents.emitFeedback('info', 'Switched to Plan Mode.');
+        }
+        if (context.invocation?.args) {
+            return {
+                type: 'submit_prompt',
+                content: context.invocation.args,
+            };
+        }
+        const approvedPlanPath = config.getApprovedPlanPath();
+        if (!approvedPlanPath) {
+            return;
+        }
+        try {
+            const content = await processSingleFileContent(approvedPlanPath, config.storage.getPlansDir(), config.getFileSystemService());
+            const fileName = path.basename(approvedPlanPath);
+            coreEvents.emitFeedback('info', `Approved Plan: ${fileName}`);
+            context.ui.addItem({
+                type: MessageType.GEMINI,
+                text: partToString(content.llmContent),
+            });
+            return;
+        }
+        catch (error) {
+            coreEvents.emitFeedback('error', `Failed to read approved plan at ${approvedPlanPath}: ${error}`, error);
+            return;
+        }
+    },
+    subCommands: [
+        {
+            name: 'copy',
+            description: 'Copy the currently approved plan to your clipboard',
+            kind: CommandKind.BUILT_IN,
+            autoExecute: true,
+            takesArgs: false,
+            action: copyAction,
+        },
+    ],
+};

package/dist/ui/commands/policiesCommand.js

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ApprovalMode } from '@google/gemini-cli-core';
+import { CommandKind } from './types.js';
+import { MessageType } from '../types.js';
+const categorizeRulesByMode = (rules) => {
+    const result = {
+        normal: [],
+        autoEdit: [],
+        yolo: [],
+        plan: [],
+    };
+    const ALL_MODES = Object.values(ApprovalMode);
+    rules.forEach((rule) => {
+        const modes = rule.modes?.length ? rule.modes : ALL_MODES;
+        const modeSet = new Set(modes);
+        if (modeSet.has(ApprovalMode.DEFAULT))
+            result.normal.push(rule);
+        if (modeSet.has(ApprovalMode.AUTO_EDIT))
+            result.autoEdit.push(rule);
+        if (modeSet.has(ApprovalMode.YOLO))
+            result.yolo.push(rule);
+        if (modeSet.has(ApprovalMode.PLAN))
+            result.plan.push(rule);
+    });
+    return result;
+};
+const formatRule = (rule, i) => `${i + 1}. **${rule.decision.toUpperCase()}** ${rule.toolName ? `tool: \`${rule.toolName}\`` : 'all tools'}` +
+    (rule.argsPattern ? ` (args match: \`${rule.argsPattern.source}\`)` : '') +
+    (rule.priority !== undefined ? ` [Priority: ${rule.priority}]` : '') +
+    (rule.source ? ` [Source: ${rule.source}]` : '');
+const formatSection = (title, rules) => `### ${title}\n${rules.length ? rules.map(formatRule).join('\n') : '_No policies._'}\n\n`;
+const listPoliciesCommand = {
+    name: 'list',
+    description: 'List all active policies grouped by mode',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: async (context) => {
+        const agentContext = context.services.agentContext;
+        const config = agentContext?.config;
+        if (!config) {
+            context.ui.addItem({
+                type: MessageType.ERROR,
+                text: 'Error: Config not available.',
+            }, Date.now());
+            return;
+        }
+        const policyEngine = config.getPolicyEngine();
+        const rules = policyEngine.getRules();
+        if (rules.length === 0) {
+            context.ui.addItem({
+                type: MessageType.INFO,
+                text: 'No active policies.',
+            }, Date.now());
+            return;
+        }
+        const categorized = categorizeRulesByMode(rules);
+        const normalRulesSet = new Set(categorized.normal);
+        const uniqueAutoEdit = categorized.autoEdit.filter((rule) => !normalRulesSet.has(rule));
+        const uniqueYolo = categorized.yolo.filter((rule) => !normalRulesSet.has(rule));
+        const uniquePlan = categorized.plan.filter((rule) => !normalRulesSet.has(rule));
+        let content = '**Active Policies**\n\n';
+        content += formatSection('Normal Mode Policies', categorized.normal);
+        content += formatSection('Auto Edit Mode Policies (combined with normal mode policies)', uniqueAutoEdit);
+        content += formatSection('Yolo Mode Policies (combined with normal mode policies)', uniqueYolo);
+        content += formatSection('Plan Mode Policies (combined with normal mode policies)', uniquePlan);
+        context.ui.addItem({
+            type: MessageType.INFO,
+            text: content,
+        }, Date.now());
+    },
+};
+export const policiesCommand = {
+    name: 'policies',
+    description: 'Manage policies',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: false,
+    subCommands: [listPoliciesCommand],
+};

package/dist/ui/commands/privacyCommand.js

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CommandKind, } from './types.js';
+export const privacyCommand = {
+    name: 'privacy',
+    description: 'Display the privacy notice',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: () => ({
+        type: 'dialog',
+        dialog: 'privacy',
+    }),
+};

package/dist/ui/commands/profileCommand.js

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isDevelopment } from '../../utils/installationInfo.js';
+import { CommandKind } from './types.js';
+export const profileCommand = isDevelopment
+    ? {
+        name: 'profile',
+        kind: CommandKind.BUILT_IN,
+        description: 'Toggle the debug profile display',
+        autoExecute: true,
+        action: async (context) => {
+            context.ui.toggleDebugProfiler();
+            return {
+                type: 'message',
+                messageType: 'info',
+                content: 'Toggled profile display.',
+            };
+        },
+    }
+    : null;

package/dist/ui/commands/quitCommand.js

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { formatDuration } from '../utils/formatters.js';
+import { CommandKind } from './types.js';
+export const quitCommand = {
+    name: 'quit',
+    altNames: ['exit'],
+    description: 'Exit the cli',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: (context, args) => {
+        const now = Date.now();
+        const { sessionStartTime } = context.session.stats;
+        const wallDuration = now - sessionStartTime.getTime();
+        const deleteSession = args.trim() === '--delete';
+        return {
+            type: 'quit',
+            deleteSession,
+            messages: [
+                {
+                    type: 'user',
+                    text: `/quit`, // Keep it consistent, even if /exit was used
+                    id: now - 1,
+                },
+                {
+                    type: 'quit',
+                    duration: formatDuration(wallDuration),
+                    id: now,
+                },
+            ],
+        };
+    },
+};

package/dist/ui/commands/restoreCommand.js

@@ -0,0 +1,131 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+import { formatCheckpointDisplayList, getToolCallDataSchema, getTruncatedCheckpointNames, performRestore, } from '@google/gemini-cli-core';
+import { CommandKind, } from './types.js';
+const HistoryItemSchema = z
+    .object({
+    type: z.string(),
+    id: z.number(),
+})
+    .passthrough();
+/* eslint-disable @typescript-eslint/no-unsafe-type-assertion */
+const ToolCallDataSchema = getToolCallDataSchema(HistoryItemSchema);
+/* eslint-enable @typescript-eslint/no-unsafe-type-assertion */
+async function restoreAction(context, args) {
+    const { services, ui } = context;
+    const { agentContext, git: gitService } = services;
+    const { addItem, loadHistory } = ui;
+    const checkpointDir = agentContext?.config.storage.getProjectTempCheckpointsDir();
+    if (!checkpointDir) {
+        return {
+            type: 'message',
+            messageType: 'error',
+            content: 'Could not determine the .gemini directory path.',
+        };
+    }
+    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 (!args) {
+            if (jsonFiles.length === 0) {
+                return {
+                    type: 'message',
+                    messageType: 'info',
+                    content: 'No restorable tool calls found.',
+                };
+            }
+            const fileList = formatCheckpointDisplayList(jsonFiles);
+            return {
+                type: 'message',
+                messageType: 'info',
+                content: `Available tool calls to restore:\n\n${fileList}`,
+            };
+        }
+        const selectedFile = args.endsWith('.json') ? args : `${args}.json`;
+        if (!jsonFiles.includes(selectedFile)) {
+            return {
+                type: 'message',
+                messageType: 'error',
+                content: `File not found: ${selectedFile}`,
+            };
+        }
+        const filePath = path.join(checkpointDir, selectedFile);
+        const data = await fs.readFile(filePath, 'utf-8');
+        const parseResult = ToolCallDataSchema.safeParse(JSON.parse(data));
+        if (!parseResult.success) {
+            return {
+                type: 'message',
+                messageType: 'error',
+                content: `Checkpoint file is invalid: ${parseResult.error.message}`,
+            };
+        }
+        // We safely cast here because:
+        // 1. ToolCallDataSchema strictly validates the existence of 'history' as an array and 'id'/'type' on each item.
+        // 2. We trust that files valid according to this schema (written by useGeminiStream) contain the full HistoryItem structure.
+        const toolCallData = parseResult.data;
+        const actionStream = performRestore(toolCallData, gitService);
+        for await (const action of actionStream) {
+            if (action.type === 'message') {
+                addItem({
+                    type: action.messageType,
+                    text: action.content,
+                }, Date.now());
+            }
+            else if (action.type === 'load_history' && loadHistory) {
+                loadHistory(action.history);
+                if (action.clientHistory) {
+                    agentContext.geminiClient?.setHistory(action.clientHistory);
+                }
+            }
+        }
+        return {
+            type: 'tool',
+            toolName: toolCallData.toolCall.name,
+            toolArgs: toolCallData.toolCall.args,
+        };
+    }
+    catch (error) {
+        return {
+            type: 'message',
+            messageType: 'error',
+            content: `Could not read restorable tool calls. This is the error: ${error}`,
+        };
+    }
+}
+async function completion(context, _partialArg) {
+    const { services } = context;
+    const { agentContext } = services;
+    const checkpointDir = agentContext?.config.storage.getProjectTempCheckpointsDir();
+    if (!checkpointDir) {
+        return [];
+    }
+    try {
+        const files = await fs.readdir(checkpointDir);
+        const jsonFiles = files.filter((file) => file.endsWith('.json'));
+        return getTruncatedCheckpointNames(jsonFiles);
+    }
+    catch {
+        return [];
+    }
+}
+export const restoreCommand = (config) => {
+    if (!config?.getCheckpointingEnabled()) {
+        return null;
+    }
+    return {
+        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',
+        kind: CommandKind.BUILT_IN,
+        autoExecute: true,
+        action: restoreAction,
+        completion,
+    };
+};

package/dist/ui/commands/resumeCommand.js

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CommandKind } from './types.js';
+import { chatResumeSubCommands } from './chatCommand.js';
+export const resumeCommand = {
+    name: 'resume',
+    description: 'Browse auto-saved conversations and manage chat checkpoints',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: async (_context, _args) => ({
+        type: 'dialog',
+        dialog: 'sessionBrowser',
+    }),
+    subCommands: chatResumeSubCommands,
+};