fss-link 1.0.40 → 1.0.45

package/dist/config/extension.test.ts

@@ -0,0 +1,236 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+  EXTENSIONS_CONFIG_FILENAME,
+  EXTENSIONS_DIRECTORY_NAME,
+  annotateActiveExtensions,
+  loadExtensions,
+} from './extension.js';
+
+vi.mock('os', async (importOriginal) => {
+  const os = await importOriginal<typeof import('os')>();
+  return {
+    ...os,
+    homedir: vi.fn(),
+  };
+});
+
+describe('loadExtensions', () => {
+  let tempWorkspaceDir: string;
+  let tempHomeDir: string;
+
+  beforeEach(() => {
+    tempWorkspaceDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'fss-link-test-workspace-'),
+    );
+    tempHomeDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'fss-link-test-home-'),
+    );
+    vi.mocked(os.homedir).mockReturnValue(tempHomeDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempWorkspaceDir, { recursive: true, force: true });
+    fs.rmSync(tempHomeDir, { recursive: true, force: true });
+  });
+
+  it('should include extension path in loaded extension', () => {
+    const workspaceExtensionsDir = path.join(
+      tempWorkspaceDir,
+      EXTENSIONS_DIRECTORY_NAME,
+    );
+    fs.mkdirSync(workspaceExtensionsDir, { recursive: true });
+
+    const extensionDir = path.join(workspaceExtensionsDir, 'test-extension');
+    fs.mkdirSync(extensionDir, { recursive: true });
+
+    const config = {
+      name: 'test-extension',
+      version: '1.0.0',
+    };
+    fs.writeFileSync(
+      path.join(extensionDir, EXTENSIONS_CONFIG_FILENAME),
+      JSON.stringify(config),
+    );
+
+    const extensions = loadExtensions(tempWorkspaceDir);
+    expect(extensions).toHaveLength(1);
+    expect(extensions[0].path).toBe(extensionDir);
+    expect(extensions[0].config.name).toBe('test-extension');
+  });
+
+  it('should include extension path in loaded extension', () => {
+    const workspaceExtensionsDir = path.join(
+      tempWorkspaceDir,
+      EXTENSIONS_DIRECTORY_NAME,
+    );
+    fs.mkdirSync(workspaceExtensionsDir, { recursive: true });
+
+    const extensionDir = path.join(workspaceExtensionsDir, 'test-extension');
+    fs.mkdirSync(extensionDir, { recursive: true });
+
+    const config = {
+      name: 'test-extension',
+      version: '1.0.0',
+    };
+    fs.writeFileSync(
+      path.join(extensionDir, EXTENSIONS_CONFIG_FILENAME),
+      JSON.stringify(config),
+    );
+
+    const extensions = loadExtensions(tempWorkspaceDir);
+    expect(extensions).toHaveLength(1);
+    expect(extensions[0].path).toBe(extensionDir);
+    expect(extensions[0].config.name).toBe('test-extension');
+  });
+
+  it('should include extension path in loaded extension', () => {
+    const workspaceExtensionsDir = path.join(
+      tempWorkspaceDir,
+      EXTENSIONS_DIRECTORY_NAME,
+    );
+    fs.mkdirSync(workspaceExtensionsDir, { recursive: true });
+
+    const extensionDir = path.join(workspaceExtensionsDir, 'test-extension');
+    fs.mkdirSync(extensionDir, { recursive: true });
+
+    const config = {
+      name: 'test-extension',
+      version: '1.0.0',
+    };
+    fs.writeFileSync(
+      path.join(extensionDir, EXTENSIONS_CONFIG_FILENAME),
+      JSON.stringify(config),
+    );
+
+    const extensions = loadExtensions(tempWorkspaceDir);
+    expect(extensions).toHaveLength(1);
+    expect(extensions[0].path).toBe(extensionDir);
+    expect(extensions[0].config.name).toBe('test-extension');
+  });
+
+  it('should load context file path when LINK.md is present', () => {
+    const workspaceExtensionsDir = path.join(
+      tempWorkspaceDir,
+      EXTENSIONS_DIRECTORY_NAME,
+    );
+    fs.mkdirSync(workspaceExtensionsDir, { recursive: true });
+    createExtension(workspaceExtensionsDir, 'ext1', '1.0.0', true);
+    createExtension(workspaceExtensionsDir, 'ext2', '2.0.0');
+
+    const extensions = loadExtensions(tempWorkspaceDir);
+
+    expect(extensions).toHaveLength(2);
+    const ext1 = extensions.find((e) => e.config.name === 'ext1');
+    const ext2 = extensions.find((e) => e.config.name === 'ext2');
+    expect(ext1?.contextFiles).toEqual([
+      path.join(workspaceExtensionsDir, 'ext1', 'LINK.md'),
+    ]);
+    expect(ext2?.contextFiles).toEqual([]);
+  });
+
+  it('should load context file path from the extension config', () => {
+    const workspaceExtensionsDir = path.join(
+      tempWorkspaceDir,
+      EXTENSIONS_DIRECTORY_NAME,
+    );
+    fs.mkdirSync(workspaceExtensionsDir, { recursive: true });
+    createExtension(
+      workspaceExtensionsDir,
+      'ext1',
+      '1.0.0',
+      false,
+      'my-context-file.md',
+    );
+
+    const extensions = loadExtensions(tempWorkspaceDir);
+
+    expect(extensions).toHaveLength(1);
+    const ext1 = extensions.find((e) => e.config.name === 'ext1');
+    expect(ext1?.contextFiles).toEqual([
+      path.join(workspaceExtensionsDir, 'ext1', 'my-context-file.md'),
+    ]);
+  });
+});
+
+describe('annotateActiveExtensions', () => {
+  const extensions = [
+    { config: { name: 'ext1', version: '1.0.0' }, contextFiles: [] },
+    { config: { name: 'ext2', version: '1.0.0' }, contextFiles: [] },
+    { config: { name: 'ext3', version: '1.0.0' }, contextFiles: [] },
+  ];
+
+  it('should mark all extensions as active if no enabled extensions are provided', () => {
+    const activeExtensions = annotateActiveExtensions(extensions, []);
+    expect(activeExtensions).toHaveLength(3);
+    expect(activeExtensions.every((e) => e.isActive)).toBe(true);
+  });
+
+  it('should mark only the enabled extensions as active', () => {
+    const activeExtensions = annotateActiveExtensions(extensions, [
+      'ext1',
+      'ext3',
+    ]);
+    expect(activeExtensions).toHaveLength(3);
+    expect(activeExtensions.find((e) => e.name === 'ext1')?.isActive).toBe(
+      true,
+    );
+    expect(activeExtensions.find((e) => e.name === 'ext2')?.isActive).toBe(
+      false,
+    );
+    expect(activeExtensions.find((e) => e.name === 'ext3')?.isActive).toBe(
+      true,
+    );
+  });
+
+  it('should mark all extensions as inactive when "none" is provided', () => {
+    const activeExtensions = annotateActiveExtensions(extensions, ['none']);
+    expect(activeExtensions).toHaveLength(3);
+    expect(activeExtensions.every((e) => !e.isActive)).toBe(true);
+  });
+
+  it('should handle case-insensitivity', () => {
+    const activeExtensions = annotateActiveExtensions(extensions, ['EXT1']);
+    expect(activeExtensions.find((e) => e.name === 'ext1')?.isActive).toBe(
+      true,
+    );
+  });
+
+  it('should log an error for unknown extensions', () => {
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    annotateActiveExtensions(extensions, ['ext4']);
+    expect(consoleSpy).toHaveBeenCalledWith('Extension not found: ext4');
+    consoleSpy.mockRestore();
+  });
+});
+
+function createExtension(
+  extensionsDir: string,
+  name: string,
+  version: string,
+  addContextFile = false,
+  contextFileName?: string,
+): void {
+  const extDir = path.join(extensionsDir, name);
+  fs.mkdirSync(extDir);
+  fs.writeFileSync(
+    path.join(extDir, EXTENSIONS_CONFIG_FILENAME),
+    JSON.stringify({ name, version, contextFileName }),
+  );
+
+  if (addContextFile) {
+    fs.writeFileSync(path.join(extDir, 'LINK.md'), 'context');
+  }
+
+  if (contextFileName) {
+    fs.writeFileSync(path.join(extDir, contextFileName), 'context');
+  }
+}

