fss-link 1.0.49 → 1.0.51

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

@@ -1,52 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { helpCommand } from './helpCommand.js';
-import { type CommandContext } from './types.js';
-import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
-import { MessageType } from '../types.js';
-import { CommandKind } from './types.js';
-
-describe('helpCommand', () => {
-  let mockContext: CommandContext;
-  const originalEnv = { ...process.env };
-
-  beforeEach(() => {
-    mockContext = createMockCommandContext({
-      ui: {
-        addItem: vi.fn(),
-      },
-    } as unknown as CommandContext);
-  });
-
-  afterEach(() => {
-    process.env = { ...originalEnv };
-    vi.clearAllMocks();
-  });
-
-  it('should add a help message to the UI history', async () => {
-    if (!helpCommand.action) {
-      throw new Error('Help command has no action');
-    }
-
-    await helpCommand.action(mockContext, '');
-
-    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: MessageType.HELP,
-        timestamp: expect.any(Date),
-      }),
-      expect.any(Number),
-    );
-  });
-
-  it('should have the correct command properties', () => {
-    expect(helpCommand.name).toBe('help');
-    expect(helpCommand.kind).toBe(CommandKind.BUILT_IN);
-    expect(helpCommand.description).toBe('for help on FSS Link');
-  });
-});

package/dist/ui/commands/helpCommand.ts

@@ -1,23 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { CommandKind, SlashCommand } from './types.js';
-import { MessageType, type HistoryItemHelp } from '../types.js';
-
-export const helpCommand: SlashCommand = {
-  name: 'help',
-  altNames: ['?'],
-  kind: CommandKind.BUILT_IN,
-  description: 'for help on FSS Link',
-  action: async (context) => {
-    const helpItem: Omit<HistoryItemHelp, 'id'> = {
-      type: MessageType.HELP,
-      timestamp: new Date(),
-    };
-
-    context.ui.addItem(helpItem, Date.now());
-  },
-};

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

