fss-link 1.0.49 → 1.0.51

package/dist/services/FileCommandLoader.ts

@@ -1,289 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { promises as fs } from 'fs';
-import path from 'path';
-import toml from '@iarna/toml';
-import { glob } from 'glob';
-import { z } from 'zod';
-import {
-  Config,
-  getProjectCommandsDir,
-  getUserCommandsDir,
-} from 'fss-link-core';
-import { ICommandLoader } from './types.js';
-import {
-  CommandContext,
-  CommandKind,
-  SlashCommand,
-  SlashCommandActionReturn,
-} from '../ui/commands/types.js';
-import { DefaultArgumentProcessor } from './prompt-processors/argumentProcessor.js';
-import {
-  IPromptProcessor,
-  SHORTHAND_ARGS_PLACEHOLDER,
-  SHELL_INJECTION_TRIGGER,
-} from './prompt-processors/types.js';
-import {
-  ConfirmationRequiredError,
-  ShellProcessor,
-} from './prompt-processors/shellProcessor.js';
-
-interface CommandDirectory {
-  path: string;
-  extensionName?: string;
-}
-
-/**
- * Defines the Zod schema for a command definition file. This serves as the
- * single source of truth for both validation and type inference.
- */
-const TomlCommandDefSchema = z.object({
-  prompt: z.string({
-    required_error: "The 'prompt' field is required.",
-    invalid_type_error: "The 'prompt' field must be a string.",
-  }),
-  description: z.string().optional(),
-});
-
-/**
- * Discovers and loads custom slash commands from .toml files in both the
- * user's global config directory and the current project's directory.
- *
- * This loader is responsible for:
- * - Recursively scanning command directories.
- * - Parsing and validating TOML files.
- * - Adapting valid definitions into executable SlashCommand objects.
- * - Handling file system errors and malformed files gracefully.
- */
-export class FileCommandLoader implements ICommandLoader {
-  private readonly projectRoot: string;
-
-  constructor(private readonly config: Config | null) {
-    this.projectRoot = config?.getProjectRoot() || process.cwd();
-  }
-
-  /**
-   * Loads all commands from user, project, and extension directories.
-   * Returns commands in order: user → project → extensions (alphabetically).
-   *
-   * Order is important for conflict resolution in CommandService:
-   * - User/project commands (without extensionName) use "last wins" strategy
-   * - Extension commands (with extensionName) get renamed if conflicts exist
-   *
-   * @param signal An AbortSignal to cancel the loading process.
-   * @returns A promise that resolves to an array of all loaded SlashCommands.
-   */
-  async loadCommands(signal: AbortSignal): Promise<SlashCommand[]> {
-    const allCommands: SlashCommand[] = [];
-    const globOptions = {
-      nodir: true,
-      dot: true,
-      signal,
-      follow: true,
-    };
-
-    // Load commands from each directory
-    const commandDirs = this.getCommandDirectories();
-    for (const dirInfo of commandDirs) {
-      try {
-        const files = await glob('**/*.toml', {
-          ...globOptions,
-          cwd: dirInfo.path,
-        });
-
-        const commandPromises = files.map((file) =>
-          this.parseAndAdaptFile(
-            path.join(dirInfo.path, file),
-            dirInfo.path,
-            dirInfo.extensionName,
-          ),
-        );
-
-        const commands = (await Promise.all(commandPromises)).filter(
-          (cmd): cmd is SlashCommand => cmd !== null,
-        );
-
-        // Add all commands without deduplication
-        allCommands.push(...commands);
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
-          console.error(
-            `[FileCommandLoader] Error loading commands from ${dirInfo.path}:`,
-            error,
-          );
-        }
-      }
-    }
-
-    return allCommands;
-  }
-
-  /**
-   * Get all command directories in order for loading.
-   * User commands → Project commands → Extension commands
-   * This order ensures extension commands can detect all conflicts.
-   */
-  private getCommandDirectories(): CommandDirectory[] {
-    const dirs: CommandDirectory[] = [];
-
-    // 1. User commands
-    dirs.push({ path: getUserCommandsDir() });
-
-    // 2. Project commands (override user commands)
-    dirs.push({ path: getProjectCommandsDir(this.projectRoot) });
-
-    // 3. Extension commands (processed last to detect all conflicts)
-    if (this.config) {
-      const activeExtensions = this.config
-        .getExtensions()
-        .filter((ext) => ext.isActive)
-        .sort((a, b) => a.name.localeCompare(b.name)); // Sort alphabetically for deterministic loading
-
-      const extensionCommandDirs = activeExtensions.map((ext) => ({
-        path: path.join(ext.path, 'commands'),
-        extensionName: ext.name,
-      }));
-
-      dirs.push(...extensionCommandDirs);
-    }
-
-    return dirs;
-  }
-
-  /**
-   * Parses a single .toml file and transforms it into a SlashCommand object.
-   * @param filePath The absolute path to the .toml file.
-   * @param baseDir The root command directory for name calculation.
-   * @param extensionName Optional extension name to prefix commands with.
-   * @returns A promise resolving to a SlashCommand, or null if the file is invalid.
-   */
-  private async parseAndAdaptFile(
-    filePath: string,
-    baseDir: string,
-    extensionName?: string,
-  ): Promise<SlashCommand | null> {
-    let fileContent: string;
-    try {
-      fileContent = await fs.readFile(filePath, 'utf-8');
-    } catch (error: unknown) {
-      console.error(
-        `[FileCommandLoader] Failed to read file ${filePath}:`,
-        error instanceof Error ? error.message : String(error),
-      );
-      return null;
-    }
-
-    let parsed: unknown;
-    try {
-      parsed = toml.parse(fileContent);
-    } catch (error: unknown) {
-      console.error(
-        `[FileCommandLoader] Failed to parse TOML file ${filePath}:`,
-        error instanceof Error ? error.message : String(error),
-      );
-      return null;
-    }
-
-    const validationResult = TomlCommandDefSchema.safeParse(parsed);
-
-    if (!validationResult.success) {
-      console.error(
-        `[FileCommandLoader] Skipping invalid command file: ${filePath}. Validation errors:`,
-        validationResult.error.flatten(),
-      );
-      return null;
-    }
-
-    const validDef = validationResult.data;
-
-    const relativePathWithExt = path.relative(baseDir, filePath);
-    const relativePath = relativePathWithExt.substring(
-      0,
-      relativePathWithExt.length - 5, // length of '.toml'
-    );
-    const baseCommandName = relativePath
-      .split(path.sep)
-      // Sanitize each path segment to prevent ambiguity. Since ':' is our
-      // namespace separator, we replace any literal colons in filenames
-      // with underscores to avoid naming conflicts.
-      .map((segment) => segment.replaceAll(':', '_'))
-      .join(':');
-
-    // Add extension name tag for extension commands
-    const defaultDescription = `Custom command from ${path.basename(filePath)}`;
-    let description = validDef.description || defaultDescription;
-    if (extensionName) {
-      description = `[${extensionName}] ${description}`;
-    }
-
-    const processors: IPromptProcessor[] = [];
-    const usesArgs = validDef.prompt.includes(SHORTHAND_ARGS_PLACEHOLDER);
-    const usesShellInjection = validDef.prompt.includes(
-      SHELL_INJECTION_TRIGGER,
-    );
-
-    // Interpolation (Shell Execution and Argument Injection)
-    // If the prompt uses either shell injection OR argument placeholders,
-    // we must use the ShellProcessor.
-    if (usesShellInjection || usesArgs) {
-      processors.push(new ShellProcessor(baseCommandName));
-    }
-
-    // Default Argument Handling
-    // If NO explicit argument injection ({{args}}) was used, we append the raw invocation.
-    if (!usesArgs) {
-      processors.push(new DefaultArgumentProcessor());
-    }
-
-    return {
-      name: baseCommandName,
-      description,
-      kind: CommandKind.FILE,
-      extensionName,
-      action: async (
-        context: CommandContext,
-        _args: string,
-      ): Promise<SlashCommandActionReturn> => {
-        if (!context.invocation) {
-          console.error(
-            `[FileCommandLoader] Critical error: Command '${baseCommandName}' was executed without invocation context.`,
-          );
-          return {
-            type: 'submit_prompt',
-            content: validDef.prompt, // Fallback to unprocessed prompt
-          };
-        }
-
-        try {
-          let processedPrompt = validDef.prompt;
-          for (const processor of processors) {
-            processedPrompt = await processor.process(processedPrompt, context);
-          }
-
-          return {
-            type: 'submit_prompt',
-            content: processedPrompt,
-          };
-        } catch (e) {
-          // Check if it's our specific error type
-          if (e instanceof ConfirmationRequiredError) {
-            // Halt and request confirmation from the UI layer.
-            return {
-              type: 'confirm_shell_commands',
-              commandsToConfirm: e.commandsToConfirm,
-              originalInvocation: {
-                raw: context.invocation.raw,
-              },
-            };
-          }
-          // Re-throw other errors to be handled by the global error handler.
-          throw e;
-        }
-      },
-    };
-  }
-}

