/**
 * @license
 * Copyright 2025 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */
import { getErrorMessage } from '@google/gemini-cli-core';
import { MessageType } from '../types.js';
import { loadHierarchicalGeminiMemory } from '../../config/config.js';
import { CommandKind } from './types.js';
export const memoryCommand = {
    name: 'memory',
    description: 'Commands for interacting with memory.',
    kind: CommandKind.BUILT_IN,
    subCommands: [
        {
            name: 'show',
            description: 'Show the current memory contents.',
            kind: CommandKind.BUILT_IN,
            action: async (context) => {
                const memoryContent = context.services.config?.getUserMemory() || '';
                const fileCount = context.services.config?.getGeminiMdFileCount() || 0;
                const messageContent = memoryContent.length > 0
                    ? `Current memory content from ${fileCount} file(s):\n\n---\n${memoryContent}\n---`
                    : 'Memory is currently empty.';
                context.ui.addItem({
                    type: MessageType.INFO,
                    text: messageContent,
                }, Date.now());
            },
        },
        {
            name: 'add',
            description: 'Add content to the memory.',
            kind: CommandKind.BUILT_IN,
            action: (context, args) => {
                if (!args || args.trim() === '') {
                    return {
                        type: 'message',
                        messageType: 'error',
                        content: 'Usage: /memory add <text to remember>',
                    };
                }
                context.ui.addItem({
                    type: MessageType.INFO,
                    text: `Attempting to save to memory: "${args.trim()}"`,
                }, Date.now());
                return {
                    type: 'tool',
                    toolName: 'save_memory',
                    toolArgs: { fact: args.trim() },
                };
            },
        },
        {
            name: 'refresh',
            description: 'Refresh the memory from the source.',
            kind: CommandKind.BUILT_IN,
            action: async (context) => {
                context.ui.addItem({
                    type: MessageType.INFO,
                    text: 'Refreshing memory from source files...',
                }, Date.now());
                try {
                    const config = await context.services.config;
                    const settings = context.services.settings;
                    if (config) {
                        const { memoryContent, fileCount, filePaths } = await loadHierarchicalGeminiMemory(config.getWorkingDir(), config.shouldLoadMemoryFromIncludeDirectories()
                            ? config.getWorkspaceContext().getDirectories()
                            : [], config.getDebugMode(), config.getFileService(), settings.merged, config.getExtensionContextFilePaths(), config.isTrustedFolder(), settings.merged.context?.importFormat || 'tree', config.getFileFilteringOptions());
                        config.setUserMemory(memoryContent);
                        config.setGeminiMdFileCount(fileCount);
                        config.setGeminiMdFilePaths(filePaths);
                        context.ui.setGeminiMdFileCount(fileCount);
                        const successMessage = memoryContent.length > 0
                            ? `Memory refreshed successfully. Loaded ${memoryContent.length} characters from ${fileCount} file(s).`
                            : 'Memory refreshed successfully. No memory content found.';
                        context.ui.addItem({
                            type: MessageType.INFO,
                            text: successMessage,
                        }, Date.now());
                    }
                }
                catch (error) {
                    const errorMessage = getErrorMessage(error);
                    context.ui.addItem({
                        type: MessageType.ERROR,
                        text: `Error refreshing memory: ${errorMessage}`,
                    }, Date.now());
                }
            },
        },
        {
            name: 'list',
            description: 'Lists the paths of the GEMINI.md files in use.',
            kind: CommandKind.BUILT_IN,
            action: async (context) => {
                const filePaths = context.services.config?.getGeminiMdFilePaths() || [];
                const fileCount = filePaths.length;
                const messageContent = fileCount > 0
                    ? `There are ${fileCount} GEMINI.md file(s) in use:\n\n${filePaths.join('\n')}`
                    : 'No GEMINI.md files in use.';
                context.ui.addItem({
                    type: MessageType.INFO,
                    text: messageContent,
                }, Date.now());
            },
        },
    ],
};
//# sourceMappingURL=memoryCommand.js.map