fss-link 1.0.40 → 1.0.45

package/dist/ui/commands/statsCommand.ts

@@ -0,0 +1,70 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { MessageType, HistoryItemStats } from '../types.js';
+import { formatDuration } from '../utils/formatters.js';
+import {
+  type CommandContext,
+  type SlashCommand,
+  CommandKind,
+} from './types.js';
+
+export const statsCommand: SlashCommand = {
+  name: 'stats',
+  altNames: ['usage'],
+  description: 'check session stats. Usage: /stats [model|tools]',
+  kind: CommandKind.BUILT_IN,
+  action: (context: CommandContext) => {
+    const now = new Date();
+    const { sessionStartTime } = context.session.stats;
+    if (!sessionStartTime) {
+      context.ui.addItem(
+        {
+          type: MessageType.ERROR,
+          text: 'Session start time is unavailable, cannot calculate stats.',
+        },
+        Date.now(),
+      );
+      return;
+    }
+    const wallDuration = now.getTime() - sessionStartTime.getTime();
+
+    const statsItem: HistoryItemStats = {
+      type: MessageType.STATS,
+      duration: formatDuration(wallDuration),
+    };
+
+    context.ui.addItem(statsItem, Date.now());
+  },
+  subCommands: [
+    {
+      name: 'model',
+      description: 'Show model-specific usage statistics.',
+      kind: CommandKind.BUILT_IN,
+      action: (context: CommandContext) => {
+        context.ui.addItem(
+          {
+            type: MessageType.MODEL_STATS,
+          },
+          Date.now(),
+        );
+      },
+    },
+    {
+      name: 'tools',
+      description: 'Show tool-specific usage statistics.',
+      kind: CommandKind.BUILT_IN,
+      action: (context: CommandContext) => {
+        context.ui.addItem(
+          {
+            type: MessageType.TOOL_STATS,
+          },
+          Date.now(),
+        );
+      },
+    },
+  ],
+};

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

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { terminalSetupCommand } from './terminalSetupCommand.js';
+import * as terminalSetupModule from '../utils/terminalSetup.js';
+import { CommandContext } from './types.js';
+
+vi.mock('../utils/terminalSetup.js');
+
+describe('terminalSetupCommand', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should have correct metadata', () => {
+    expect(terminalSetupCommand.name).toBe('terminal-setup');
+    expect(terminalSetupCommand.description).toContain('multiline input');
+    expect(terminalSetupCommand.kind).toBe('built-in');
+  });
+
+  it('should return success message when terminal setup succeeds', async () => {
+    vi.spyOn(terminalSetupModule, 'terminalSetup').mockResolvedValue({
+      success: true,
+      message: 'Terminal configured successfully',
+    });
+
+    const result = await terminalSetupCommand.action({} as CommandContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      content: 'Terminal configured successfully',
+      messageType: 'info',
+    });
+  });
+
+  it('should append restart message when terminal setup requires restart', async () => {
+    vi.spyOn(terminalSetupModule, 'terminalSetup').mockResolvedValue({
+      success: true,
+      message: 'Terminal configured successfully',
+      requiresRestart: true,
+    });
+
+    const result = await terminalSetupCommand.action({} as CommandContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      content:
+        'Terminal configured successfully\n\nPlease restart your terminal for the changes to take effect.',
+      messageType: 'info',
+    });
+  });
+
+  it('should return error message when terminal setup fails', async () => {
+    vi.spyOn(terminalSetupModule, 'terminalSetup').mockResolvedValue({
+      success: false,
+      message: 'Failed to detect terminal',
+    });
+
+    const result = await terminalSetupCommand.action({} as CommandContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      content: 'Failed to detect terminal',
+      messageType: 'error',
+    });
+  });
+
+  it('should handle exceptions from terminal setup', async () => {
+    vi.spyOn(terminalSetupModule, 'terminalSetup').mockRejectedValue(
+      new Error('Unexpected error'),
+    );
+
+    const result = await terminalSetupCommand.action({} as CommandContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      content: 'Failed to configure terminal: Error: Unexpected error',
+      messageType: 'error',
+    });
+  });
+});

package/dist/ui/commands/terminalSetupCommand.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { MessageActionReturn, SlashCommand, CommandKind } from './types.js';
+import { terminalSetup } from '../utils/terminalSetup.js';
+
+/**
+ * Command to configure terminal keybindings for multiline input support.
+ *
+ * This command automatically detects and configures VS Code, Cursor, and Windsurf
+ * to support Shift+Enter and Ctrl+Enter for multiline input.
+ */
+export const terminalSetupCommand: SlashCommand = {
+  name: 'terminal-setup',
+  description:
+    'Configure terminal keybindings for multiline input (VS Code, Cursor, Windsurf)',
+  kind: CommandKind.BUILT_IN,
+
+  action: async (): Promise<MessageActionReturn> => {
+    try {
+      const result = await terminalSetup();
+
+      let content = result.message;
+      if (result.requiresRestart) {
+        content +=
+          '\n\nPlease restart your terminal for the changes to take effect.';
+      }
+
+      return {
+        type: 'message',
+        content,
+        messageType: result.success ? 'info' : 'error',
+      };
+    } catch (error) {
+      return {
+        type: 'message',
+        content: `Failed to configure terminal: ${error}`,
+        messageType: 'error',
+      };
+    }
+  },
+};

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

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

