@juspay/neurolink 1.10.0 → 1.11.1

package/dist/mcp/auto-discovery.js

@@ -1,794 +1,149 @@
 /**
- * NeuroLink MCP Auto-Discovery System
- * Automatically discovers MCP servers from common configuration locations across different tools
- * Supports VS Code, Cursor, Claude Desktop, Windsurf, Roo Code, and generic configurations
+ * Auto-Discovery Module for MCP Plugins
+ * Handles automatic plugin discovery and registration
  */
 import * as fs from "fs/promises";
 import * as path from "path";
-import * as os from "os";
-import { MCPToolRegistry } from "./registry.js";
 import { autoDiscoveryLogger } from "./logging.js";
 /**
- * Claude Desktop configuration parser
+ * Default auto-discovery configuration
  */
-class ClaudeDesktopParser {
-    canParse(filePath, content) {
-        return (filePath.includes("claude_desktop_config.json") &&
-            content &&
-            typeof content === "object" &&
-            (content.mcpServers || content.mcp_servers));
-    }
-    parse(filePath, content, source) {
-        const servers = [];
-        const mcpServers = content.mcpServers || content.mcp_servers || {};
-        for (const [serverId, serverConfig] of Object.entries(mcpServers)) {
-            if (typeof serverConfig === "object" && serverConfig !== null) {
-                const config = serverConfig;
-                servers.push({
-                    id: serverId,
-                    title: config.title || serverId,
-                    command: config.command || "node",
-                    args: config.args || [],
-                    env: config.env || {},
-                    cwd: config.cwd,
-                    source,
-                    configPath: filePath,
-                    rawConfig: config,
-                });
-            }
-        }
-        return servers;
-    }
-}
-/**
- * VS Code configuration parser
- */
-class VSCodeParser {
-    canParse(filePath, content) {
-        return ((filePath.includes(".vscode/mcp.json") ||
-            filePath.includes("settings.json")) &&
-            content &&
-            typeof content === "object");
-    }
-    parse(filePath, content, source) {
-        const servers = [];
-        // Handle .vscode/mcp.json format
-        if (filePath.includes("mcp.json")) {
-            const mcpServers = content.mcpServers || content.servers || {};
-            for (const [serverId, serverConfig] of Object.entries(mcpServers)) {
-                if (typeof serverConfig === "object" && serverConfig !== null) {
-                    const config = serverConfig;
-                    servers.push({
-                        id: serverId,
-                        title: config.title || serverId,
-                        command: config.command || "node",
-                        args: config.args || [],
-                        env: config.env || {},
-                        cwd: config.cwd,
-                        source,
-                        configPath: filePath,
-                        rawConfig: config,
-                    });
-                }
-            }
-        }
-        // Handle settings.json with MCP configuration
-        if (filePath.includes("settings.json") && content.mcp) {
-            const mcpConfig = content.mcp;
-            if (mcpConfig.servers) {
-                for (const [serverId, serverConfig] of Object.entries(mcpConfig.servers)) {
-                    if (typeof serverConfig === "object" && serverConfig !== null) {
-                        const config = serverConfig;
-                        servers.push({
-                            id: serverId,
-                            title: config.title || serverId,
-                            command: config.command || "node",
-                            args: config.args || [],
-                            env: config.env || {},
-                            cwd: config.cwd,
-                            source,
-                            configPath: filePath,
-                            rawConfig: config,
-                        });
-                    }
-                }
-            }
-        }
-        return servers;
-    }
-}
-/**
- * Cursor configuration parser
- */
-class CursorParser {
-    canParse(filePath, content) {
-        return (filePath.includes(".cursor/mcp.json") ||
-            (filePath.includes("mcp.json") && content && typeof content === "object"));
-    }
-    parse(filePath, content, source) {
-        const servers = [];
-        const mcpServers = content.mcpServers || content.servers || {};
-        for (const [serverId, serverConfig] of Object.entries(mcpServers)) {
-            if (typeof serverConfig === "object" && serverConfig !== null) {
-                const config = serverConfig;
-                servers.push({
-                    id: serverId,
-                    title: config.title || serverId,
-                    command: config.command || "node",
-                    args: config.args || [],
-                    env: config.env || {},
-                    cwd: config.cwd,
-                    source,
-                    configPath: filePath,
-                    rawConfig: config,
-                });
-            }
-        }
-        return servers;
-    }
-}
-/**
- * Windsurf configuration parser
- */
-class WindsurfParser {
-    canParse(filePath, content) {
-        return (filePath.includes("windsurf/mcp_config.json") &&
-            content &&
-            typeof content === "object");
-    }
-    parse(filePath, content, source) {
-        const servers = [];
-        const mcpServers = content.mcpServers || content.servers || {};
-        for (const [serverId, serverConfig] of Object.entries(mcpServers)) {
-            if (typeof serverConfig === "object" && serverConfig !== null) {
-                const config = serverConfig;
-                servers.push({
-                    id: serverId,
-                    title: config.title || serverId,
-                    command: config.command || "node",
-                    args: config.args || [],
-                    env: config.env || {},
-                    cwd: config.cwd,
-                    source,
-                    configPath: filePath,
-                    rawConfig: config,
-                });
-            }
-        }
-        return servers;
-    }
-}
-/**
- * Cline AI Coder configuration parser
- */
-class ClineParser {
-    canParse(filePath, content) {
-        return (filePath.includes("cline_mcp_settings.json") &&
-            content &&
-            typeof content === "object" &&
-            (content.mcpServers || content.servers));
-    }
-    parse(filePath, content, source) {
-        const servers = [];
-        const mcpServers = content.mcpServers || content.servers || {};
-        for (const [serverId, serverConfig] of Object.entries(mcpServers)) {
-            if (typeof serverConfig === "object" && serverConfig !== null) {
-                const config = serverConfig;
-                servers.push({
-                    id: serverId,
-                    title: config.title || serverId,
-                    command: config.command || "node",
-                    args: config.args || [],
-                    env: config.env || {},
-                    cwd: config.cwd,
-                    source,
-                    configPath: filePath,
-                    rawConfig: config,
-                });
-            }
-        }
-        return servers;
-    }
-}
-/**
- * Continue Dev configuration parser
- */
-class ContinueParser {
-    canParse(filePath, content) {
-        return ((filePath.includes("continue/config.json") ||
-            filePath.includes(".continue/config.json")) &&
-            content &&
-            typeof content === "object" &&
-            (content.mcpServers || content.contextProviders?.mcp));
-    }
-    parse(filePath, content, source) {
-        const servers = [];
-        // Continue may have MCP servers in contextProviders.mcp or directly in mcpServers
-        const mcpServers = content.mcpServers || content.contextProviders?.mcp || {};
-        for (const [serverId, serverConfig] of Object.entries(mcpServers)) {
-            if (typeof serverConfig === "object" && serverConfig !== null) {
-                const config = serverConfig;
-                servers.push({
-                    id: serverId,
-                    title: config.title || serverId,
-                    command: config.command || "node",
-                    args: config.args || [],
-                    env: config.env || {},
-                    cwd: config.cwd,
-                    source,
-                    configPath: filePath,
-                    rawConfig: config,
-                });
-            }
-        }
-        return servers;
-    }
-}
-/**
- * Aider configuration parser
- */
-class AiderParser {
-    canParse(filePath, content) {
-        return ((filePath.includes(".aider") || filePath.includes("aider.conf")) &&
-            content &&
-            typeof content === "object" &&
-            content.mcp_servers);
-    }
-    parse(filePath, content, source) {
-        const servers = [];
-        const mcpServers = content.mcp_servers || {};
-        for (const [serverId, serverConfig] of Object.entries(mcpServers)) {
-            if (typeof serverConfig === "object" && serverConfig !== null) {
-                const config = serverConfig;
-                servers.push({
-                    id: serverId,
-                    title: config.title || serverId,
-                    command: config.command || "node",
-                    args: config.args || [],
-                    env: config.env || {},
-                    cwd: config.cwd,
-                    source,
-                    configPath: filePath,
-                    rawConfig: config,
-                });
-            }
-        }
-        return servers;
-    }
-}
+const DEFAULT_CONFIG = {
+    searchPaths: ["./src/lib/mcp/plugins", "./neurolink-mcp", "./node_modules"],
+    manifestName: "neurolink-mcp.json",
+    maxDepth: 3,
+};
 /**
- * Generic MCP configuration parser
+ * Auto-discovery service for MCP plugins
  */
