fss-link 1.0.49 → 1.0.51

package/dist/ui/commands/directoryCommand.test.tsx

@@ -1,185 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { directoryCommand, expandHomeDir } from './directoryCommand.js';
-import { Config, WorkspaceContext } from 'fss-link-core';
-import { CommandContext } from './types.js';
-import { MessageType } from '../types.js';
-import * as os from 'os';
-import * as path from 'path';
-
-describe('directoryCommand', () => {
-  let mockContext: CommandContext;
-  let mockConfig: Config;
-  let mockWorkspaceContext: WorkspaceContext;
-  const addCommand = directoryCommand.subCommands?.find(
-    (c) => c.name === 'add',
-  );
-  const showCommand = directoryCommand.subCommands?.find(
-    (c) => c.name === 'show',
-  );
-
-  beforeEach(() => {
-    mockWorkspaceContext = {
-      addDirectory: vi.fn(),
-      getDirectories: vi
-        .fn()
-        .mockReturnValue([
-          path.normalize('/home/user/project1'),
-          path.normalize('/home/user/project2'),
-        ]),
-    } as unknown as WorkspaceContext;
-
-    mockConfig = {
-      getWorkspaceContext: () => mockWorkspaceContext,
-      isRestrictiveSandbox: vi.fn().mockReturnValue(false),
-      getGeminiClient: vi.fn().mockReturnValue({
-        addDirectoryContext: vi.fn(),
-      }),
-      getWorkingDir: () => '/test/dir',
-      shouldLoadMemoryFromIncludeDirectories: () => false,
-      getDebugMode: () => false,
-      getFileService: () => ({}),
-      getExtensionContextFilePaths: () => [],
-      getFileFilteringOptions: () => ({ ignore: [], include: [] }),
-      setUserMemory: vi.fn(),
-      setGeminiMdFileCount: vi.fn(),
-    } as unknown as Config;
-
-    mockContext = {
-      services: {
-        config: mockConfig,
-        settings: {
-          merged: {
-            memoryDiscoveryMaxDirs: 1000,
-          },
-        },
-      },
-      ui: {
-        addItem: vi.fn(),
-      },
-    } as unknown as CommandContext;
-  });
-
-  describe('show', () => {
-    it('should display the list of directories', () => {
-      if (!showCommand?.action) throw new Error('No action');
-      showCommand.action(mockContext, '');
-      expect(mockWorkspaceContext.getDirectories).toHaveBeenCalled();
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: MessageType.INFO,
-          text: `Current workspace directories:\n- ${path.normalize(
-            '/home/user/project1',
-          )}\n- ${path.normalize('/home/user/project2')}`,
-        }),
-        expect.any(Number),
-      );
-    });
-  });
-
-  describe('add', () => {
-    it('should show an error if no path is provided', () => {
-      if (!addCommand?.action) throw new Error('No action');
-      addCommand.action(mockContext, '');
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: MessageType.ERROR,
-          text: 'Please provide at least one path to add.',
-        }),
-        expect.any(Number),
-      );
-    });
-
-    it('should call addDirectory and show a success message for a single path', async () => {
-      const newPath = path.normalize('/home/user/new-project');
-      if (!addCommand?.action) throw new Error('No action');
-      await addCommand.action(mockContext, newPath);
-      expect(mockWorkspaceContext.addDirectory).toHaveBeenCalledWith(newPath);
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: MessageType.INFO,
-          text: `Successfully added directories:\n- ${newPath}`,
-        }),
-        expect.any(Number),
-      );
-    });
-
-    it('should call addDirectory for each path and show a success message for multiple paths', async () => {
-      const newPath1 = path.normalize('/home/user/new-project1');
-      const newPath2 = path.normalize('/home/user/new-project2');
-      if (!addCommand?.action) throw new Error('No action');
-      await addCommand.action(mockContext, `${newPath1},${newPath2}`);
-      expect(mockWorkspaceContext.addDirectory).toHaveBeenCalledWith(newPath1);
-      expect(mockWorkspaceContext.addDirectory).toHaveBeenCalledWith(newPath2);
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: MessageType.INFO,
-          text: `Successfully added directories:\n- ${newPath1}\n- ${newPath2}`,
-        }),
-        expect.any(Number),
-      );
-    });
-
-    it('should show an error if addDirectory throws an exception', async () => {
-      const error = new Error('Directory does not exist');
-      vi.mocked(mockWorkspaceContext.addDirectory).mockImplementation(() => {
-        throw error;
-      });
-      const newPath = path.normalize('/home/user/invalid-project');
-      if (!addCommand?.action) throw new Error('No action');
-      await addCommand.action(mockContext, newPath);
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: MessageType.ERROR,
-          text: `Error adding '${newPath}': ${error.message}`,
-        }),
-        expect.any(Number),
-      );
-    });
-
-    it('should handle a mix of successful and failed additions', async () => {
-      const validPath = path.normalize('/home/user/valid-project');
-      const invalidPath = path.normalize('/home/user/invalid-project');
-      const error = new Error('Directory does not exist');
-      vi.mocked(mockWorkspaceContext.addDirectory).mockImplementation(
-        (p: string) => {
-          if (p === invalidPath) {
-            throw error;
-          }
-        },
-      );
-
-      if (!addCommand?.action) throw new Error('No action');
-      await addCommand.action(mockContext, `${validPath},${invalidPath}`);
-
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: MessageType.INFO,
-          text: `Successfully added directories:\n- ${validPath}`,
-        }),
-        expect.any(Number),
-      );
-
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: MessageType.ERROR,
-          text: `Error adding '${invalidPath}': ${error.message}`,
-        }),
-        expect.any(Number),
-      );
-    });
-  });
-  it('should correctly expand a Windows-style home directory path', () => {
-    const windowsPath = '%userprofile%\\Documents';
-    const expectedPath = path.win32.join(os.homedir(), 'Documents');
-    const result = expandHomeDir(windowsPath);
-    expect(path.win32.normalize(result)).toBe(
-      path.win32.normalize(expectedPath),
-    );
-  });
-});

