@juspay/neurolink 6.0.0 → 6.2.0

package/dist/mcp/adapters/plugin-bridge.d.ts

@@ -1,40 +0,0 @@
-/**
- * Plugin Bridge Adapter
- * Provides compatibility layer for existing MCP integrations
- */
-import type { ExecutionContext } from "../contracts/mcp-contract.js";
-import type { JsonValue, UnknownRecord, Unknown } from "../../types/common.js";
-/**
- * Bridge interface for legacy MCP compatibility
- */
-export interface LegacyMCPBridge {
-    writeFile: (filePath: string, content: string) => Promise<void>;
-    readFile: (filePath: string) => Promise<string>;
-    listFiles: (dirPath: string) => Promise<string[]>;
-}
-/**
- * Create a bridge for legacy MCP integrations
- */
-export declare function createLegacyBridge(context: ExecutionContext): LegacyMCPBridge;
-/**
- * Enhanced execution context with bridge compatibility
- */
-export declare function enhanceExecutionContext(context: ExecutionContext): ExecutionContext;
-/**
- * Utility function to adapt legacy MCP calls
- */
-export declare function adaptLegacyMCPCall(context: ExecutionContext, operation: string, ...args: JsonValue[]): Promise<Unknown>;
-/**
- * Quick plugin factory for simple plugin creation
- */
-export declare class QuickPluginFactory {
-    static create(name: string, config: UnknownRecord): Promise<{
-        name: string;
-        config: UnknownRecord;
-        initialized: boolean;
-    }>;
-}
-/**
- * Execute plugin with enhanced context
- */
-export declare function executePlugin(plugin: UnknownRecord, context: ExecutionContext, operation: string, ...args: JsonValue[]): Promise<Unknown>;

package/dist/mcp/adapters/plugin-bridge.js

@@ -1,89 +0,0 @@
-/**
- * Plugin Bridge Adapter
- * Provides compatibility layer for existing MCP integrations
- */
-import * as path from "path";
-/**
- * Create a bridge for legacy MCP integrations
- */
-export function createLegacyBridge(context) {
-    const basePath = process.cwd();
-    return {
-        async writeFile(filePath, content) {
-            const fullPath = path.resolve(basePath, filePath);
-            await context.secureFS.writeFile(fullPath, content);
-        },
-        async readFile(filePath) {
-            const fullPath = path.resolve(basePath, filePath);
-            const result = await context.secureFS.readFile(fullPath, "utf-8");
-            return typeof result === "string" ? result : result.toString();
-        },
-        async listFiles(dirPath) {
-            const fullPath = path.resolve(basePath, dirPath);
-            return await context.secureFS.readdir(fullPath);
-        },
-    };
-}
-/**
- * Enhanced execution context with bridge compatibility
- */
-export function enhanceExecutionContext(context) {
-    return {
-        ...context,
-        path: {
-            join: path.join,
-            resolve: path.resolve,
-            relative: path.relative,
-            dirname: path.dirname,
-            basename: path.basename,
-        },
-        plugin: createLegacyBridge(context),
-    };
-}
-/**
- * Utility function to adapt legacy MCP calls
- */
-export async function adaptLegacyMCPCall(context, operation, ...args) {
-    const bridge = createLegacyBridge(context);
-    switch (operation) {
-        case "writeFile": {
-            const filePath = typeof args[0] === "string" ? args[0] : String(args[0]);
-            const content = typeof args[1] === "string" ? args[1] : String(args[1]);
-            return bridge.writeFile(filePath, content);
-        }
-        case "readFile": {
-            const readPath = typeof args[0] === "string" ? args[0] : String(args[0]);
-            return bridge.readFile(readPath);
-        }
-        case "listFiles": {
-            const listPath = typeof args[0] === "string" ? args[0] : String(args[0]);
-            return bridge.listFiles(listPath);
-        }
-        default:
-            throw new Error(`Unsupported legacy operation: ${operation}`);
-    }
-}
-/**
- * Quick plugin factory for simple plugin creation
- */
-export class QuickPluginFactory {
-    static async create(name, config) {
-        // Simple factory implementation
-        return {
-            name,
-            config,
-            initialized: true,
-        };
-    }
-}
-/**
- * Execute plugin with enhanced context
- */
-export async function executePlugin(plugin, context, operation, ...args) {
-    const enhancedContext = enhanceExecutionContext(context);
-    if (typeof plugin.execute === "function") {
-        return plugin.execute(enhancedContext, { operation, args });
-    }
-    // Fallback to legacy adaptation
-    return adaptLegacyMCPCall(enhancedContext, operation, ...args);
-}

package/dist/mcp/auto-discovery.d.ts