-class GenericParser {
-    canParse(filePath, content) {
-        return ((filePath.includes("mcp.json") ||
-            filePath.includes("mcp-config.json") ||
-            filePath.includes("mcp_config.json")) &&
-            content &&
-            typeof content === "object");
+export class AutoDiscovery {
+    config;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
     }
-    parse(filePath, content, source) {
-        const servers = [];
-        const mcpServers = content.mcpServers || content.servers || content;
-        for (const [serverId, serverConfig] of Object.entries(mcpServers)) {
-            if (typeof serverConfig === "object" && serverConfig !== null) {
-                const config = serverConfig;
-                servers.push({
-                    id: serverId,
-                    title: config.title || serverId,
-                    command: config.command || "node",
-                    args: config.args || [],
-                    env: config.env || {},
-                    cwd: config.cwd,
-                    source,
-                    configPath: filePath,
-                    rawConfig: config,
-                });
-            }
-        }
-        return servers;
-    }
-}
-/**
- * MCP Auto-Discovery Engine
- */
-export class MCPAutoDiscovery {
-    parsers = [
-        new ClaudeDesktopParser(),
-        new ClineParser(), // Move Cline parser before VSCode parser
-        new VSCodeParser(),
-        new CursorParser(),
-        new WindsurfParser(),
-        new ContinueParser(),
-        new AiderParser(),
-        new GenericParser(),
-    ];
     /**
-     * Discover MCP servers from all common locations
-     *
-     * @param options Discovery configuration options
-     * @returns Discovery result with found servers
+     * Discover all available MCP plugins
      */
-    async discoverServers(options = {}) {
-        const startTime = Date.now();
+    async discover() {
         const discovered = [];
-        const sources = [];
-        const errors = [];
-        let configFilesFound = 0;
-        const { searchWorkspace = true, searchGlobal = true, searchCommonPaths = true, followSymlinks = false, maxDepth = 3, includeInactive = true, preferredTools = [], } = options;
-        // Define search paths based on options
-        const searchPaths = this.getSearchPaths({
-            searchWorkspace,
-            searchGlobal,
-            searchCommonPaths,
-        });
-        autoDiscoveryLogger.debug(`Starting discovery with ${searchPaths.length} search paths`);
-        // Search each path
-        for (const searchPath of searchPaths) {
-            try {
-                const pathResults = await this.searchPath(searchPath, maxDepth, followSymlinks, includeInactive);
-                discovered.push(...pathResults.servers);
-                sources.push(...pathResults.sources);
-                configFilesFound += pathResults.configFilesFound;
-                if (pathResults.errors.length > 0) {
-                    errors.push(...pathResults.errors);
-                }
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                errors.push(`Error searching path ${searchPath.path}: ${errorMessage}`);
-            }
-        }
-        // Remove duplicates and apply prioritization
-        const uniqueServers = this.deduplicateServers(discovered, preferredTools);
-        const duplicatesRemoved = discovered.length - uniqueServers.length;
-        const executionTime = Date.now() - startTime;
-        autoDiscoveryLogger.debug(`Discovery completed in ${executionTime}ms: ` +
-            `${uniqueServers.length} servers found, ${duplicatesRemoved} duplicates removed`);
-        return {
-            discovered: uniqueServers,
-            sources: [...new Set(sources)], // Remove duplicate sources
-            errors,
-            stats: {
-                configFilesFound,
-                serversDiscovered: uniqueServers.length,
-                duplicatesRemoved,
-                executionTime,
-            },
-        };
-    }
-    /**
-     * Auto-register discovered servers with a registry
-     *
-     * @param registry Target MCP registry
-     * @param options Discovery options
-     * @returns Registration results
-     */
-    async autoRegisterServers(registry, options = {}) {
-        const discoveryResult = await this.discoverServers(options);
-        const registered = [];
-        const failed = [];
-        const errors = [...discoveryResult.errors];
-        for (const server of discoveryResult.discovered) {
+        for (const searchPath of this.config.searchPaths) {
             try {
-                // Convert discovered server to NeuroLink MCP server format
-                const mcpServer = await this.convertToMCPServer(server);
-                // Attempt to register
-                await registry.registerServer(mcpServer);
-                registered.push(server.id);
-                autoDiscoveryLogger.info(`Successfully registered server '${server.id}' from ${server.source.tool}`);
+                const plugins = await this.discoverInPath(searchPath);
+                discovered.push(...plugins);
             }
             catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                failed.push(server.id);
-                errors.push(`Failed to register server '${server.id}': ${errorMessage}`);
-                autoDiscoveryLogger.error(`Failed to register server '${server.id}': ${errorMessage}`);
+                autoDiscoveryLogger.debug(`Failed to discover in ${searchPath}:`, error);
             }
         }
-        return { registered, failed, errors };
+        autoDiscoveryLogger.info(`Auto-discovery completed: ${discovered.length} plugins found`);
+        return discovered;
     }
     /**
-     * Get standard search paths for MCP configurations
+     * Discover plugins in a specific path
      */
-    getSearchPaths(options) {
-        const paths = [];
-        const homeDir = os.homedir();
-        const currentDir = process.cwd();
-        // Global configurations
-        if (options.searchGlobal) {
-            // Claude Desktop
-            paths.push({
-                path: path.join(homeDir, "Library", "Application Support", "Claude"),
-                source: {
-                    tool: "Claude Desktop",
-                    type: "global",
-                    priority: 9,
-                    description: "Claude Desktop global configuration",
-                },
-                patterns: ["claude_desktop_config.json"],
-            });
-            // Cursor global
-            paths.push({
-                path: path.join(homeDir, ".cursor"),
-                source: {
-                    tool: "Cursor",
-                    type: "global",
-                    priority: 8,
-                    description: "Cursor global configuration",
-                },
-                patterns: ["mcp.json"],
-            });
-            // Windsurf global
-            paths.push({
-                path: path.join(homeDir, ".codeium", "windsurf"),
-                source: {
-                    tool: "Windsurf",
-                    type: "global",
-                    priority: 8,
-                    description: "Windsurf global configuration",
-                },
-                patterns: ["mcp_config.json"],
-            });
-            // VS Code global
-            const vscodeGlobalPaths = [
-                path.join(homeDir, "Library", "Application Support", "Code", "User"), // macOS
-                path.join(homeDir, ".config", "Code", "User"), // Linux
-                path.join(homeDir, "AppData", "Roaming", "Code", "User"), // Windows
-            ];
-            for (const vscodeGlobalPath of vscodeGlobalPaths) {
-                paths.push({
-                    path: vscodeGlobalPath,
-                    source: {
-                        tool: "VS Code",
-                        type: "global",
-                        priority: 7,
-                        description: "VS Code global configuration",
-                    },
-                    patterns: ["settings.json"],
-                });
-            }
-            // Cline AI Coder - stored in VS Code extension globalStorage
-            const clineGlobalPaths = [
-                path.join(homeDir, "Library", "Application Support", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings"), // macOS
-                path.join(homeDir, ".config", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings"), // Linux
-                path.join(homeDir, "AppData", "Roaming", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings"), // Windows
-                // VS Code Insiders
-                path.join(homeDir, "Library", "Application Support", "Code - Insiders", "User", "globalStorage", "saoudrizwan.claude-dev", "settings"), // macOS
-                path.join(homeDir, ".config", "Code - Insiders", "User", "globalStorage", "saoudrizwan.claude-dev", "settings"), // Linux
-                path.join(homeDir, "AppData", "Roaming", "Code - Insiders", "User", "globalStorage", "saoudrizwan.claude-dev", "settings"), // Windows
-            ];
-            for (const clineGlobalPath of clineGlobalPaths) {
-                paths.push({
-                    path: clineGlobalPath,
-                    source: {
-                        tool: "Cline AI Coder",
-                        type: "global",
-                        priority: 8,
-                        description: "Cline AI Coder extension configuration",
-                    },
-                    patterns: ["cline_mcp_settings.json"],
-                });
-            }
-            // Continue Dev global configuration
-            paths.push({
-                path: path.join(homeDir, ".continue"),
-                source: {
-                    tool: "Continue Dev",
-                    type: "global",
-                    priority: 7,
-                    description: "Continue Dev global configuration",
-                },
-                patterns: ["config.json"],
-            });
-            // Aider global configuration
-            paths.push({
-                path: path.join(homeDir, ".aider"),
-                source: {
-                    tool: "Aider",
-                    type: "global",
-                    priority: 7,
-                    description: "Aider global configuration",
-                },
-                patterns: ["config.json", "aider.conf"],
-            });
-        }
-        // Workspace/project configurations
-        if (options.searchWorkspace) {
-            // VS Code workspace
-            paths.push({
-                path: path.join(currentDir, ".vscode"),
-                source: {
-                    tool: "VS Code",
-                    type: "workspace",
-                    priority: 9,
-                    description: "VS Code workspace configuration",
-                },
-                patterns: ["mcp.json", "settings.json"],
-            });
-            // Cursor project
-            paths.push({
-                path: path.join(currentDir, ".cursor"),
-                source: {
-                    tool: "Cursor",
-                    type: "project",
-                    priority: 9,
-                    description: "Cursor project configuration",
-                },
-                patterns: ["mcp.json"],
-            });
+    async discoverInPath(basePath, depth = 0) {
+        if (depth > this.config.maxDepth) {
+            return [];
         }
-        // Common file locations
-        if (options.searchCommonPaths) {
-            paths.push({
-                path: currentDir,
-                source: {
-                    tool: "Generic",
-                    type: "project",
-                    priority: 6,
-                    description: "Generic project configuration",
-                },
-                patterns: [
-                    "mcp.json",
-                    ".mcp-config.json",
-                    "mcp_config.json",
-                    ".mcp-servers.json",
-                ],
-            });
-        }
-        return paths;
-    }
-    /**
-     * Search a specific path for MCP configurations
-     */
-    async searchPath(searchConfig, maxDepth, followSymlinks, includeInactive) {
-        const servers = [];
-        const sources = [];
-        const errors = [];
-        let configFilesFound = 0;
+        const discovered = [];
         try {
-            // Check if path exists
-            await fs.access(searchConfig.path);
-            autoDiscoveryLogger.debug(`Searching path: ${searchConfig.path}`);
-        }
-        catch {
-            // Path doesn't exist, skip silently
-            autoDiscoveryLogger.debug(`Path does not exist: ${searchConfig.path}`);
-            return { servers, sources, configFilesFound, errors };
-        }
-        // Search for each pattern
-        for (const pattern of searchConfig.patterns) {
-            const filePath = path.join(searchConfig.path, pattern);
-            try {
-                await fs.access(filePath);
-                autoDiscoveryLogger.debug(`Found config file: ${filePath}`);
-                // Read and parse the file with resilient JSON parsing
-                const content = await fs.readFile(filePath, "utf-8");
-                const parsedContent = this.parseJsonResilient(content, filePath);
-                configFilesFound++;
-                // Try to parse with available parsers
-                let parsed = false;
-                for (const parser of this.parsers) {
-                    if (parser.canParse(filePath, parsedContent)) {
-                        autoDiscoveryLogger.debug(`Using parser for ${searchConfig.source.tool}: ${parser.constructor.name}`);
-                        const parsedServers = parser.parse(filePath, parsedContent, searchConfig.source);
-                        autoDiscoveryLogger.debug(`Parsed ${parsedServers.length} servers from ${filePath}`);
-                        servers.push(...parsedServers);
-                        sources.push(searchConfig.source);
-                        parsed = true;
-                        break;
+            const items = await fs.readdir(basePath);
+            for (const item of items) {
+                const itemPath = path.join(basePath, item);
+                const stats = await fs.stat(itemPath);
+                if (stats.isDirectory()) {
+                    // Check for manifest in this directory
+                    const manifestPath = path.join(itemPath, this.config.manifestName);
+                    try {
+                        await fs.access(manifestPath);
+                        const plugin = await this.loadPlugin(manifestPath, itemPath);
+                        if (plugin) {
+                            discovered.push(plugin);
+                        }
+                    }
+                    catch {
+                        // No manifest, continue searching subdirectories
+                        const subPlugins = await this.discoverInPath(itemPath, depth + 1);
+                        discovered.push(...subPlugins);
                     }
-                }
-                if (!parsed) {
-                    autoDiscoveryLogger.debug(`No parser could handle ${filePath}`);
-                }
-            }
-            catch (error) {
-                if (error.code !== "ENOENT") {
-                    // File exists but couldn't be parsed
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    errors.push(`Error parsing ${filePath}: ${errorMessage}`);
-                    autoDiscoveryLogger.debug(`Error parsing ${filePath}: ${errorMessage}`);
                 }
             }
         }
-        return { servers, sources, configFilesFound, errors };
+        catch (error) {
+            autoDiscoveryLogger.debug(`Failed to scan ${basePath}:`, error);
+        }
+        return discovered;
     }
     /**
-     * Parse JSON with resilience to common syntax issues
+     * Load plugin from manifest
      */
-    parseJsonResilient(content, filePath) {
+    async loadPlugin(manifestPath, pluginPath) {
         try {
-            // First, try standard JSON parsing
-            return JSON.parse(content);
+            const manifestContent = await fs.readFile(manifestPath, "utf-8");
+            const metadata = JSON.parse(manifestContent);
+            // Validate basic metadata
+            if (!metadata.name || !metadata.version || !metadata.main) {
+                autoDiscoveryLogger.warn(`Invalid manifest at ${manifestPath}`);
+                return null;
+            }
+            const entryPath = path.resolve(pluginPath, metadata.main);
+            return {
+                metadata,
+                entryPath,
+                source: this.determineSource(pluginPath),
+                constructor: undefined,
+            };
         }
         catch (error) {
-            const originalError = error instanceof Error ? error.message : String(error);
-            try {
-                // Attempt to fix common JSON issues
-                let fixedContent = content;
-                // Remove trailing commas before closing braces and brackets
-                fixedContent = fixedContent.replace(/,(\s*[}\]])/g, "$1");
-                // Remove single-line comments (// comments)
-                fixedContent = fixedContent.replace(/\/\/.*$/gm, "");
-                // Remove multi-line comments (/* comments */)
-                fixedContent = fixedContent.replace(/\/\*[\s\S]*?\*\//g, "");
-                // Remove trailing commas after the last property in objects
-                fixedContent = fixedContent.replace(/,(\s*})/g, "$1");
-                // Remove trailing commas after the last element in arrays
-                fixedContent = fixedContent.replace(/,(\s*])/g, "$1");
-                // Fix unescaped control characters in strings
-                fixedContent = fixedContent.replace(/("(?:[^"\\]|\\.)+")/g, (match) => {
-                    try {
-                        // Try to parse the string to see if it's valid
-                        JSON.parse(`{${match}}`);
-                        return match;
-                    }
-                    catch {
-                        // If invalid, escape common control characters
-                        return match
-                            .replace(/\n/g, "\\n")
-                            .replace(/\r/g, "\\r")
-                            .replace(/\t/g, "\\t")
-                            .replace(/\f/g, "\\f")
-                            .replace(/\b/g, "\\b");
-                    }
-                });
-                // Fix unquoted object keys
-                fixedContent = fixedContent.replace(/([{,]\s*)([a-zA-Z_$][a-zA-Z0-9_$]*)\s*:/g, '$1"$2":');
-                // Try parsing the fixed content
-                const result = JSON.parse(fixedContent);
-                autoDiscoveryLogger.debug(`Successfully repaired JSON syntax issues in ${filePath}`);
-                return result;
-            }
-            catch (secondError) {
-                // If we still can't parse it, try one more time with aggressive fixes
-                try {
-                    let aggressiveFixedContent = content;
-                    // Remove any non-printable characters except standard whitespace
-                    aggressiveFixedContent = aggressiveFixedContent.replace(
-                    // eslint-disable-next-line no-control-regex
-                    /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "");
-                    // Apply all previous fixes
-                    aggressiveFixedContent = aggressiveFixedContent.replace(/,(\s*[}\]])/g, "$1");
-                    aggressiveFixedContent = aggressiveFixedContent.replace(/\/\/.*$/gm, "");
-                    aggressiveFixedContent = aggressiveFixedContent.replace(/\/\*[\s\S]*?\*\//g, "");
-                    aggressiveFixedContent = aggressiveFixedContent.replace(/,(\s*})/g, "$1");
-                    aggressiveFixedContent = aggressiveFixedContent.replace(/,(\s*])/g, "$1");
-                    const result = JSON.parse(aggressiveFixedContent);
-                    autoDiscoveryLogger.debug(`Successfully repaired JSON with aggressive fixes in ${filePath}`);
-                    return result;
-                }
-                catch (thirdError) {
-                    // If all attempts fail, throw a comprehensive error but don't crash the discovery
-                    const secondErrorMessage = secondError instanceof Error
-                        ? secondError.message
-                        : String(secondError);
-                    const thirdErrorMessage = thirdError instanceof Error
-                        ? thirdError.message
-                        : String(thirdError);
-                    autoDiscoveryLogger.warn(`Unable to repair JSON in ${filePath}. ` +
-                        `Original: ${originalError}. After basic repair: ${secondErrorMessage}. ` +
-                        `After aggressive repair: ${thirdErrorMessage}`);
-                    // Return empty object so discovery can continue
-                    return {};
-                }
-            }
+            autoDiscoveryLogger.error(`Failed to load plugin manifest at ${manifestPath}:`, error);
+            return null;
         }
     }
     /**
-     * Remove duplicate servers and apply prioritization
+     * Determine plugin source based on path
      */
-    deduplicateServers(servers, preferredTools) {
-        const serverMap = new Map();
-        // Sort by priority (higher priority first)
-        const sortedServers = servers.sort((a, b) => {
-            // Preferred tools get highest priority
-            const aPreferred = preferredTools.includes(a.source.tool);
-            const bPreferred = preferredTools.includes(b.source.tool);
-            if (aPreferred && !bPreferred) {
-                return -1;
-            }
-            if (!aPreferred && bPreferred) {
-                return 1;
-            }
-            // Then by source priority
-            return b.source.priority - a.source.priority;
-        });
-        // Keep the highest priority version of each server
-        for (const server of sortedServers) {
-            const key = server.id;
-            if (!serverMap.has(key)) {
-                serverMap.set(key, server);
-            }
+    determineSource(pluginPath) {
+        if (pluginPath.includes("node_modules")) {
+            return "installed";
         }
-        return Array.from(serverMap.values());
-    }
-    /**
-     * Map tool names to valid MCP server categories
-     */
-    mapToolToCategory(toolName) {
-        const normalizedTool = toolName.toLowerCase().replace(/\s+/g, "-");
-        // Map known tools to appropriate categories
-        const categoryMap = {
-            "claude-desktop": "ai-providers",
-            "vs-code": "development",
-            cursor: "development",
-            windsurf: "development",
-            "roo-code": "development",
-            generic: "integrations",
-        };
-        return categoryMap[normalizedTool] || "custom";
-    }
-    /**
-     * Convert discovered server to NeuroLink MCP server format
-     */
-    async convertToMCPServer(server) {
-        // This is a simplified conversion
-        // In a real implementation, you might want to actually spawn the server
-        // and discover its tools via MCP protocol
-        const mcpServer = {
-            id: server.id,
-            title: server.title,
-            category: this.mapToolToCategory(server.source.tool),
-            tools: {
-                // Placeholder - would be populated by actual MCP discovery
-                [`${server.id}-placeholder`]: {
-                    name: `${server.id}-placeholder`,
-                    description: `Placeholder tool for discovered server ${server.id}`,
-                    category: "discovered",
-                    isImplemented: false,
-                    execute: async (params, context) => {
-                        return {
-                            success: false,
-                            error: "This is a placeholder tool. Actual server discovery not yet implemented.",
-                        };
-                    },
-                },
-            },
-            registerTool(tool) {
-                // Check for duplicate tool names
-                if (this.tools[tool.name]) {
-                    throw new Error(`Tool '${tool.name}' already exists in discovered server '${this.id}'`);
-                }
-                // Register the tool
-                this.tools[tool.name] = {
-                    ...tool,
-                    // Add server metadata to tool
-                    metadata: {
-                        ...tool.metadata,
-                        serverId: this.id,
-                        serverCategory: this.category,
-                        registeredAt: Date.now(),
-                    },
-                };
-                return this;
-            },
-            metadata: {
-                source: server.source.tool,
-                configPath: server.configPath,
-                command: server.command,
-                args: server.args,
-                env: server.env,
-                cwd: server.cwd,
-                discoveredAt: Date.now(),
-            },
-        };
-        return mcpServer;
+        if (pluginPath.includes("src/lib/mcp/plugins")) {
+            return "core";
+        }
+        return "project";
     }
 }
 /**
  * Default auto-discovery instance
  */
-export const defaultAutoDiscovery = new MCPAutoDiscovery();
+export const autoDiscovery = new AutoDiscovery();
 /**
- * Utility function to discover servers with default instance
+ * Discover MCP servers using auto-discovery
  */
-export async function discoverMCPServers(options) {
-    return defaultAutoDiscovery.discoverServers(options);
+export async function discoverMCPServers(options = {}) {
+    const discovery = new AutoDiscovery(options);
+    return discovery.discover();
 }
 /**
- * Utility function to auto-register discovered servers
+ * Auto-register discovered MCP servers
  */
-export async function autoRegisterMCPServers(registry, options) {
-    return defaultAutoDiscovery.autoRegisterServers(registry, options);
+export async function autoRegisterMCPServers(options = {}) {
+    const discovered = await discoverMCPServers(options);
+    let registered = 0;
+    let failed = 0;
+    for (const plugin of discovered) {
+        try {
+            // Registration logic would go here
+            autoDiscoveryLogger.info(`Registered plugin: ${plugin.metadata.name}`);
+            registered++;
+        }
+        catch (error) {
+            autoDiscoveryLogger.error(`Failed to register ${plugin.metadata.name}:`, error);
+            failed++;
+        }
+    }
+    return {
+        registered,
+        failed,
+        plugins: discovered,
+    };
 }