package/dist/ui/commands/directoryCommand.tsx

@@ -1,179 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { SlashCommand, CommandContext, CommandKind } from './types.js';
-import { MessageType } from '../types.js';
-import * as os from 'os';
-import * as path from 'path';
-import { loadServerHierarchicalMemory } from 'fss-link-core';
-
-export function expandHomeDir(p: string): string {
-  if (!p) {
-    return '';
-  }
-  let expandedPath = p;
-  if (p.toLowerCase().startsWith('%userprofile%')) {
-    expandedPath = os.homedir() + p.substring('%userprofile%'.length);
-  } else if (p === '~' || p.startsWith('~/')) {
-    expandedPath = os.homedir() + p.substring(1);
-  }
-  return path.normalize(expandedPath);
-}
-
-export const directoryCommand: SlashCommand = {
-  name: 'directory',
-  altNames: ['dir'],
-  description: 'Manage workspace directories',
-  kind: CommandKind.BUILT_IN,
-  subCommands: [
-    {
-      name: 'add',
-      description:
-        'Add directories to the workspace. Use comma to separate multiple paths',
-      kind: CommandKind.BUILT_IN,
-      action: async (context: CommandContext, args: string) => {
-        const {
-          ui: { addItem },
-          services: { config },
-        } = context;
-        const [...rest] = args.split(' ');
-
-        if (!config) {
-          addItem(
-            {
-              type: MessageType.ERROR,
-              text: 'Configuration is not available.',
-            },
-            Date.now(),
-          );
-          return;
-        }
-
-        const workspaceContext = config.getWorkspaceContext();
-
-        const pathsToAdd = rest
-          .join(' ')
-          .split(',')
-          .filter((p) => p);
-        if (pathsToAdd.length === 0) {
-          addItem(
-            {
-              type: MessageType.ERROR,
-              text: 'Please provide at least one path to add.',
-            },
-            Date.now(),
-          );
-          return;
-        }
-
-        if (config.isRestrictiveSandbox()) {
-          return {
-            type: 'message' as const,
-            messageType: 'error' as const,
-            content:
-              'The /directory add command is not supported in restrictive sandbox profiles. Please use --include-directories when starting the session instead.',
-          };
-        }
-
-        const added: string[] = [];
-        const errors: string[] = [];
-
-        for (const pathToAdd of pathsToAdd) {
-          try {
-            workspaceContext.addDirectory(expandHomeDir(pathToAdd.trim()));
-            added.push(pathToAdd.trim());
-          } catch (e) {
-            const error = e as Error;
-            errors.push(`Error adding '${pathToAdd.trim()}': ${error.message}`);
-          }
-        }
-
-        if (added.length > 0) {
-          try {
-            if (config.shouldLoadMemoryFromIncludeDirectories()) {
-              const { memoryContent, fileCount } =
-                await loadServerHierarchicalMemory(
-                  config.getWorkingDir(),
-                  [...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);
-              context.ui.setGeminiMdFileCount(fileCount);
-            }
-            addItem(
-              {
-                type: MessageType.INFO,
-                text: `Successfully added memory files from the following directories if there are:\n- ${added.join('\n- ')}`,
-              },
-              Date.now(),
-            );
-          } catch (error) {
-            errors.push(`Error refreshing memory: ${(error as Error).message}`);
-          }
-        }
-
-        if (added.length > 0) {
-          const gemini = config.getGeminiClient();
-          if (gemini) {
-            await gemini.addDirectoryContext();
-          }
-          addItem(
-            {
-              type: MessageType.INFO,
-              text: `Successfully added directories:\n- ${added.join('\n- ')}`,
-            },
-            Date.now(),
-          );
-        }
-
-        if (errors.length > 0) {
-          addItem(
-            { type: MessageType.ERROR, text: errors.join('\n') },
-            Date.now(),
-          );
-        }
-        return;
-      },
-    },
-    {
-      name: 'show',
-      description: 'Show all directories in the workspace',
-      kind: CommandKind.BUILT_IN,
-      action: async (context: CommandContext) => {
-        const {
-          ui: { addItem },
-          services: { config },
-        } = context;
-        if (!config) {
-          addItem(
-            {
-              type: MessageType.ERROR,
-              text: 'Configuration is not available.',
-            },
-            Date.now(),
-          );
-          return;
-        }
-        const workspaceContext = config.getWorkspaceContext();
-        const directories = workspaceContext.getDirectories();
-        const directoryList = directories.map((dir) => `- ${dir}`).join('\n');
-        addItem(
-          {
-            type: MessageType.INFO,
-            text: `Current workspace directories:\n${directoryList}`,
-          },
-          Date.now(),
-        );
-      },
-    },
-  ],
-};

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

@@ -1,99 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
-import open from 'open';
-import { docsCommand } from './docsCommand.js';
-import { type CommandContext } from './types.js';
-import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
-import { MessageType } from '../types.js';
-
-// Mock the 'open' library
-vi.mock('open', () => ({
-  default: vi.fn(),
-}));
-
-describe('docsCommand', () => {
-  let mockContext: CommandContext;
-  beforeEach(() => {
-    // Create a fresh mock context before each test
-    mockContext = createMockCommandContext();
-    // Reset the `open` mock
-    vi.mocked(open).mockClear();
-  });
-
-  afterEach(() => {
-    // Restore any stubbed environment variables
-    vi.unstubAllEnvs();
-  });
-
-  it("should add an info message and call 'open' in a non-sandbox environment", async () => {
-    if (!docsCommand.action) {
-      throw new Error('docsCommand must have an action.');
-    }
-
-    const docsUrl = 'https://docs.anthropic.com/en/docs/claude-code';
-
-    await docsCommand.action(mockContext, '');
-
-    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-      {
-        type: MessageType.INFO,
-        text: `Opening documentation in your browser: ${docsUrl}`,
-      },
-      expect.any(Number),
-    );
-
-    expect(open).toHaveBeenCalledWith(docsUrl);
-  });
-
-  it('should only add an info message in a sandbox environment', async () => {
-    if (!docsCommand.action) {
-      throw new Error('docsCommand must have an action.');
-    }
-
-    // Simulate a sandbox environment
-    vi.stubEnv('SANDBOX', 'gemini-sandbox');
-    const docsUrl = 'https://docs.anthropic.com/en/docs/claude-code';
-
-    await docsCommand.action(mockContext, '');
-
-    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-      {
-        type: MessageType.INFO,
-        text: `Please open the following URL in your browser to view the documentation:\n${docsUrl}`,
-      },
-      expect.any(Number),
-    );
-
-    // Ensure 'open' was not called in the sandbox
-    expect(open).not.toHaveBeenCalled();
-  });
-
-  it("should not open browser for 'sandbox-exec'", async () => {
-    if (!docsCommand.action) {
-      throw new Error('docsCommand must have an action.');
-    }
-
-    // Simulate the specific 'sandbox-exec' environment
-    vi.stubEnv('SANDBOX', 'sandbox-exec');
-    const docsUrl = 'https://docs.anthropic.com/en/docs/claude-code';
-
-    await docsCommand.action(mockContext, '');
-
-    // The logic should fall through to the 'else' block
-    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-      {
-        type: MessageType.INFO,
-        text: `Opening documentation in your browser: ${docsUrl}`,
-      },
-      expect.any(Number),
-    );
-
-    // 'open' should be called in this specific sandbox case
-    expect(open).toHaveBeenCalledWith(docsUrl);
-  });
-});

