fss-link 1.0.49 → 1.0.51

package/dist/ui/commands/memoryCommand.test.ts

@@ -1,344 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { vi, describe, it, expect, beforeEach, Mock } from 'vitest';
-import { memoryCommand } from './memoryCommand.js';
-import { type CommandContext, SlashCommand } from './types.js';
-import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
-import { MessageType } from '../types.js';
-import { LoadedSettings } from '../../config/settings.js';
-import {
-  getErrorMessage,
-  loadServerHierarchicalMemory,
-  type FileDiscoveryService,
-} from 'fss-link-core';
-
-vi.mock('fss-link-core', async (importOriginal) => {
-  const original =
-    await importOriginal<typeof import('fss-link-core')>();
-  return {
-    ...original,
-    getErrorMessage: vi.fn((error: unknown) => {
-      if (error instanceof Error) return error.message;
-      return String(error);
-    }),
-    loadServerHierarchicalMemory: vi.fn(),
-  };
-});
-
-const mockLoadServerHierarchicalMemory = loadServerHierarchicalMemory as Mock;
-
-describe('memoryCommand', () => {
-  let mockContext: CommandContext;
-
-  const getSubCommand = (name: 'show' | 'add' | 'refresh'): SlashCommand => {
-    const subCommand = memoryCommand.subCommands?.find(
-      (cmd) => cmd.name === name,
-    );
-    if (!subCommand) {
-      throw new Error(`/memory ${name} command not found.`);
-    }
-    return subCommand;
-  };
-
-  describe('/memory show', () => {
-    let showCommand: SlashCommand;
-    let mockGetUserMemory: Mock;
-    let mockGetGeminiMdFileCount: Mock;
-
-    beforeEach(() => {
-      showCommand = getSubCommand('show');
-
-      mockGetUserMemory = vi.fn();
-      mockGetGeminiMdFileCount = vi.fn();
-
-      mockContext = createMockCommandContext({
-        services: {
-          config: {
-            getUserMemory: mockGetUserMemory,
-            getGeminiMdFileCount: mockGetGeminiMdFileCount,
-          },
-        },
-      });
-    });
-
-    it('should display a message if memory is empty', async () => {
-      if (!showCommand.action) throw new Error('Command has no action');
-
-      mockGetUserMemory.mockReturnValue('');
-      mockGetGeminiMdFileCount.mockReturnValue(0);
-
-      await showCommand.action(mockContext, '');
-
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        {
-          type: MessageType.INFO,
-          text: 'Memory is currently empty.',
-        },
-        expect.any(Number),
-      );
-    });
-
-    it('should display the memory content and file count if it exists', async () => {
-      if (!showCommand.action) throw new Error('Command has no action');
-
-      const memoryContent = 'This is a test memory.';
-
-      mockGetUserMemory.mockReturnValue(memoryContent);
-      mockGetGeminiMdFileCount.mockReturnValue(1);
-
-      await showCommand.action(mockContext, '');
-
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        {
-          type: MessageType.INFO,
-          text: `Current memory content from 1 file(s):\n\n---\n${memoryContent}\n---`,
-        },
-        expect.any(Number),
-      );
-    });
-  });
-
-  describe('/memory add', () => {
-    let addCommand: SlashCommand;
-
-    beforeEach(() => {
-      addCommand = getSubCommand('add');
-      mockContext = createMockCommandContext();
-    });
-
-    it('should return an error message if no arguments are provided', () => {
-      if (!addCommand.action) throw new Error('Command has no action');
-
-      const result = addCommand.action(mockContext, '  ');
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'error',
-        content: 'Usage: /memory add [--global|--project] <text to remember>',
-      });
-
-      expect(mockContext.ui.addItem).not.toHaveBeenCalled();
-    });
-
-    it('should return a tool action and add an info message when arguments are provided', () => {
-      if (!addCommand.action) throw new Error('Command has no action');
-
-      const fact = 'remember this';
-      const result = addCommand.action(mockContext, `  ${fact}  `);
-
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        {
-          type: MessageType.INFO,
-          text: `Attempting to save to memory : "${fact}"`,
-        },
-        expect.any(Number),
-      );
-
-      expect(result).toEqual({
-        type: 'tool',
-        toolName: 'save_memory',
-        toolArgs: { fact },
-      });
-    });
-
-    it('should handle --global flag and add scope to tool args', () => {
-      if (!addCommand.action) throw new Error('Command has no action');
-
-      const fact = 'remember this globally';
-      const result = addCommand.action(mockContext, `--global ${fact}`);
-
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        {
-          type: MessageType.INFO,
-          text: `Attempting to save to memory (global): "${fact}"`,
-        },
-        expect.any(Number),
-      );
-
-      expect(result).toEqual({
-        type: 'tool',
-        toolName: 'save_memory',
-        toolArgs: { fact, scope: 'global' },
-      });
-    });
-
-    it('should handle --project flag and add scope to tool args', () => {
-      if (!addCommand.action) throw new Error('Command has no action');
-
-      const fact = 'remember this for project';
-      const result = addCommand.action(mockContext, `--project ${fact}`);
-
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        {
-          type: MessageType.INFO,
-          text: `Attempting to save to memory (project): "${fact}"`,
-        },
-        expect.any(Number),
-      );
-
-      expect(result).toEqual({
-        type: 'tool',
-        toolName: 'save_memory',
-        toolArgs: { fact, scope: 'project' },
-      });
-    });
-
-    it('should return error if flag is provided but no fact follows', () => {
-      if (!addCommand.action) throw new Error('Command has no action');
-
-      const result = addCommand.action(mockContext, '--global   ');
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'error',
-        content: 'Usage: /memory add [--global|--project] <text to remember>',
-      });
-
-      expect(mockContext.ui.addItem).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('/memory refresh', () => {
-    let refreshCommand: SlashCommand;
-    let mockSetUserMemory: Mock;
-    let mockSetGeminiMdFileCount: Mock;
-
-    beforeEach(() => {
-      refreshCommand = getSubCommand('refresh');
-      mockSetUserMemory = vi.fn();
-      mockSetGeminiMdFileCount = vi.fn();
-      const mockConfig = {
-        setUserMemory: mockSetUserMemory,
-        setGeminiMdFileCount: mockSetGeminiMdFileCount,
-        getWorkingDir: () => '/test/dir',
-        getDebugMode: () => false,
-        getFileService: () => ({}) as FileDiscoveryService,
-        getExtensionContextFilePaths: () => [],
-        shouldLoadMemoryFromIncludeDirectories: () => false,
-        getWorkspaceContext: () => ({
-          getDirectories: () => [],
-        }),
-        getFileFilteringOptions: () => ({
-          ignore: [],
-          include: [],
-        }),
-      };
-
-      mockContext = createMockCommandContext({
-        services: {
-          config: mockConfig,
-          settings: {
-            merged: {
-              memoryDiscoveryMaxDirs: 1000,
-            },
-          } as LoadedSettings,
-        },
-      });
-      mockLoadServerHierarchicalMemory.mockClear();
-    });
-
-    it('should display success message when memory is refreshed with content', async () => {
-      if (!refreshCommand.action) throw new Error('Command has no action');
-
-      const refreshResult = {
-        memoryContent: 'new memory content',
-        fileCount: 2,
-      };
-      mockLoadServerHierarchicalMemory.mockResolvedValue(refreshResult);
-
-      await refreshCommand.action(mockContext, '');
-
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        {
-          type: MessageType.INFO,
-          text: 'Refreshing memory from source files...',
-        },
-        expect.any(Number),
-      );
-
-      expect(loadServerHierarchicalMemory).toHaveBeenCalledOnce();
-      expect(mockSetUserMemory).toHaveBeenCalledWith(
-        refreshResult.memoryContent,
-      );
-      expect(mockSetGeminiMdFileCount).toHaveBeenCalledWith(
-        refreshResult.fileCount,
-      );
-
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        {
-          type: MessageType.INFO,
-          text: 'Memory refreshed successfully. Loaded 18 characters from 2 file(s).',
-        },
-        expect.any(Number),
-      );
-    });
-
-    it('should display success message when memory is refreshed with no content', async () => {
-      if (!refreshCommand.action) throw new Error('Command has no action');
-
-      const refreshResult = { memoryContent: '', fileCount: 0 };
-      mockLoadServerHierarchicalMemory.mockResolvedValue(refreshResult);
-
-      await refreshCommand.action(mockContext, '');
-
-      expect(loadServerHierarchicalMemory).toHaveBeenCalledOnce();
-      expect(mockSetUserMemory).toHaveBeenCalledWith('');
-      expect(mockSetGeminiMdFileCount).toHaveBeenCalledWith(0);
-
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        {
-          type: MessageType.INFO,
-          text: 'Memory refreshed successfully. No memory content found.',
-        },
-        expect.any(Number),
-      );
-    });
-
-    it('should display an error message if refreshing fails', async () => {
-      if (!refreshCommand.action) throw new Error('Command has no action');
-
-      const error = new Error('Failed to read memory files.');
-      mockLoadServerHierarchicalMemory.mockRejectedValue(error);
-
-      await refreshCommand.action(mockContext, '');
-
-      expect(loadServerHierarchicalMemory).toHaveBeenCalledOnce();
-      expect(mockSetUserMemory).not.toHaveBeenCalled();
-      expect(mockSetGeminiMdFileCount).not.toHaveBeenCalled();
-
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        {
-          type: MessageType.ERROR,
-          text: `Error refreshing memory: ${error.message}`,
-        },
-        expect.any(Number),
-      );
-
-      expect(getErrorMessage).toHaveBeenCalledWith(error);
-    });
-
-    it('should not throw if config service is unavailable', async () => {
-      if (!refreshCommand.action) throw new Error('Command has no action');
-
-      const nullConfigContext = createMockCommandContext({
-        services: { config: null },
-      });
-
-      await expect(
-        refreshCommand.action(nullConfigContext, ''),
-      ).resolves.toBeUndefined();
-
-      expect(nullConfigContext.ui.addItem).toHaveBeenCalledWith(
-        {
-          type: MessageType.INFO,
-          text: 'Refreshing memory from source files...',
-        },
-        expect.any(Number),
-      );
-
-      expect(loadServerHierarchicalMemory).not.toHaveBeenCalled();
-    });
-  });
-});