package/dist/services/McpPromptLoader.ts

@@ -1,231 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {
-  Config,
-  getErrorMessage,
-  getMCPServerPrompts,
-} from 'fss-link-core';
-import {
-  CommandContext,
-  CommandKind,
-  SlashCommand,
-  SlashCommandActionReturn,
-} from '../ui/commands/types.js';
-import { ICommandLoader } from './types.js';
-import { PromptArgument } from '@modelcontextprotocol/sdk/types.js';
-
-/**
- * Discovers and loads executable slash commands from prompts exposed by
- * Model-Context-Protocol (MCP) servers.
- */
-export class McpPromptLoader implements ICommandLoader {
-  constructor(private readonly config: Config | null) {}
-
-  /**
-   * Loads all available prompts from all configured MCP servers and adapts
-   * them into executable SlashCommand objects.
-   *
-   * @param _signal An AbortSignal (unused for this synchronous loader).
-   * @returns A promise that resolves to an array of loaded SlashCommands.
-   */
-  loadCommands(_signal: AbortSignal): Promise<SlashCommand[]> {
-    const promptCommands: SlashCommand[] = [];
-    if (!this.config) {
-      return Promise.resolve([]);
-    }
-    const mcpServers = this.config.getMcpServers() || {};
-    for (const serverName in mcpServers) {
-      const prompts = getMCPServerPrompts(this.config, serverName) || [];
-      for (const prompt of prompts) {
-        const commandName = `${prompt.name}`;
-        const newPromptCommand: SlashCommand = {
-          name: commandName,
-          description: prompt.description || `Invoke prompt ${prompt.name}`,
-          kind: CommandKind.MCP_PROMPT,
-          subCommands: [
-            {
-              name: 'help',
-              description: 'Show help for this prompt',
-              kind: CommandKind.MCP_PROMPT,
-              action: async (): Promise<SlashCommandActionReturn> => {
-                if (!prompt.arguments || prompt.arguments.length === 0) {
-                  return {
-                    type: 'message',
-                    messageType: 'info',
-                    content: `Prompt "${prompt.name}" has no arguments.`,
-                  };
-                }
-
-                let helpMessage = `Arguments for "${prompt.name}":\n\n`;
-                if (prompt.arguments && prompt.arguments.length > 0) {
-                  helpMessage += `You can provide arguments by name (e.g., --argName="value") or by position.\n\n`;
-                  helpMessage += `e.g., ${prompt.name} ${prompt.arguments?.map((_) => `"foo"`)} is equivalent to ${prompt.name} ${prompt.arguments?.map((arg) => `--${arg.name}="foo"`)}\n\n`;
-                }
-                for (const arg of prompt.arguments) {
-                  helpMessage += `  --${arg.name}\n`;
-                  if (arg.description) {
-                    helpMessage += `    ${arg.description}\n`;
-                  }
-                  helpMessage += `    (required: ${
-                    arg.required ? 'yes' : 'no'
-                  })\n\n`;
-                }
-                return {
-                  type: 'message',
-                  messageType: 'info',
-                  content: helpMessage,
-                };
-              },
-            },
-          ],
-          action: async (
-            context: CommandContext,
-            args: string,
-          ): Promise<SlashCommandActionReturn> => {
-            if (!this.config) {
-              return {
-                type: 'message',
-                messageType: 'error',
-                content: 'Config not loaded.',
-              };
-            }
-
-            const promptInputs = this.parseArgs(args, prompt.arguments);
-            if (promptInputs instanceof Error) {
-              return {
-                type: 'message',
-                messageType: 'error',
-                content: promptInputs.message,
-              };
-            }
-
-            try {
-              const mcpServers = this.config.getMcpServers() || {};
-              const mcpServerConfig = mcpServers[serverName];
-              if (!mcpServerConfig) {
-                return {
-                  type: 'message',
-                  messageType: 'error',
-                  content: `MCP server config not found for '${serverName}'.`,
-                };
-              }
-              const result = await prompt.invoke(promptInputs);
-
-              if (result['error']) {
-                return {
-                  type: 'message',
-                  messageType: 'error',
-                  content: `Error invoking prompt: ${result['error']}`,
-                };
-              }
-
-              if (!result.messages?.[0]?.content?.['text']) {
-                return {
-                  type: 'message',
-                  messageType: 'error',
-                  content:
-                    'Received an empty or invalid prompt response from the server.',
-                };
-              }
-
-              return {
-                type: 'submit_prompt',
-                content: JSON.stringify(result.messages[0].content.text),
-              };
-            } catch (error) {
-              return {
-                type: 'message',
-                messageType: 'error',
-                content: `Error: ${getErrorMessage(error)}`,
-              };
-            }
-          },
-          completion: async (_: CommandContext, partialArg: string) => {
-            if (!prompt || !prompt.arguments) {
-              return [];
-            }
-
-            const suggestions: string[] = [];
-            const usedArgNames = new Set(
-              (partialArg.match(/--([^=]+)/g) || []).map((s) => s.substring(2)),
-            );
-
-            for (const arg of prompt.arguments) {
-              if (!usedArgNames.has(arg.name)) {
-                suggestions.push(`--${arg.name}=""`);
-              }
-            }
-
-            return suggestions;
-          },
-        };
-        promptCommands.push(newPromptCommand);
-      }
-    }
-    return Promise.resolve(promptCommands);
-  }
-
-  private parseArgs(
-    userArgs: string,
-    promptArgs: PromptArgument[] | undefined,
-  ): Record<string, unknown> | Error {
-    const argValues: { [key: string]: string } = {};
-    const promptInputs: Record<string, unknown> = {};
-
-    // arg parsing: --key="value" or --key=value
-    const namedArgRegex = /--([^=]+)=(?:"((?:\\.|[^"\\])*)"|([^ ]*))/g;
-    let match;
-    const remainingArgs: string[] = [];
-    let lastIndex = 0;
-
-    while ((match = namedArgRegex.exec(userArgs)) !== null) {
-      const key = match[1];
-      const value = match[2] ?? match[3]; // Quoted or unquoted value
-      argValues[key] = value;
-      // Capture text between matches as potential positional args
-      if (match.index > lastIndex) {
-        remainingArgs.push(userArgs.substring(lastIndex, match.index).trim());
-      }
-      lastIndex = namedArgRegex.lastIndex;
-    }
-
-    // Capture any remaining text after the last named arg
-    if (lastIndex < userArgs.length) {
-      remainingArgs.push(userArgs.substring(lastIndex).trim());
-    }
-
-    const positionalArgs = remainingArgs.join(' ').split(/ +/);
-
-    if (!promptArgs) {
-      return promptInputs;
-    }
-    for (const arg of promptArgs) {
-      if (argValues[arg.name]) {
-        promptInputs[arg.name] = argValues[arg.name];
-      }
-    }
-
-    const unfilledArgs = promptArgs.filter(
-      (arg) => arg.required && !promptInputs[arg.name],
-    );
-
-    const missingArgs: string[] = [];
-    for (let i = 0; i < unfilledArgs.length; i++) {
-      if (positionalArgs.length > i && positionalArgs[i]) {
-        promptInputs[unfilledArgs[i].name] = positionalArgs[i];
-      } else {
-        missingArgs.push(unfilledArgs[i].name);
-      }
-    }
-
-    if (missingArgs.length > 0) {
-      const missingArgNames = missingArgs.map((name) => `--${name}`).join(', ');
-      return new Error(`Missing required argument(s): ${missingArgNames}`);
-    }
-    return promptInputs;
-  }
-}