package/dist/ui/commands/docsCommand.ts

@@ -1,42 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import open from 'open';
-import process from 'node:process';
-import {
-  type CommandContext,
-  type SlashCommand,
-  CommandKind,
-} from './types.js';
-import { MessageType } from '../types.js';
-
-export const docsCommand: SlashCommand = {
-  name: 'docs',
-  description: 'open full FSS Link documentation in your browser',
-  kind: CommandKind.BUILT_IN,
-  action: async (context: CommandContext): Promise<void> => {
-    const docsUrl = 'https://docs.anthropic.com/en/docs/claude-code';
-
-    if (process.env['SANDBOX'] && process.env['SANDBOX'] !== 'sandbox-exec') {
-      context.ui.addItem(
-        {
-          type: MessageType.INFO,
-          text: `Please open the following URL in your browser to view the documentation:\n${docsUrl}`,
-        },
-        Date.now(),
-      );
-    } else {
-      context.ui.addItem(
-        {
-          type: MessageType.INFO,
-          text: `Opening documentation in your browser: ${docsUrl}`,
-        },
-        Date.now(),
-      );
-      await open(docsUrl);
-    }
-  },
-};

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

@@ -1,30 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect } from 'vitest';
-import { editorCommand } from './editorCommand.js';
-// 1. Import the mock context utility
-import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
-
-describe('editorCommand', () => {
-  it('should return a dialog action to open the editor dialog', () => {
-    if (!editorCommand.action) {
-      throw new Error('The editor command must have an action.');
-    }
-    const mockContext = createMockCommandContext();
-    const result = editorCommand.action(mockContext, '');
-
-    expect(result).toEqual({
-      type: 'dialog',
-      dialog: 'editor',
-    });
-  });
-
-  it('should have the correct name and description', () => {
-    expect(editorCommand.name).toBe('editor');
-    expect(editorCommand.description).toBe('set external editor preference');
-  });
-});