@@ -1,255 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {
-  MockInstance,
-  vi,
-  describe,
-  it,
-  expect,
-  beforeEach,
-  afterEach,
-} from 'vitest';
-import { ideCommand } from './ideCommand.js';
-import { type CommandContext } from './types.js';
-import { type Config, DetectedIde } from 'fss-link-core';
-import * as core from 'fss-link-core';
-
-vi.mock('child_process');
-vi.mock('glob');
-vi.mock('fss-link-core');
-
-describe('ideCommand', () => {
-  let mockContext: CommandContext;
-  let mockConfig: Config;
-  let platformSpy: MockInstance;
-
-  beforeEach(() => {
-    mockContext = {
-      ui: {
-        addItem: vi.fn(),
-      },
-      services: {
-        settings: {
-          setValue: vi.fn(),
-        },
-      },
-    } as unknown as CommandContext;
-
-    mockConfig = {
-      getIdeMode: vi.fn(),
-      getIdeClient: vi.fn(() => ({
-        reconnect: vi.fn(),
-        disconnect: vi.fn(),
-        getCurrentIde: vi.fn(),
-        getDetectedIdeDisplayName: vi.fn(),
-        getConnectionStatus: vi.fn(),
-      })),
-      setIdeModeAndSyncConnection: vi.fn(),
-      setIdeMode: vi.fn(),
-    } as unknown as Config;
-
-    platformSpy = vi.spyOn(process, 'platform', 'get');
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('should return null if config is not provided', () => {
-    const command = ideCommand(null);
-    expect(command).toBeNull();
-  });
-
-  it('should return the ide command', () => {
-    vi.mocked(mockConfig.getIdeMode).mockReturnValue(true);
-    vi.mocked(mockConfig.getIdeClient).mockReturnValue({
-      getCurrentIde: () => DetectedIde.VSCode,
-      getDetectedIdeDisplayName: () => 'VS Code',
-      getConnectionStatus: () => ({
-        status: core.IDEConnectionStatus.Disconnected,
-      }),
-    } as ReturnType<Config['getIdeClient']>);
-    const command = ideCommand(mockConfig);
-    expect(command).not.toBeNull();
-    expect(command?.name).toBe('ide');
-    expect(command?.subCommands).toHaveLength(3);
-    expect(command?.subCommands?.[0].name).toBe('enable');
-    expect(command?.subCommands?.[1].name).toBe('status');
-    expect(command?.subCommands?.[2].name).toBe('install');
-  });
-
-  it('should show disable command when connected', () => {
-    vi.mocked(mockConfig.getIdeMode).mockReturnValue(true);
-    vi.mocked(mockConfig.getIdeClient).mockReturnValue({
-      getCurrentIde: () => DetectedIde.VSCode,
-      getDetectedIdeDisplayName: () => 'VS Code',
-      getConnectionStatus: () => ({
-        status: core.IDEConnectionStatus.Connected,
-      }),
-    } as ReturnType<Config['getIdeClient']>);
-    const command = ideCommand(mockConfig);
-    expect(command).not.toBeNull();
-    const subCommandNames = command?.subCommands?.map((cmd) => cmd.name);
-    expect(subCommandNames).toContain('disable');
-    expect(subCommandNames).not.toContain('enable');
-  });
-
-  describe('status subcommand', () => {
-    const mockGetConnectionStatus = vi.fn();
-    beforeEach(() => {
-      vi.mocked(mockConfig.getIdeClient).mockReturnValue({
-        getConnectionStatus: mockGetConnectionStatus,
-        getCurrentIde: () => DetectedIde.VSCode,
-        getDetectedIdeDisplayName: () => 'VS Code',
-      } as unknown as ReturnType<Config['getIdeClient']>);
-    });
-
-    it('should show connected status', async () => {
-      mockGetConnectionStatus.mockReturnValue({
-        status: core.IDEConnectionStatus.Connected,
-      });
-      const command = ideCommand(mockConfig);
-      const result = await command!.subCommands!.find(
-        (c) => c.name === 'status',
-      )!.action!(mockContext, '');
-      expect(mockGetConnectionStatus).toHaveBeenCalled();
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'info',
-        content: '🟢 Connected to VS Code',
-      });
-    });
-
-    it('should show connecting status', async () => {
-      mockGetConnectionStatus.mockReturnValue({
-        status: core.IDEConnectionStatus.Connecting,
-      });
-      const command = ideCommand(mockConfig);
-      const result = await command!.subCommands!.find(
-        (c) => c.name === 'status',
-      )!.action!(mockContext, '');
-      expect(mockGetConnectionStatus).toHaveBeenCalled();
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'info',
-        content: `🟡 Connecting...`,
-      });
-    });
-    it('should show disconnected status', async () => {
-      mockGetConnectionStatus.mockReturnValue({
-        status: core.IDEConnectionStatus.Disconnected,
-      });
-      const command = ideCommand(mockConfig);
-      const result = await command!.subCommands!.find(
-        (c) => c.name === 'status',
-      )!.action!(mockContext, '');
-      expect(mockGetConnectionStatus).toHaveBeenCalled();
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'error',
-        content: `🔴 Disconnected`,
-      });
-    });
-
-    it('should show disconnected status with details', async () => {
-      const details = 'Something went wrong';
-      mockGetConnectionStatus.mockReturnValue({
-        status: core.IDEConnectionStatus.Disconnected,
-        details,
-      });
-      const command = ideCommand(mockConfig);
-      const result = await command!.subCommands!.find(
-        (c) => c.name === 'status',
-      )!.action!(mockContext, '');
-      expect(mockGetConnectionStatus).toHaveBeenCalled();
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'error',
-        content: `🔴 Disconnected: ${details}`,
-      });
-    });
-  });
-
-  describe('install subcommand', () => {
-    const mockInstall = vi.fn();
-    beforeEach(() => {
-      vi.mocked(mockConfig.getIdeMode).mockReturnValue(true);
-      vi.mocked(mockConfig.getIdeClient).mockReturnValue({
-        getCurrentIde: () => DetectedIde.VSCode,
-        getConnectionStatus: () => ({
-          status: core.IDEConnectionStatus.Disconnected,
-        }),
-        getDetectedIdeDisplayName: () => 'VS Code',
-      } as unknown as ReturnType<Config['getIdeClient']>);
-      vi.mocked(core.getIdeInstaller).mockReturnValue({
-        install: mockInstall,
-        isInstalled: vi.fn(),
-      });
-      platformSpy.mockReturnValue('linux');
-    });
-
-    it('should install the extension', async () => {
-      mockInstall.mockResolvedValue({
-        success: true,
-        message: 'Successfully installed.',
-      });
-
-      const command = ideCommand(mockConfig);
-      await command!.subCommands!.find((c) => c.name === 'install')!.action!(
-        mockContext,
-        '',
-      );
-
-      expect(core.getIdeInstaller).toHaveBeenCalledWith('vscode');
-      expect(mockInstall).toHaveBeenCalled();
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: 'info',
-          text: `Installing IDE companion...`,
-        }),
-        expect.any(Number),
-      );
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: 'info',
-          text: 'Successfully installed.',
-        }),
-        expect.any(Number),
-      );
-    }, 10000);
-
-    it('should show an error if installation fails', async () => {
-      mockInstall.mockResolvedValue({
-        success: false,
-        message: 'Installation failed.',
-      });
-
-      const command = ideCommand(mockConfig);
-      await command!.subCommands!.find((c) => c.name === 'install')!.action!(
-        mockContext,
-        '',
-      );
-
-      expect(core.getIdeInstaller).toHaveBeenCalledWith('vscode');
-      expect(mockInstall).toHaveBeenCalled();
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: 'info',
-          text: `Installing IDE companion...`,
-        }),
-        expect.any(Number),
-      );
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: 'error',
-          text: 'Installation failed.',
-        }),
-        expect.any(Number),
-      );
-    });
-  });
-});