package/dist/ui/commands/themeCommand.ts

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

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

@@ -0,0 +1,105 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { toolsCommand } from './toolsCommand.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import { MessageType } from '../types.js';
+import { Tool } from 'fss-link-core';
+
+// Mock tools for testing
+const mockTools = [
+  {
+    name: 'file-reader',
+    displayName: 'File Reader',
+    description: 'Reads files from the local system.',
+    schema: {},
+  },
+  {
+    name: 'code-editor',
+    displayName: 'Code Editor',
+    description: 'Edits code files.',
+    schema: {},
+  },
+] as Tool[];
+
+describe('toolsCommand', () => {
+  it('should display an error if the tool registry is unavailable', async () => {
+    const mockContext = createMockCommandContext({
+      services: {
+        config: {
+          getToolRegistry: () => undefined,
+        },
+      },
+    });
+
+    if (!toolsCommand.action) throw new Error('Action not defined');
+    await toolsCommand.action(mockContext, '');
+
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      {
+        type: MessageType.ERROR,
+        text: 'Could not retrieve tool registry.',
+      },
+      expect.any(Number),
+    );
+  });
+
+  it('should display "No tools available" when none are found', async () => {
+    const mockContext = createMockCommandContext({
+      services: {
+        config: {
+          getToolRegistry: () => ({ getAllTools: () => [] as Tool[] }),
+        },
+      },
+    });
+
+    if (!toolsCommand.action) throw new Error('Action not defined');
+    await toolsCommand.action(mockContext, '');
+
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        text: expect.stringContaining('No tools available'),
+      }),
+      expect.any(Number),
+    );
+  });
+
+  it('should list tools without descriptions by default', async () => {
+    const mockContext = createMockCommandContext({
+      services: {
+        config: {
+          getToolRegistry: () => ({ getAllTools: () => mockTools }),
+        },
+      },
+    });
+
+    if (!toolsCommand.action) throw new Error('Action not defined');
+    await toolsCommand.action(mockContext, '');
+
+    const message = (mockContext.ui.addItem as vi.Mock).mock.calls[0][0].text;
+    expect(message).not.toContain('Reads files from the local system.');
+    expect(message).toContain('File Reader');
+    expect(message).toContain('Code Editor');
+  });
+
+  it('should list tools with descriptions when "desc" arg is passed', async () => {
+    const mockContext = createMockCommandContext({
+      services: {
+        config: {
+          getToolRegistry: () => ({ getAllTools: () => mockTools }),
+        },
+      },
+    });
+
+    if (!toolsCommand.action) throw new Error('Action not defined');
+    await toolsCommand.action(mockContext, 'desc');
+
+    const message = (mockContext.ui.addItem as vi.Mock).mock.calls[0][0].text;
+    expect(message).toContain('Reads files from the local system.');
+    expect(message).toContain('Edits code files.');
+  });
+});

package/dist/ui/commands/toolsCommand.ts