@@ -1,62 +0,0 @@
-/**
- * Auto-Discovery Module for MCP Plugins
- * Handles automatic plugin discovery and registration
- */
-import type { DiscoveredMCP } from "./contracts/mcp-contract.js";
-/**
- * Auto-discovery configuration
- */
-interface AutoDiscoveryConfig {
-    searchPaths: string[];
-    manifestName: string;
-    maxDepth: number;
-}
-/**
- * Auto-discovery service for MCP plugins
- */
-export declare class AutoDiscovery {
-    private config;
-    constructor(config?: Partial<AutoDiscoveryConfig>);
-    /**
-     * Discover all available MCP plugins
-     */
-    discover(): Promise<DiscoveredMCP[]>;
-    /**
-     * Discover plugins in a specific path
-     */
-    private discoverInPath;
-    /**
-     * Load plugin from manifest
-     */
-    private loadPlugin;
-    /**
-     * Determine plugin source based on path
-     */
-    private determineSource;
-}
-/**
- * Default auto-discovery instance
- */
-export declare const autoDiscovery: AutoDiscovery;
-/**
- * Discovery options interface
- */
-export interface DiscoveryOptions {
-    searchPaths?: string[];
-    manifestName?: string;
-    maxDepth?: number;
-    includeDevPlugins?: boolean;
-}
-/**
- * Discover MCP servers using auto-discovery
- */
-export declare function discoverMCPServers(options?: DiscoveryOptions): Promise<DiscoveredMCP[]>;
-/**
- * Auto-register discovered MCP servers
- */
-export declare function autoRegisterMCPServers(options?: DiscoveryOptions): Promise<{
-    registered: number;
-    failed: number;
-    plugins: DiscoveredMCP[];
-}>;
-export {};

package/dist/mcp/auto-discovery.js

@@ -1,149 +0,0 @@
-/**
- * Auto-Discovery Module for MCP Plugins
- * Handles automatic plugin discovery and registration
- */
-import * as fs from "fs/promises";
-import * as path from "path";
-import { autoDiscoveryLogger } from "./logging.js";
-/**
- * Default auto-discovery configuration
- */
-const DEFAULT_CONFIG = {
-    searchPaths: ["./src/lib/mcp/plugins", "./neurolink-mcp", "./node_modules"],
-    manifestName: "neurolink-mcp.json",
-    maxDepth: 3,
-};
-/**
- * Auto-discovery service for MCP plugins
- */
-export class AutoDiscovery {
-    config;
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    /**
-     * Discover all available MCP plugins
-     */
-    async discover() {
-        const discovered = [];
-        for (const searchPath of this.config.searchPaths) {
-            try {
-                const plugins = await this.discoverInPath(searchPath);
-                discovered.push(...plugins);
-            }
-            catch (error) {
-                autoDiscoveryLogger.debug(`Failed to discover in ${searchPath}:`, error);
-            }
-        }
-        autoDiscoveryLogger.info(`Auto-discovery completed: ${discovered.length} plugins found`);
-        return discovered;
-    }
-    /**
-     * Discover plugins in a specific path
-     */
-    async discoverInPath(basePath, depth = 0) {
-        if (depth > this.config.maxDepth) {
-            return [];
-        }
-        const discovered = [];
-        try {
-            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);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            autoDiscoveryLogger.debug(`Failed to scan ${basePath}:`, error);
-        }
-        return discovered;
-    }
-    /**
-     * Load plugin from manifest
-     */
-    async loadPlugin(manifestPath, pluginPath) {
-        try {
-            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) {
-            autoDiscoveryLogger.error(`Failed to load plugin manifest at ${manifestPath}:`, error);
-            return null;
-        }
-    }
-    /**
-     * Determine plugin source based on path
-     */
-    determineSource(pluginPath) {
-        if (pluginPath.includes("node_modules")) {
-            return "installed";
-        }
-        if (pluginPath.includes("src/lib/mcp/plugins")) {
-            return "core";
-        }
-        return "project";
-    }
-}
-/**
- * Default auto-discovery instance
- */
-export const autoDiscovery = new AutoDiscovery();
-/**
- * Discover MCP servers using auto-discovery
- */
-export async function discoverMCPServers(options = {}) {
-    const discovery = new AutoDiscovery(options);
-    return discovery.discover();
-}
-/**
- * Auto-register discovered MCP servers
- */
-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,
-    };
-}

package/dist/mcp/client.d.ts

