fss-link 1.0.40 → 1.0.45

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

@@ -0,0 +1,185 @@
+/**
+ * @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

@@ -0,0 +1,179 @@
+/**
+ * @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

@@ -0,0 +1,99 @@
+/**
+ * @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

@@ -0,0 +1,42 @@
+/**
+ * @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

@@ -0,0 +1,30 @@
+/**
+ * @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

@@ -0,0 +1,21 @@
+/**
+ * @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

@@ -0,0 +1,67 @@
+/**
+ * @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

@@ -0,0 +1,46 @@
+/**
+ * @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(),
+    );
+  },
+};