package/dist/services/SearchEngineConfigProvider.ts

@@ -1,100 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { getFSSLinkDatabase } from '../config/database.js';
-
-export interface SearchEngineConfig {
-  braveApiKey?: string;
-  tavilyApiKey?: string;
-}
-
-/**
- * Configuration provider for search engine API keys
- * Loads from database and sets environment variables
- */
-export class SearchEngineConfigProvider {
-  private static instance: SearchEngineConfigProvider | null = null;
-  
-  static getInstance(): SearchEngineConfigProvider {
-    if (!SearchEngineConfigProvider.instance) {
-      SearchEngineConfigProvider.instance = new SearchEngineConfigProvider();
-    }
-    return SearchEngineConfigProvider.instance;
-  }
-
-  /**
-   * Load search engine configuration from database and set environment variables
-   */
-  async loadConfiguration(): Promise<SearchEngineConfig> {
-    const db = await getFSSLinkDatabase();
-    
-    const braveApiKey = await db.getUserPreference('webscraper.brave_api_key');
-    const tavilyApiKey = await db.getUserPreference('webscraper.tavily_api_key');
-    
-    // Set environment variables for immediate use
-    if (braveApiKey) {
-      process.env['BRAVE_SEARCH_API_KEY'] = braveApiKey;
-    }
-    if (tavilyApiKey) {
-      process.env['TAVILY_API_KEY'] = tavilyApiKey;
-    }
-    
-    return {
-      braveApiKey: braveApiKey || undefined,
-      tavilyApiKey: tavilyApiKey || undefined,
-    };
-  }
-  
-  /**
-   * Save search engine configuration to database
-   */
-  async saveConfiguration(config: SearchEngineConfig): Promise<void> {
-    const db = await getFSSLinkDatabase();
-    
-    if (config.braveApiKey) {
-      await db.setUserPreference('webscraper.brave_api_key', config.braveApiKey);
-      await db.setUserPreference('webscraper.brave_enabled', 'true');
-      process.env['BRAVE_SEARCH_API_KEY'] = config.braveApiKey;
-    }
-    
-    if (config.tavilyApiKey) {
-      await db.setUserPreference('webscraper.tavily_api_key', config.tavilyApiKey);
-      await db.setUserPreference('webscraper.tavily_enabled', 'true');
-      process.env['TAVILY_API_KEY'] = config.tavilyApiKey;
-    }
-  }
-  
-  /**
-   * Check if search engines are configured
-   */
-  async hasConfiguration(): Promise<boolean> {
-    const config = await this.loadConfiguration();
-    return !!(config.braveApiKey || config.tavilyApiKey);
-  }
-  
-  /**
-   * Get configuration status for display
-   */
-  async getConfigurationStatus(): Promise<string> {
-    const config = await this.loadConfiguration();
-    
-    let status = '🔍 Search Engine Configuration:\n';
-    
-    if (config.braveApiKey) {
-      status += `✅ Brave Search: Configured\n`;
-    } else {
-      status += `❌ Brave Search: Not configured\n`;
-    }
-    
-    if (config.tavilyApiKey) {
-      status += `✅ Tavily Search: Configured\n`;
-    } else {
-      status += `❌ Tavily Search: Not configured\n`;
-    }
-    
-    return status;
-  }
-}