package/dist/ui/commands/editorCommand.ts

@@ -1,21 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {
-  CommandKind,
-  type OpenDialogActionReturn,
-  type SlashCommand,
-} from './types.js';
-
-export const editorCommand: SlashCommand = {
-  name: 'editor',
-  description: 'set external editor preference',
-  kind: CommandKind.BUILT_IN,
-  action: (): OpenDialogActionReturn => ({
-    type: 'dialog',
-    dialog: 'editor',
-  }),
-};

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

@@ -1,67 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect } from 'vitest';
-import { extensionsCommand } from './extensionsCommand.js';
-import { type CommandContext } from './types.js';
-import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
-import { MessageType } from '../types.js';
-
-describe('extensionsCommand', () => {
-  let mockContext: CommandContext;
-
-  it('should display "No active extensions." when none are found', async () => {
-    mockContext = createMockCommandContext({
-      services: {
-        config: {
-          getExtensions: () => [],
-        },
-      },
-    });
-
-    if (!extensionsCommand.action) throw new Error('Action not defined');
-    await extensionsCommand.action(mockContext, '');
-
-    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-      {
-        type: MessageType.INFO,
-        text: 'No active extensions.',
-      },
-      expect.any(Number),
-    );
-  });
-
-  it('should list active extensions when they are found', async () => {
-    const mockExtensions = [
-      { name: 'ext-one', version: '1.0.0', isActive: true },
-      { name: 'ext-two', version: '2.1.0', isActive: true },
-      { name: 'ext-three', version: '3.0.0', isActive: false },
-    ];
-    mockContext = createMockCommandContext({
-      services: {
-        config: {
-          getExtensions: () => mockExtensions,
-        },
-      },
-    });
-
-    if (!extensionsCommand.action) throw new Error('Action not defined');
-    await extensionsCommand.action(mockContext, '');
-
-    const expectedMessage =
-      'Active extensions:\n\n' +
-      `  - \u001b[36mext-one (v1.0.0)\u001b[0m\n` +
-      `  - \u001b[36mext-two (v2.1.0)\u001b[0m\n`;
-
-    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-      {
-        type: MessageType.INFO,
-        text: expectedMessage,
-      },
-      expect.any(Number),
-    );
-  });
-});

package/dist/ui/commands/extensionsCommand.ts

@@ -1,46 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {
-  type CommandContext,
-  type SlashCommand,
-  CommandKind,
-} from './types.js';
-import { MessageType } from '../types.js';
-
-export const extensionsCommand: SlashCommand = {
-  name: 'extensions',
-  description: 'list active extensions',
-  kind: CommandKind.BUILT_IN,
-  action: async (context: CommandContext): Promise<void> => {
-    const activeExtensions = context.services.config
-      ?.getExtensions()
-      .filter((ext) => ext.isActive);
-    if (!activeExtensions || activeExtensions.length === 0) {
-      context.ui.addItem(
-        {
-          type: MessageType.INFO,
-          text: 'No active extensions.',
-        },
-        Date.now(),
-      );
-      return;
-    }
-
-    const extensionLines = activeExtensions.map(
-      (ext) => `  - \u001b[36m${ext.name} (v${ext.version})\u001b[0m`,
-    );
-    const message = `Active extensions:\n\n${extensionLines.join('\n')}\n`;
-
-    context.ui.addItem(
-      {
-        type: MessageType.INFO,
-        text: message,
-      },
-      Date.now(),
-    );
-  },
-};