@@ -0,0 +1,71 @@
+/**
+ * @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 toolsCommand: SlashCommand = {
+  name: 'tools',
+  description: 'list available FSS Link tools',
+  kind: CommandKind.BUILT_IN,
+  action: async (context: CommandContext, args?: string): Promise<void> => {
+    const subCommand = args?.trim();
+
+    // Default to NOT showing descriptions. The user must opt in with an argument.
+    let useShowDescriptions = false;
+    if (subCommand === 'desc' || subCommand === 'descriptions') {
+      useShowDescriptions = true;
+    }
+
+    const toolRegistry = context.services.config?.getToolRegistry();
+    if (!toolRegistry) {
+      context.ui.addItem(
+        {
+          type: MessageType.ERROR,
+          text: 'Could not retrieve tool registry.',
+        },
+        Date.now(),
+      );
+      return;
+    }
+
+    const tools = toolRegistry.getAllTools();
+    // Filter out MCP tools by checking for the absence of a serverName property
+    const geminiTools = tools.filter((tool) => !('serverName' in tool));
+
+    let message = 'Available FSS Link tools:\n\n';
+
+    if (geminiTools.length > 0) {
+      geminiTools.forEach((tool) => {
+        if (useShowDescriptions && tool.description) {
+          message += `  - \u001b[36m${tool.displayName} (${tool.name})\u001b[0m:\n`;
+
+          const greenColor = '\u001b[32m';
+          const resetColor = '\u001b[0m';
+
+          // Handle multi-line descriptions
+          const descLines = tool.description.trim().split('\n');
+          for (const descLine of descLines) {
+            message += `      ${greenColor}${descLine}${resetColor}\n`;
+          }
+        } else {
+          message += `  - \u001b[36m${tool.displayName}\u001b[0m\n`;
+        }
+      });
+    } else {
+      message += '  No tools available\n';
+    }
+    message += '\n';
+
+    message += '\u001b[0m';
+
+    context.ui.addItem({ type: MessageType.INFO, text: message }, Date.now());
+  },
+};

package/dist/ui/commands/ttsCommand.ts

@@ -0,0 +1,143 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { CommandKind, SlashCommand } from './types.js';
+import { MessageType } from '../types.js';
+
+export const ttsCommand: SlashCommand = {
+  name: 'tts',
+  description: 'control text-to-speech settings',
+  kind: CommandKind.BUILT_IN,
+  subCommands: [
+    {
+      name: 'on',
+      description: 'enable text-to-speech',
+      kind: CommandKind.BUILT_IN,
+      action: async (context) => {
+        // Set TTS enabled using setter
+        if (!context.session.ttsEnabled) {
+          context.ui.setTtsEnabled(true);
+          context.ui.addItem(
+            {
+              type: MessageType.INFO,
+              text: '🎵 TTS enabled - Use /speak "message" to test',
+            },
+            Date.now()
+          );
+        } else {
+          context.ui.addItem(
+            {
+              type: MessageType.INFO,
+              text: '🎵 TTS is already enabled',
+            },
+            Date.now()
+          );
+        }
+      },
+    },
+    {
+      name: 'off',
+      description: 'disable text-to-speech',
+      kind: CommandKind.BUILT_IN,
+      action: async (context) => {
+        // Set TTS disabled using setter
+        if (context.session.ttsEnabled) {
+          context.ui.setTtsEnabled(false);
+          context.ui.addItem(
+            {
+              type: MessageType.INFO,
+              text: '🔇 TTS disabled',
+            },
+            Date.now()
+          );
+        } else {
+          context.ui.addItem(
+            {
+              type: MessageType.INFO,
+              text: '🔇 TTS is already disabled',
+            },
+            Date.now()
+          );
+        }
+      },
+    },
+    {
+      name: 'status',
+      description: 'show TTS status and configuration',
+      kind: CommandKind.BUILT_IN,
+      action: async (context) => {
+        const enabled = context.session.ttsEnabled || false;
+        const voice = context.session.ttsVoice || 'Bella';
+        
+        // Show checking server status with animation
+        context.ui.addItem(
+          {
+            type: MessageType.INFO,
+            text: '🔍 Checking TTS server status...',
+          },
+          Date.now()
+        );
+        
+        // Test server availability with timeout
+        let serverAvailable = false;
+        let serverInfo = '';
+        try {
+          const response = await fetch('http://192.168.1.5:11450/health', {
+            method: 'GET',
+          });
+          serverAvailable = response.ok;
+          if (response.ok) {
+            const data = await response.json();
+            serverInfo = `Version: ${data.version || 'unknown'}`;
+          }
+        } catch (error) {
+          serverInfo = `Connection failed: ${error instanceof Error ? error.message : 'Unknown error'}`;
+        }
+        
+        // Voice personality emojis
+        const voiceEmojis: Record<string, string> = {
+          'Bella': '👩‍💼', 'Emma': '👩‍🎨', 'George': '👨‍🔧',
+          'Lewis': '👨‍💻', 'Sarah': '👩‍🏫', 'Michael': '👨‍⚖️'
+        };
+        const voiceEmoji = voiceEmojis[voice] || '🗣️';
+        
+        // Rich status display
+        let status = `🎵 FSS-TTS Integration Status\n`;
+        status += `════════════════════════════════\n\n`;
+        status += `Session Settings:\n`;
+        status += `  🔊 TTS Mode: ${enabled ? '✅ Enabled' : '❌ Disabled'}\n`;
+        status += `  ${voiceEmoji} Voice: ${voice}\n`;
+        status += `  🎛️  Session-based (resets on restart)\n\n`;
+        status += `Server Status:\n`;
+        status += `  🌐 Endpoint: http://192.168.1.5:11450\n`;
+        status += `  📡 Connection: ${serverAvailable ? '✅ Connected' : '❌ Failed'}\n`;
+        if (serverInfo) {
+          status += `  ℹ️  Info: ${serverInfo}\n`;
+        }
+        status += `\n`;
+        status += `Available Commands:\n`;
+        status += `  /tts on              - Enable TTS for this session\n`;
+        status += `  /tts off             - Disable TTS for this session\n`;
+        status += `  /speak "message"     - Immediate TTS output\n`;
+        status += `  /voice VoiceName     - Select voice personality\n\n`;
+        status += `Available Voices:\n`;
+        Object.entries(voiceEmojis).forEach(([name, emoji]) => {
+          const marker = name === voice ? '👉' : '  ';
+          status += `${marker} ${emoji} ${name}\n`;
+        });
+        status += `\n💡 Tip: Use /speak "Build completed!" for progress updates`;
+
+        context.ui.addItem(
+          {
+            type: MessageType.INFO,
+            text: status,
+          },
+          Date.now()
+        );
+      },
+    },
+  ],
+};