package/dist/ui/commands/ideCommand.ts

@@ -1,283 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {
-  Config,
-  DetectedIde,
-  FSS_LINK_COMPANION_EXTENSION_NAME,
-  IDEConnectionStatus,
-  getIdeInfo,
-  getIdeInstaller,
-  IdeClient,
-  type File,
-  ideContext,
-} from 'fss-link-core';
-import path from 'node:path';
-import {
-  CommandContext,
-  SlashCommand,
-  SlashCommandActionReturn,
-  CommandKind,
-} from './types.js';
-import { SettingScope } from '../../config/settings.js';
-
-function getIdeStatusMessage(ideClient: IdeClient): {
-  messageType: 'info' | 'error';
-  content: string;
-} {
-  const connection = ideClient.getConnectionStatus();
-  switch (connection.status) {
-    case IDEConnectionStatus.Connected:
-      return {
-        messageType: 'info',
-        content: `🟢 Connected to ${ideClient.getDetectedIdeDisplayName()}`,
-      };
-    case IDEConnectionStatus.Connecting:
-      return {
-        messageType: 'info',
-        content: `🟡 Connecting...`,
-      };
-    default: {
-      let content = `🔴 Disconnected`;
-      if (connection?.details) {
-        content += `: ${connection.details}`;
-      }
-      return {
-        messageType: 'error',
-        content,
-      };
-    }
-  }
-}
-
-function formatFileList(openFiles: File[]): string {
-  const basenameCounts = new Map<string, number>();
-  for (const file of openFiles) {
-    const basename = path.basename(file.path);
-    basenameCounts.set(basename, (basenameCounts.get(basename) || 0) + 1);
-  }
-
-  const fileList = openFiles
-    .map((file: File) => {
-      const basename = path.basename(file.path);
-      const isDuplicate = (basenameCounts.get(basename) || 0) > 1;
-      const parentDir = path.basename(path.dirname(file.path));
-      const displayName = isDuplicate
-        ? `${basename} (/${parentDir})`
-        : basename;
-
-      return `  - ${displayName}${file.isActive ? ' (active)' : ''}`;
-    })
-    .join('\n');
-
-  const infoMessage = `
-(Note: The file list is limited to a number of recently accessed files within your workspace and only includes local files on disk)`;
-
-  return `\n\nOpen files:\n${fileList}\n${infoMessage}`;
-}
-
-async function getIdeStatusMessageWithFiles(ideClient: IdeClient): Promise<{
-  messageType: 'info' | 'error';
-  content: string;
-}> {
-  const connection = ideClient.getConnectionStatus();
-  switch (connection.status) {
-    case IDEConnectionStatus.Connected: {
-      let content = `🟢 Connected to ${ideClient.getDetectedIdeDisplayName()}`;
-      const context = ideContext.getIdeContext();
-      const openFiles = context?.workspaceState?.openFiles;
-      if (openFiles && openFiles.length > 0) {
-        content += formatFileList(openFiles);
-      }
-      return {
-        messageType: 'info',
-        content,
-      };
-    }
-    case IDEConnectionStatus.Connecting:
-      return {
-        messageType: 'info',
-        content: `🟡 Connecting...`,
-      };
-    default: {
-      let content = `🔴 Disconnected`;
-      if (connection?.details) {
-        content += `: ${connection.details}`;
-      }
-      return {
-        messageType: 'error',
-        content,
-      };
-    }
-  }
-}
-
-export const ideCommand = (config: Config | null): SlashCommand | null => {
-  if (!config) {
-    return null;
-  }
-  const ideClient = config.getIdeClient();
-  const currentIDE = ideClient.getCurrentIde();
-  if (!currentIDE || !ideClient.getDetectedIdeDisplayName()) {
-    return {
-      name: 'ide',
-      description: 'manage IDE integration',
-      kind: CommandKind.BUILT_IN,
-      action: (): SlashCommandActionReturn =>
-        ({
-          type: 'message',
-          messageType: 'error',
-          content: `IDE integration is not supported in your current environment. To use this feature, run FSS Link in one of these supported IDEs: ${Object.values(
-            DetectedIde,
-          )
-            .map((ide) => getIdeInfo(ide).displayName)
-            .join(', ')}`,
-        }) as const,
-    };
-  }
-
-  const ideSlashCommand: SlashCommand = {
-    name: 'ide',
-    description: 'manage IDE integration',
-    kind: CommandKind.BUILT_IN,
-    subCommands: [],
-  };
-
-  const statusCommand: SlashCommand = {
-    name: 'status',
-    description: 'check status of IDE integration',
-    kind: CommandKind.BUILT_IN,
-    action: async (): Promise<SlashCommandActionReturn> => {
-      const { messageType, content } =
-        await getIdeStatusMessageWithFiles(ideClient);
-      return {
-        type: 'message',
-        messageType,
-        content,
-      } as const;
-    },
-  };
-
-  const installCommand: SlashCommand = {
-    name: 'install',
-    description: `install required IDE companion for ${ideClient.getDetectedIdeDisplayName()}`,
-    kind: CommandKind.BUILT_IN,
-    action: async (context) => {
-      const installer = getIdeInstaller(currentIDE);
-      if (!installer) {
-        context.ui.addItem(
-          {
-            type: 'error',
-            text: `No installer is available for ${ideClient.getDetectedIdeDisplayName()}. Please install the '${FSS_LINK_COMPANION_EXTENSION_NAME}' extension manually from the marketplace.`,
-          },
-          Date.now(),
-        );
-        return;
-      }
-
-      context.ui.addItem(
-        {
-          type: 'info',
-          text: `Installing IDE companion...`,
-        },
-        Date.now(),
-      );
-
-      const result = await installer.install();
-      context.ui.addItem(
-        {
-          type: result.success ? 'info' : 'error',
-          text: result.message,
-        },
-        Date.now(),
-      );
-      if (result.success) {
-        context.services.settings.setValue(SettingScope.User, 'ideMode', true);
-        // Poll for up to 5 seconds for the extension to activate.
-        for (let i = 0; i < 10; i++) {
-          await config.setIdeModeAndSyncConnection(true);
-          if (
-            ideClient.getConnectionStatus().status ===
-            IDEConnectionStatus.Connected
-          ) {
-            break;
-          }
-          await new Promise((resolve) => setTimeout(resolve, 500));
-        }
-
-        const { messageType, content } = getIdeStatusMessage(ideClient);
-        if (messageType === 'error') {
-          context.ui.addItem(
-            {
-              type: messageType,
-              text: `Failed to automatically enable IDE integration. To fix this, run the CLI in a new terminal window.`,
-            },
-            Date.now(),
-          );
-        } else {
-          context.ui.addItem(
-            {
-              type: messageType,
-              text: content,
-            },
-            Date.now(),
-          );
-        }
-      }
-    },
-  };
-
-  const enableCommand: SlashCommand = {
-    name: 'enable',
-    description: 'enable IDE integration',
-    kind: CommandKind.BUILT_IN,
-    action: async (context: CommandContext) => {
-      context.services.settings.setValue(SettingScope.User, 'ideMode', true);
-      await config.setIdeModeAndSyncConnection(true);
-      const { messageType, content } = getIdeStatusMessage(ideClient);
-      context.ui.addItem(
-        {
-          type: messageType,
-          text: content,
-        },
-        Date.now(),
-      );
-    },
-  };
-
-  const disableCommand: SlashCommand = {
-    name: 'disable',
-    description: 'disable IDE integration',
-    kind: CommandKind.BUILT_IN,
-    action: async (context: CommandContext) => {
-      context.services.settings.setValue(SettingScope.User, 'ideMode', false);
-      await config.setIdeModeAndSyncConnection(false);
-      const { messageType, content } = getIdeStatusMessage(ideClient);
-      context.ui.addItem(
-        {
-          type: messageType,
-          text: content,
-        },
-        Date.now(),
-      );
-    },
-  };
-
-  const { status } = ideClient.getConnectionStatus();
-  const isConnected = status === IDEConnectionStatus.Connected;
-
-  if (isConnected) {
-    ideSlashCommand.subCommands = [statusCommand, disableCommand];
-  } else {
-    ideSlashCommand.subCommands = [
-      enableCommand,
-      statusCommand,
-      installCommand,
-    ];
-  }
-
-  return ideSlashCommand;
-};