package/dist/ui/commands/memoryCommand.ts

@@ -1,305 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {
-  getErrorMessage,
-  loadServerHierarchicalMemory,
-  FSS_LINK_DIR,
-} from 'fss-link-core';
-import path from 'node:path';
-import os from 'os';
-import fs from 'fs/promises';
-import { MessageType } from '../types.js';
-import {
-  CommandKind,
-  SlashCommand,
-  SlashCommandActionReturn,
-} from './types.js';
-
-export const memoryCommand: SlashCommand = {
-  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(),
-        );
-      },
-      subCommands: [
-        {
-          name: '--project',
-          description: 'Show project-level memory contents.',
-          kind: CommandKind.BUILT_IN,
-          action: async (context) => {
-            try {
-              const projectMemoryPath = path.join(process.cwd(), 'LINK.md');
-              const memoryContent = await fs.readFile(
-                projectMemoryPath,
-                'utf-8',
-              );
-
-              const messageContent =
-                memoryContent.trim().length > 0
-                  ? `Project memory content from ${projectMemoryPath}:\n\n---\n${memoryContent}\n---`
-                  : 'Project memory is currently empty.';
-
-              context.ui.addItem(
-                {
-                  type: MessageType.INFO,
-                  text: messageContent,
-                },
-                Date.now(),
-              );
-            } catch (_error) {
-              context.ui.addItem(
-                {
-                  type: MessageType.INFO,
-                  text: 'Project memory file not found or is currently empty.',
-                },
-                Date.now(),
-              );
-            }
-          },
-        },
-        {
-          name: '--global',
-          description: 'Show global memory contents.',
-          kind: CommandKind.BUILT_IN,
-          action: async (context) => {
-            try {
-              const globalMemoryPath = path.join(
-                os.homedir(),
-                FSS_LINK_DIR,
-                'LINK.md',
-              );
-              const globalMemoryContent = await fs.readFile(
-                globalMemoryPath,
-                'utf-8',
-              );
-
-              const messageContent =
-                globalMemoryContent.trim().length > 0
-                  ? `Global memory content:\n\n---\n${globalMemoryContent}\n---`
-                  : 'Global memory is currently empty.';
-
-              context.ui.addItem(
-                {
-                  type: MessageType.INFO,
-                  text: messageContent,
-                },
-                Date.now(),
-              );
-            } catch (_error) {
-              context.ui.addItem(
-                {
-                  type: MessageType.INFO,
-                  text: 'Global memory file not found or is currently empty.',
-                },
-                Date.now(),
-              );
-            }
-          },
-        },
-      ],
-    },
-    {
-      name: 'add',
-      description:
-        'Add content to the memory. Use --global for global memory or --project for project memory.',
-      kind: CommandKind.BUILT_IN,
-      action: (context, args): SlashCommandActionReturn | void => {
-        if (!args || args.trim() === '') {
-          return {
-            type: 'message',
-            messageType: 'error',
-            content:
-              'Usage: /memory add [--global|--project] <text to remember>',
-          };
-        }
-
-        const trimmedArgs = args.trim();
-        let scope: 'global' | 'project' | undefined;
-        let fact: string;
-
-        // Check for scope flags
-        if (trimmedArgs.startsWith('--global ')) {
-          scope = 'global';
-          fact = trimmedArgs.substring('--global '.length).trim();
-        } else if (trimmedArgs.startsWith('--project ')) {
-          scope = 'project';
-          fact = trimmedArgs.substring('--project '.length).trim();
-        } else if (trimmedArgs === '--global' || trimmedArgs === '--project') {
-          // Flag provided but no text after it
-          return {
-            type: 'message',
-            messageType: 'error',
-            content:
-              'Usage: /memory add [--global|--project] <text to remember>',
-          };
-        } else {
-          // No scope specified, will be handled by the tool
-          fact = trimmedArgs;
-        }
-
-        if (!fact || fact.trim() === '') {
-          return {
-            type: 'message',
-            messageType: 'error',
-            content:
-              'Usage: /memory add [--global|--project] <text to remember>',
-          };
-        }
-
-        const scopeText = scope ? `(${scope})` : '';
-        context.ui.addItem(
-          {
-            type: MessageType.INFO,
-            text: `Attempting to save to memory ${scopeText}: "${fact}"`,
-          },
-          Date.now(),
-        );
-
-        return {
-          type: 'tool',
-          toolName: 'save_memory',
-          toolArgs: scope ? { fact, scope } : { fact },
-        };
-      },
-      subCommands: [
-        {
-          name: '--project',
-          description: 'Add content to project-level memory.',
-          kind: CommandKind.BUILT_IN,
-          action: (context, args): SlashCommandActionReturn | void => {
-            if (!args || args.trim() === '') {
-              return {
-                type: 'message',
-                messageType: 'error',
-                content: 'Usage: /memory add --project <text to remember>',
-              };
-            }
-
-            context.ui.addItem(
-              {
-                type: MessageType.INFO,
-                text: `Attempting to save to project memory: "${args.trim()}"`,
-              },
-              Date.now(),
-            );
-
-            return {
-              type: 'tool',
-              toolName: 'save_memory',
-              toolArgs: { fact: args.trim(), scope: 'project' },
-            };
-          },
-        },
-        {
-          name: '--global',
-          description: 'Add content to global memory.',
-          kind: CommandKind.BUILT_IN,
-          action: (context, args): SlashCommandActionReturn | void => {
-            if (!args || args.trim() === '') {
-              return {
-                type: 'message',
-                messageType: 'error',
-                content: 'Usage: /memory add --global <text to remember>',
-              };
-            }
-
-            context.ui.addItem(
-              {
-                type: MessageType.INFO,
-                text: `Attempting to save to global memory: "${args.trim()}"`,
-              },
-              Date.now(),
-            );
-
-            return {
-              type: 'tool',
-              toolName: 'save_memory',
-              toolArgs: { fact: args.trim(), scope: 'global' },
-            };
-          },
-        },
-      ],
-    },
-    {
-      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 = context.services.config;
-          if (config) {
-            const { memoryContent, fileCount } =
-              await loadServerHierarchicalMemory(
-                config.getWorkingDir(),
-                config.shouldLoadMemoryFromIncludeDirectories()
-                  ? config.getWorkspaceContext().getDirectories()
-                  : [],
-                config.getDebugMode(),
-                config.getFileService(),
-                config.getExtensionContextFilePaths(),
-                context.services.settings.merged.memoryImportFormat || 'tree', // Use setting or default to 'tree'
-                config.getFileFilteringOptions(),
-                context.services.settings.merged.memoryDiscoveryMaxDirs,
-              );
-            config.setUserMemory(memoryContent);
-            config.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(),
-          );
-        }
-      },
-    },
-  ],
-};

package/dist/ui/commands/privacyCommand.test.ts

@@ -1,38 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { privacyCommand } from './privacyCommand.js';
-import { type CommandContext } from './types.js';
-import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
-
-describe('privacyCommand', () => {
-  let mockContext: CommandContext;
-
-  beforeEach(() => {
-    mockContext = createMockCommandContext();
-  });
-
-  it('should return a dialog action to open the privacy dialog', () => {
-    // Ensure the command has an action to test.
-    if (!privacyCommand.action) {
-      throw new Error('The privacy command must have an action.');
-    }
-
-    const result = privacyCommand.action(mockContext, '');
-
-    // Assert that the action returns the correct object to trigger the privacy dialog.
-    expect(result).toEqual({
-      type: 'dialog',
-      dialog: 'privacy',
-    });
-  });
-
-  it('should have the correct name and description', () => {
-    expect(privacyCommand.name).toBe('privacy');
-    expect(privacyCommand.description).toBe('display the privacy notice');
-  });
-});

package/dist/ui/commands/privacyCommand.ts

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