@@ -1,68 +0,0 @@
-/**
- * NeuroLink MCP Client
- * Following Lighthouse's pattern for MCP tool registration and execution
- */
-import { EventEmitter } from "events";
-import type { ToolResult, NeuroLinkExecutionContext } from "./factory.js";
-import type { Unknown } from "../types/common.js";
-/**
- * MCP Client Configuration
- */
-export interface MCPClientConfig {
-    sessionId: string;
-    userId?: string;
-    aiProvider?: string;
-    modelId?: string;
-    logLevel?: "debug" | "info" | "warn" | "error";
-}
-/**
- * NeuroLink MCP Client
- * Manages tool registration and execution following Lighthouse patterns
- */
-export declare class NeuroLinkMCPClient extends EventEmitter {
-    private tools;
-    private config;
-    private executionCount;
-    private isConnected;
-    constructor(config: MCPClientConfig);
-    /**
-     * Register a tool with the MCP client
-     * Following Lighthouse's pattern of namespacing tools with server ID
-     */
-    registerTool(toolName: string, execute: (name: string, params: Record<string, unknown>) => Promise<Unknown>, description?: string, inputSchema?: unknown): void;
-    /**
-     * Get all registered tools
-     */
-    getTools(): Record<string, {
-        name: string;
-        description?: string;
-        inputSchema?: unknown;
-    }>;
-    /**
-     * Execute a tool by name
-     */
-    executeTool(toolName: string, params: unknown, context?: Partial<NeuroLinkExecutionContext>): Promise<ToolResult>;
-    /**
-     * Check if connected to MCP
-     */
-    isConnectedToMCP(): boolean;
-    /**
-     * Disconnect from MCP
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Get client statistics
-     */
-    getStats(): {
-        sessionId: string;
-        toolCount: number;
-        executionCount: number;
-        isConnected: boolean;
-        uptime: number;
-    };
-    private startTime;
-}
-/**
- * Create a new MCP client instance
- */
-export declare function createMCPClient(config: MCPClientConfig): NeuroLinkMCPClient;

package/dist/mcp/client.js