package/dist/config/extension.ts

@@ -0,0 +1,180 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { MCPServerConfig, GeminiCLIExtension } from 'fss-link-core';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+export const EXTENSIONS_DIRECTORY_NAME = path.join('.fss-link', 'extensions');
+export const EXTENSIONS_CONFIG_FILENAME = 'fss-link-extension.json';
+export const EXTENSIONS_CONFIG_FILENAME_OLD = 'qwen-extension.json';
+
+export interface Extension {
+  path: string;
+  config: ExtensionConfig;
+  contextFiles: string[];
+}
+
+export interface ExtensionConfig {
+  name: string;
+  version: string;
+  mcpServers?: Record<string, MCPServerConfig>;
+  contextFileName?: string | string[];
+  excludeTools?: string[];
+}
+
+export function loadExtensions(workspaceDir: string): Extension[] {
+  const allExtensions = [
+    ...loadExtensionsFromDir(workspaceDir),
+    ...loadExtensionsFromDir(os.homedir()),
+  ];
+
+  const uniqueExtensions = new Map<string, Extension>();
+  for (const extension of allExtensions) {
+    if (!uniqueExtensions.has(extension.config.name)) {
+      uniqueExtensions.set(extension.config.name, extension);
+    }
+  }
+
+  return Array.from(uniqueExtensions.values());
+}
+
+function loadExtensionsFromDir(dir: string): Extension[] {
+  const extensionsDir = path.join(dir, EXTENSIONS_DIRECTORY_NAME);
+  if (!fs.existsSync(extensionsDir)) {
+    return [];
+  }
+
+  const extensions: Extension[] = [];
+  for (const subdir of fs.readdirSync(extensionsDir)) {
+    const extensionDir = path.join(extensionsDir, subdir);
+
+    const extension = loadExtension(extensionDir);
+    if (extension != null) {
+      extensions.push(extension);
+    }
+  }
+  return extensions;
+}
+
+function loadExtension(extensionDir: string): Extension | null {
+  if (!fs.statSync(extensionDir).isDirectory()) {
+    console.error(
+      `Warning: unexpected file ${extensionDir} in extensions directory.`,
+    );
+    return null;
+  }
+
+  let configFilePath = path.join(extensionDir, EXTENSIONS_CONFIG_FILENAME);
+  if (!fs.existsSync(configFilePath)) {
+    const oldConfigFilePath = path.join(
+      extensionDir,
+      EXTENSIONS_CONFIG_FILENAME_OLD,
+    );
+    if (!fs.existsSync(oldConfigFilePath)) {
+      console.error(
+        `Warning: extension directory ${extensionDir} does not contain a config file ${configFilePath}.`,
+      );
+      return null;
+    }
+    configFilePath = oldConfigFilePath;
+  }
+
+  try {
+    const configContent = fs.readFileSync(configFilePath, 'utf-8');
+    const config = JSON.parse(configContent) as ExtensionConfig;
+    if (!config.name || !config.version) {
+      console.error(
+        `Invalid extension config in ${configFilePath}: missing name or version.`,
+      );
+      return null;
+    }
+
+    const contextFiles = getContextFileNames(config)
+      .map((contextFileName) => path.join(extensionDir, contextFileName))
+      .filter((contextFilePath) => fs.existsSync(contextFilePath));
+
+    return {
+      path: extensionDir,
+      config,
+      contextFiles,
+    };
+  } catch (e) {
+    console.error(
+      `Warning: error parsing extension config in ${configFilePath}: ${e}`,
+    );
+    return null;
+  }
+}
+
+function getContextFileNames(config: ExtensionConfig): string[] {
+  if (!config.contextFileName) {
+    return ['LINK.md'];
+  } else if (!Array.isArray(config.contextFileName)) {
+    // Auto-migrate QWEN.md → LINK.md for single string
+    const migrated = config.contextFileName === 'QWEN.md' ? 'LINK.md' : config.contextFileName;
+    return [migrated];
+  }
+  // Auto-migrate QWEN.md → LINK.md for arrays
+  return config.contextFileName.map(name => name === 'QWEN.md' ? 'LINK.md' : name);
+}
+
+export function annotateActiveExtensions(
+  extensions: Extension[],
+  enabledExtensionNames: string[],
+): GeminiCLIExtension[] {
+  const annotatedExtensions: GeminiCLIExtension[] = [];
+
+  if (enabledExtensionNames.length === 0) {
+    return extensions.map((extension) => ({
+      name: extension.config.name,
+      version: extension.config.version,
+      isActive: true,
+      path: extension.path,
+    }));
+  }
+
+  const lowerCaseEnabledExtensions = new Set(
+    enabledExtensionNames.map((e) => e.trim().toLowerCase()),
+  );
+
+  if (
+    lowerCaseEnabledExtensions.size === 1 &&
+    lowerCaseEnabledExtensions.has('none')
+  ) {
+    return extensions.map((extension) => ({
+      name: extension.config.name,
+      version: extension.config.version,
+      isActive: false,
+      path: extension.path,
+    }));
+  }
+
+  const notFoundNames = new Set(lowerCaseEnabledExtensions);
+
+  for (const extension of extensions) {
+    const lowerCaseName = extension.config.name.toLowerCase();
+    const isActive = lowerCaseEnabledExtensions.has(lowerCaseName);
+
+    if (isActive) {
+      notFoundNames.delete(lowerCaseName);
+    }
+
+    annotatedExtensions.push({
+      name: extension.config.name,
+      version: extension.config.version,
+      isActive,
+      path: extension.path,
+    });
+  }
+
+  for (const requestedName of notFoundNames) {
+    console.error(`Extension not found: ${requestedName}`);
+  }
+
+  return annotatedExtensions;
+}