package/dist/services/prompt-processors/argumentProcessor.test.ts

@@ -1,41 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { DefaultArgumentProcessor } from './argumentProcessor.js';
-import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
-import { describe, it, expect } from 'vitest';
-
-describe('Argument Processors', () => {
-  describe('DefaultArgumentProcessor', () => {
-    const processor = new DefaultArgumentProcessor();
-
-    it('should append the full command if args are provided', async () => {
-      const prompt = 'Parse the command.';
-      const context = createMockCommandContext({
-        invocation: {
-          raw: '/mycommand arg1 "arg two"',
-          name: 'mycommand',
-          args: 'arg1 "arg two"',
-        },
-      });
-      const result = await processor.process(prompt, context);
-      expect(result).toBe('Parse the command.\n\n/mycommand arg1 "arg two"');
-    });
-
-    it('should NOT append the full command if no args are provided', async () => {
-      const prompt = 'Parse the command.';
-      const context = createMockCommandContext({
-        invocation: {
-          raw: '/mycommand',
-          name: 'mycommand',
-          args: '',
-        },
-      });
-      const result = await processor.process(prompt, context);
-      expect(result).toBe('Parse the command.');
-    });
-  });
-});

package/dist/services/prompt-processors/argumentProcessor.ts

@@ -1,23 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { IPromptProcessor } from './types.js';
-import { CommandContext } from '../../ui/commands/types.js';
-
-/**
- * Appends the user's full command invocation to the prompt if arguments are
- * provided, allowing the model to perform its own argument parsing.
- *
- * This processor is only used if the prompt does NOT contain {{args}}.
- */
-export class DefaultArgumentProcessor implements IPromptProcessor {
-  async process(prompt: string, context: CommandContext): Promise<string> {
-    if (context.invocation!.args) {
-      return `${prompt}\n\n${context.invocation!.raw}`;
-    }
-    return prompt;
-  }
-}