@@ -1,248 +0,0 @@
-/**
- * NeuroLink MCP Client
- * Following Lighthouse's pattern for MCP tool registration and execution
- */
-import { EventEmitter } from "events";
-import { logger } from "../utils/logger.js";
-/**
- * NeuroLink MCP Client
- * Manages tool registration and execution following Lighthouse patterns
- */
-export class NeuroLinkMCPClient extends EventEmitter {
-    tools = new Map();
-    config;
-    executionCount = 0;
-    isConnected = false;
-    constructor(config) {
-        super();
-        this.config = config;
-        this.isConnected = true;
-        logger.info(`[MCP Client] Initialized for session ${config.sessionId}`, {
-            userId: config.userId,
-            aiProvider: config.aiProvider,
-            modelId: config.modelId,
-        });
-    }
-    /**
-     * Register a tool with the MCP client
-     * Following Lighthouse's pattern of namespacing tools with server ID
-     */
-    registerTool(toolName, execute, description, inputSchema) {
-        // Parse server ID from tool name (format: serverId_toolName)
-        const parts = toolName.split("_");
-        const serverId = parts[0];
-        const originalName = parts.slice(1).join("_");
-        // Create registered tool
-        const registeredTool = {
-            name: toolName,
-            originalName,
-            serverId,
-            execute: async (params, context) => {
-                try {
-                    // Call the execute function with Lighthouse-style parameters
-                    const result = await execute(toolName, params);
-                    // Handle different response formats
-                    if (result && typeof result === "object") {
-                        // If it's already in NeuroLink format
-                        if ("success" in result &&
-                            ("data" in result || "error" in result)) {
-                            return result;
-                        }
-                        // If it's in Lighthouse format with content array
-                        const lightouseResult = result;
-                        if (lightouseResult.text &&
-                            Array.isArray(lightouseResult.text) &&
-                            lightouseResult.text[0]?.text) {
-                            try {
-                                const data = JSON.parse(lightouseResult.text[0].text);
-                                return {
-                                    success: !lightouseResult.isError,
-                                    data,
-                                    metadata: {
-                                        toolName,
-                                        serverId,
-                                        sessionId: context.sessionId,
-                                        timestamp: Date.now(),
-                                    },
-                                };
-                            }
-                            catch (parseError) {
-                                // If JSON parsing fails, return the text as-is
-                                return {
-                                    success: !lightouseResult.isError,
-                                    data: { text: lightouseResult.text[0].text },
-                                    metadata: {
-                                        toolName,
-                                        serverId,
-                                        sessionId: context.sessionId,
-                                        timestamp: Date.now(),
-                                    },
-                                };
-                            }
-                        }
-                        // If it has a direct text property
-                        const textResult = result;
-                        if (textResult.text) {
-                            return {
-                                success: true,
-                                data: { text: textResult.text },
-                                metadata: {
-                                    toolName,
-                                    serverId,
-                                    sessionId: context.sessionId,
-                                    timestamp: Date.now(),
-                                },
-                            };
-                        }
-                    }
-                    return {
-                        success: false,
-                        error: "Invalid tool response format",
-                    };
-                }
-                catch (error) {
-                    logger.error(`[MCP Client] Tool execution failed: ${toolName}`, error);
-                    return {
-                        success: false,
-                        error: error instanceof Error ? error.message : String(error),
-                    };
-                }
-            },
-            description,
-            inputSchema,
-        };
-        // Register the tool
-        this.tools.set(toolName, registeredTool);
-        logger.debug(`[MCP Client] Registered tool: ${toolName}`, {
-            serverId,
-            originalName,
-            description,
-        });
-        // Emit tool registration event
-        this.emit("tool:registered", {
-            toolName,
-            serverId,
-            originalName,
-        });
-    }
-    /**
-     * Get all registered tools
-     */
-    getTools() {
-        const tools = {};
-        for (const [name, tool] of Array.from(this.tools.entries())) {
-            tools[name] = {
-                name: name, // Include the tool name as a property
-                description: tool.description,
-                inputSchema: tool.inputSchema,
-            };
-        }
-        return tools;
-    }
-    /**
-     * Execute a tool by name
-     */
-    async executeTool(toolName, params, context) {
-        const tool = this.tools.get(toolName);
-        if (!tool) {
-            return {
-                success: false,
-                error: `Tool not found: ${toolName}`,
-            };
-        }
-        // Create full context using createExecutionContext for proper structure
-        const { createExecutionContext } = await import("./context-manager.js");
-        const fullContext = createExecutionContext({
-            sessionId: this.config.sessionId,
-            userId: this.config.userId,
-            aiProvider: this.config.aiProvider,
-            modelId: this.config.modelId,
-            ...context,
-        });
-        // Track execution
-        this.executionCount++;
-        const executionId = `exec-${this.executionCount}`;
-        // Emit execution start event
-        this.emit("tool:execute:start", {
-            executionId,
-            toolName,
-            serverId: tool.serverId,
-            params,
-        });
-        const startTime = Date.now();
-        try {
-            // Execute the tool
-            const result = await tool.execute(params, fullContext);
-            // Add execution metadata
-            result.metadata = {
-                ...result.metadata,
-                executionId,
-                executionTime: Date.now() - startTime,
-            };
-            // Emit execution complete event
-            this.emit("tool:execute:complete", {
-                executionId,
-                toolName,
-                serverId: tool.serverId,
-                success: result.success,
-                executionTime: result.metadata.executionTime,
-            });
-            return result;
-        }
-        catch (error) {
-            const executionTime = Date.now() - startTime;
-            // Emit execution error event
-            this.emit("tool:execute:error", {
-                executionId,
-                toolName,
-                serverId: tool.serverId,
-                error: error instanceof Error ? error.message : String(error),
-                executionTime,
-            });
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                metadata: {
-                    executionId,
-                    toolName,
-                    serverId: tool.serverId,
-                    executionTime,
-                },
-            };
-        }
-    }
-    /**
-     * Check if connected to MCP
-     */
-    isConnectedToMCP() {
-        return this.isConnected;
-    }
-    /**
-     * Disconnect from MCP
-     */
-    async disconnect() {
-        this.isConnected = false;
-        this.tools.clear();
-        this.removeAllListeners();
-        logger.info(`[MCP Client] Disconnected for session ${this.config.sessionId}`);
-    }
-    /**
-     * Get client statistics
-     */
-    getStats() {
-        return {
-            sessionId: this.config.sessionId,
-            toolCount: this.tools.size,
-            executionCount: this.executionCount,
-            isConnected: this.isConnected,
-            uptime: Date.now() - (this.startTime || Date.now()),
-        };
-    }
-    startTime = Date.now();
-}
-/**
- * Create a new MCP client instance
- */
-export function createMCPClient(config) {
-    return new NeuroLinkMCPClient(config);
-}

package/dist/mcp/config.d.ts

@@ -1,31 +0,0 @@
-/**
- * NeuroLink MCP Configuration
- * Central registry for all MCP servers following Lighthouse patterns
- * Handles built-in servers only - auto-discovery handled by unified registry
- */
-import type { NeuroLinkMCPServer } from "./factory.js";
-/**
- * Built-in MCP servers (kept for backward compatibility)
- * Add new servers here as they are created
- */
-export declare const allServers: NeuroLinkMCPServer[];
-/**
- * MCP Configuration following Lighthouse patterns
- * Handles built-in servers - auto-discovery is handled by unified registry
- */
-export declare const mcpConfig: {
-    /**
-     * Get list of active built-in MCP servers with implemented tools
-     */
-    getServers: () => Promise<NeuroLinkMCPServer[]>;
-    /**
-     * Get all available tools across all servers
-     */
-    getAllTools: () => Promise<{
-        name: string;
-        description: string;
-        serverId: string;
-        serverTitle: string;
-        category?: string;
-    }[]>;
-};