package/dist/config/keyBindings.test.ts

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  Command,
+  KeyBindingConfig,
+  defaultKeyBindings,
+} from './keyBindings.js';
+
+describe('keyBindings config', () => {
+  describe('defaultKeyBindings', () => {
+    it('should have bindings for all commands', () => {
+      const commands = Object.values(Command);
+
+      for (const command of commands) {
+        expect(defaultKeyBindings[command]).toBeDefined();
+        expect(Array.isArray(defaultKeyBindings[command])).toBe(true);
+      }
+    });
+
+    it('should have valid key binding structures', () => {
+      for (const [_, bindings] of Object.entries(defaultKeyBindings)) {
+        for (const binding of bindings) {
+          // Each binding should have either key or sequence, but not both
+          const hasKey = binding.key !== undefined;
+          const hasSequence = binding.sequence !== undefined;
+
+          expect(hasKey || hasSequence).toBe(true);
+          expect(hasKey && hasSequence).toBe(false);
+
+          // Modifier properties should be boolean or undefined
+          if (binding.ctrl !== undefined) {
+            expect(typeof binding.ctrl).toBe('boolean');
+          }
+          if (binding.shift !== undefined) {
+            expect(typeof binding.shift).toBe('boolean');
+          }
+          if (binding.command !== undefined) {
+            expect(typeof binding.command).toBe('boolean');
+          }
+          if (binding.paste !== undefined) {
+            expect(typeof binding.paste).toBe('boolean');
+          }
+        }
+      }
+    });
+
+    it('should export all required types', () => {
+      // Basic type checks
+      expect(typeof Command.HOME).toBe('string');
+      expect(typeof Command.END).toBe('string');
+
+      // Config should be readonly
+      const config: KeyBindingConfig = defaultKeyBindings;
+      expect(config[Command.HOME]).toBeDefined();
+    });
+  });
+});

package/dist/config/keyBindings.ts

@@ -0,0 +1,184 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Command enum for all available keyboard shortcuts
+ */
+export enum Command {
+  // Basic bindings
+  RETURN = 'return',
+  ESCAPE = 'escape',
+
+  // Cursor movement
+  HOME = 'home',
+  END = 'end',
+
+  // Text deletion
+  KILL_LINE_RIGHT = 'killLineRight',
+  KILL_LINE_LEFT = 'killLineLeft',
+  CLEAR_INPUT = 'clearInput',
+
+  // Screen control
+  CLEAR_SCREEN = 'clearScreen',
+
+  // History navigation
+  HISTORY_UP = 'historyUp',
+  HISTORY_DOWN = 'historyDown',
+  NAVIGATION_UP = 'navigationUp',
+  NAVIGATION_DOWN = 'navigationDown',
+
+  // Auto-completion
+  ACCEPT_SUGGESTION = 'acceptSuggestion',
+  COMPLETION_UP = 'completionUp',
+  COMPLETION_DOWN = 'completionDown',
+
+  // Text input
+  SUBMIT = 'submit',
+  NEWLINE = 'newline',
+
+  // External tools
+  OPEN_EXTERNAL_EDITOR = 'openExternalEditor',
+  PASTE_CLIPBOARD_IMAGE = 'pasteClipboardImage',
+
+  // App level bindings
+  SHOW_ERROR_DETAILS = 'showErrorDetails',
+  TOGGLE_TOOL_DESCRIPTIONS = 'toggleToolDescriptions',
+  TOGGLE_IDE_CONTEXT_DETAIL = 'toggleIDEContextDetail',
+  QUIT = 'quit',
+  EXIT = 'exit',
+  SHOW_MORE_LINES = 'showMoreLines',
+
+  // Shell commands
+  REVERSE_SEARCH = 'reverseSearch',
+  SUBMIT_REVERSE_SEARCH = 'submitReverseSearch',
+  ACCEPT_SUGGESTION_REVERSE_SEARCH = 'acceptSuggestionReverseSearch',
+}
+
+/**
+ * Data-driven key binding structure for user configuration
+ */
+export interface KeyBinding {
+  /** The key name (e.g., 'a', 'return', 'tab', 'escape') */
+  key?: string;
+  /** The key sequence (e.g., '\x18' for Ctrl+X) - alternative to key name */
+  sequence?: string;
+  /** Control key requirement: true=must be pressed, false=must not be pressed, undefined=ignore */
+  ctrl?: boolean;
+  /** Shift key requirement: true=must be pressed, false=must not be pressed, undefined=ignore */
+  shift?: boolean;
+  /** Command/meta key requirement: true=must be pressed, false=must not be pressed, undefined=ignore */
+  command?: boolean;
+  /** Paste operation requirement: true=must be paste, false=must not be paste, undefined=ignore */
+  paste?: boolean;
+}
+
+/**
+ * Configuration type mapping commands to their key bindings
+ */
+export type KeyBindingConfig = {
+  readonly [C in Command]: readonly KeyBinding[];
+};
+
+/**
+ * Default key binding configuration
+ * Matches the original hard-coded logic exactly
+ */
+export const defaultKeyBindings: KeyBindingConfig = {
+  // Basic bindings
+  [Command.RETURN]: [{ key: 'return' }],
+  // Original: key.name === 'escape'
+  [Command.ESCAPE]: [{ key: 'escape' }],
+
+  // Cursor movement
+  // Original: key.ctrl && key.name === 'a'
+  [Command.HOME]: [{ key: 'a', ctrl: true }],
+  // Original: key.ctrl && key.name === 'e'
+  [Command.END]: [{ key: 'e', ctrl: true }],
+
+  // Text deletion
+  // Original: key.ctrl && key.name === 'k'
+  [Command.KILL_LINE_RIGHT]: [{ key: 'k', ctrl: true }],
+  // Original: key.ctrl && key.name === 'u'
+  [Command.KILL_LINE_LEFT]: [{ key: 'u', ctrl: true }],
+  // Original: key.ctrl && key.name === 'c'
+  [Command.CLEAR_INPUT]: [{ key: 'c', ctrl: true }],
+
+  // Screen control
+  // Original: key.ctrl && key.name === 'l'
+  [Command.CLEAR_SCREEN]: [{ key: 'l', ctrl: true }],
+
+  // History navigation
+  // Original: key.ctrl && key.name === 'p'
+  [Command.HISTORY_UP]: [{ key: 'p', ctrl: true }],
+  // Original: key.ctrl && key.name === 'n'
+  [Command.HISTORY_DOWN]: [{ key: 'n', ctrl: true }],
+  // Original: key.name === 'up'
+  [Command.NAVIGATION_UP]: [{ key: 'up' }],
+  // Original: key.name === 'down'
+  [Command.NAVIGATION_DOWN]: [{ key: 'down' }],
+
+  // Auto-completion
+  // Original: key.name === 'tab' || (key.name === 'return' && !key.ctrl)
+  [Command.ACCEPT_SUGGESTION]: [{ key: 'tab' }, { key: 'return', ctrl: false }],
+  // Completion navigation (arrow or Ctrl+P/N)
+  [Command.COMPLETION_UP]: [{ key: 'up' }, { key: 'p', ctrl: true }],
+  [Command.COMPLETION_DOWN]: [{ key: 'down' }, { key: 'n', ctrl: true }],
+
+  // Text input
+  // Original: key.name === 'return' && !key.ctrl && !key.meta && !key.paste
+  // Must also exclude shift to allow shift+enter for newline
+  [Command.SUBMIT]: [
+    {
+      key: 'return',
+      ctrl: false,
+      command: false,
+      paste: false,
+      shift: false,
+    },
+  ],
+  // Original: key.name === 'return' && (key.ctrl || key.meta || key.paste)
+  // Split into multiple data-driven bindings
+  // Now also includes shift+enter for multi-line input
+  [Command.NEWLINE]: [
+    { key: 'return', ctrl: true },
+    { key: 'return', command: true },
+    { key: 'return', paste: true },
+    { key: 'return', shift: true },
+    { key: 'j', ctrl: true },
+  ],
+
+  // External tools
+  // Original: key.ctrl && (key.name === 'x' || key.sequence === '\x18')
+  [Command.OPEN_EXTERNAL_EDITOR]: [
+    { key: 'x', ctrl: true },
+    { sequence: '\x18', ctrl: true },
+  ],
+  // Original: key.ctrl && key.name === 'v'
+  [Command.PASTE_CLIPBOARD_IMAGE]: [{ key: 'v', ctrl: true }],
+
+  // App level bindings
+  // Original: key.ctrl && key.name === 'o'
+  [Command.SHOW_ERROR_DETAILS]: [{ key: 'o', ctrl: true }],
+  // Original: key.ctrl && key.name === 't'
+  [Command.TOGGLE_TOOL_DESCRIPTIONS]: [{ key: 't', ctrl: true }],
+  // Original: key.ctrl && key.name === 'g'
+  [Command.TOGGLE_IDE_CONTEXT_DETAIL]: [{ key: 'g', ctrl: true }],
+  // Original: key.ctrl && (key.name === 'c' || key.name === 'C')
+  [Command.QUIT]: [{ key: 'c', ctrl: true }],
+  // Original: key.ctrl && (key.name === 'd' || key.name === 'D')
+  [Command.EXIT]: [{ key: 'd', ctrl: true }],
+  // Original: key.ctrl && key.name === 's'
+  [Command.SHOW_MORE_LINES]: [{ key: 's', ctrl: true }],
+
+  // Shell commands
+  // Original: key.ctrl && key.name === 'r'
+  [Command.REVERSE_SEARCH]: [{ key: 'r', ctrl: true }],
+  // Original: key.name === 'return' && !key.ctrl
+  // Note: original logic ONLY checked ctrl=false, ignored meta/shift/paste
+  [Command.SUBMIT_REVERSE_SEARCH]: [{ key: 'return', ctrl: false }],
+  // Original: key.name === 'tab'
+  [Command.ACCEPT_SUGGESTION_REVERSE_SEARCH]: [{ key: 'tab' }],
+};