@juspay/neurolink 1.10.0 → 1.11.1

package/dist/mcp/index.d.ts

@@ -1,190 +1,45 @@
 /**
- * NeuroLink MCP (Model Context Protocol) Module
- *
- * This module exports the MCP configuration and initialization utilities
- * for use throughout the application, following Lighthouse's patterns.
+ * MCP Ecosystem - Main Export
+ * Universal AI Development Platform with Extensible Plugin Architecture
+ * Implementation based on research blueprint
  */
-import { getMCPManager, removeMCPManager } from "./manager.js";
-import { createMCPServer } from "./factory.js";
-import type { NeuroLinkMCPServer } from "./factory.js";
-export { createMCPServer } from "./factory.js";
-export { mcpConfig } from "./config.js";
-export { getMCPManager, removeMCPManager, MCPManager } from "./manager.js";
-export { createMCPClient } from "./client.js";
-export { initializeMCPTools, getAllAvailableTools, initializeServerTools, } from "./initialize-tools.js";
-export type { NeuroLinkMCPServer, NeuroLinkMCPTool, NeuroLinkExecutionContext, ToolResult, MCPServerCategory, MCPServerConfig, } from "./factory.js";
-export type { MCPClientConfig } from "./client.js";
+export { MCP } from "./contracts/mcp-contract.js";
+export type { MCPMetadata, ExecutionContext, MCPConstructor, MCPInstance, DiscoveredMCP, } from "./contracts/mcp-contract.js";
+export { MCPEcosystem, mcpEcosystem } from "./ecosystem.js";
+export { PluginManager, pluginManager } from "./plugin-manager.js";
+export { SecurityManager } from "./security-manager.js";
+export { mcpLogger } from "./logging.js";
+export type { LogLevel } from "./logging.js";
+export { FileSystemMCP } from "./plugins/core/filesystem-mcp.js";
+import type { MCPMetadata } from "./contracts/mcp-contract.js";
 /**
- * MCP utilities for system-wide operations
+ * Initialize the MCP ecosystem
  */
-export declare const MCPUtils: {
-    /**
-     * Get a formatted list of all available tools across all registered MCP servers
-     * Useful for documentation or configuration UI
-     */
-    getAvailableTools: () => Promise<{
-        serverId: string;
-        serverTitle: string;
-        serverDescription: string | undefined;
-        category: import("./factory.js").MCPServerCategory | undefined;
-        toolCount: number;
-        tools: {
-            name: string;
-            description: string;
-            isImplemented: boolean;
-        }[];
-    }[]>;
-    /**
-     * Function to test connectivity with MCP servers
-     * Returns diagnostics about the MCP server initialization status
-     */
-    testConnectivity: () => Promise<{
-        status: string;
-        message: string;
-        servers: {
-            serverId: string;
-            serverTitle: string;
-            status: string;
-            toolCount: number;
-            implementedTools: number;
-        }[];
-        timestamp: string;
-    } | {
-        status: string;
-        message: string;
-        timestamp: string;
-        servers?: undefined;
-    }>;
-    /**
-     * Get statistics about MCP usage
-     */
-    getStatistics: () => Promise<{
-        servers: {
-            total: number;
-            byCategory: Record<string, number>;
-        };
-        tools: {
-            totalTools: number;
-            implementedTools: number;
-            byCategory: Record<string, number>;
-        };
-        sessions: {
-            instanceCount: number;
-            maxInstances: number;
-            instances: Record<string, any>;
-        };
-    }>;
-    /**
-     * Initialize MCP for a session
-     * Convenience method that sets up everything needed for a session
-     */
-    initializeSession: (sessionId: string, config?: {
-        userId?: string;
-        aiProvider?: string;
-        modelId?: string;
-    }) => Promise<{
-        sessionId: string;
-        client: import("./client.js").NeuroLinkMCPClient;
-        context: import("./factory.js").NeuroLinkExecutionContext;
-        toolCount: number;
-    }>;
-    /**
-     * Clean up a session
-     */
-    cleanupSession: (sessionId: string) => Promise<boolean>;
-};
+export declare function initializeMCPEcosystem(): Promise<void>;
 /**
- * Default export for convenience
+ * List available MCPs
  */
-declare const _default: {
-    config: {
-        getServers: () => Promise<NeuroLinkMCPServer[]>;
-        getAllTools: () => Promise<{
-            name: string;
-            description: string;
-            serverId: string;
-            serverTitle: string;
-            category?: string;
-        }[]>;
-    };
-    utils: {
-        /**
-         * Get a formatted list of all available tools across all registered MCP servers
-         * Useful for documentation or configuration UI
-         */
-        getAvailableTools: () => Promise<{
-            serverId: string;
-            serverTitle: string;
-            serverDescription: string | undefined;
-            category: import("./factory.js").MCPServerCategory | undefined;
-            toolCount: number;
-            tools: {
-                name: string;
-                description: string;
-                isImplemented: boolean;
-            }[];
-        }[]>;
-        /**
-         * Function to test connectivity with MCP servers
-         * Returns diagnostics about the MCP server initialization status
-         */
-        testConnectivity: () => Promise<{
-            status: string;
-            message: string;
-            servers: {
-                serverId: string;
-                serverTitle: string;
-                status: string;
-                toolCount: number;
-                implementedTools: number;
-            }[];
-            timestamp: string;
-        } | {
-            status: string;
-            message: string;
-            timestamp: string;
-            servers?: undefined;
-        }>;
-        /**
-         * Get statistics about MCP usage
-         */
-        getStatistics: () => Promise<{
-            servers: {
-                total: number;
-                byCategory: Record<string, number>;
-            };
-            tools: {
-                totalTools: number;
-                implementedTools: number;
-                byCategory: Record<string, number>;
-            };
-            sessions: {
-                instanceCount: number;
-                maxInstances: number;
-                instances: Record<string, any>;
-            };
-        }>;
-        /**
-         * Initialize MCP for a session
-         * Convenience method that sets up everything needed for a session
-         */
-        initializeSession: (sessionId: string, config?: {
-            userId?: string;
-            aiProvider?: string;
-            modelId?: string;
-        }) => Promise<{
-            sessionId: string;
-            client: import("./client.js").NeuroLinkMCPClient;
-            context: import("./factory.js").NeuroLinkExecutionContext;
-            toolCount: number;
-        }>;
-        /**
-         * Clean up a session
-         */
-        cleanupSession: (sessionId: string) => Promise<boolean>;
-    };
-    createServer: typeof createMCPServer;
-    getManager: typeof getMCPManager;
-    removeManager: typeof removeMCPManager;
-};
-export default _default;
+export declare function listMCPs(): Promise<MCPMetadata[]>;
+/**
+ * Execute an MCP operation
+ */
+export declare function executeMCP<T = any>(name: string, config: any, args: any, context?: {
+    sessionId?: string;
+    userId?: string;
+}): Promise<T>;
+/**
+ * Quick filesystem operations
+ */
+export declare function readFile(path: string, basePath?: string): Promise<any>;
+export declare function writeFile(path: string, content: string, basePath?: string): Promise<any>;
+export declare function listFiles(path: string, basePath?: string): Promise<any>;
+export declare function createDirectory(path: string, basePath?: string): Promise<any>;
+/**
+ * Get MCP ecosystem statistics
+ */
+export declare function getMCPStats(): Promise<{
+    initialized: boolean;
+    pluginsDiscovered: number;
+    pluginsBySource: Record<string, number>;
+    availablePlugins: string[];
+}>;

package/dist/mcp/index.js

@@ -1,156 +1,78 @@
 /**
- * NeuroLink MCP (Model Context Protocol) Module
- *
- * This module exports the MCP configuration and initialization utilities
- * for use throughout the application, following Lighthouse's patterns.
+ * MCP Ecosystem - Main Export
+ * Universal AI Development Platform with Extensible Plugin Architecture
+ * Implementation based on research blueprint
  */
-import { mcpConfig } from "./config.js";
-import { getMCPManager, removeMCPManager, MCPManager } from "./manager.js";
-import { initializeMCPTools, getAllAvailableTools, initializeServerTools, } from "./initialize-tools.js";
-import { createMCPServer } from "./factory.js";
-import { logger } from "../utils/logger.js";
-// Re-export core components
-export { createMCPServer } from "./factory.js";
-export { mcpConfig } from "./config.js";
-export { getMCPManager, removeMCPManager, MCPManager } from "./manager.js";
-export { createMCPClient } from "./client.js";
-export { initializeMCPTools, getAllAvailableTools, initializeServerTools, } from "./initialize-tools.js";
+// Core contracts and types
+export { MCP } from "./contracts/mcp-contract.js";
+// Main ecosystem interface
+export { MCPEcosystem, mcpEcosystem } from "./ecosystem.js";
+// Plugin management
+export { PluginManager, pluginManager } from "./plugin-manager.js";
+// Security
+export { SecurityManager } from "./security-manager.js";
+// Logging
+export { mcpLogger } from "./logging.js";
+// Core plugins
+export { FileSystemMCP } from "./plugins/core/filesystem-mcp.js";
 /**
- * MCP utilities for system-wide operations
+ * Quick access functions for common MCP operations
  */
-export const MCPUtils = {
-    /**
-     * Get a formatted list of all available tools across all registered MCP servers
-     * Useful for documentation or configuration UI
-     */
-    getAvailableTools: async () => {
-        const servers = await mcpConfig.getServers();
-        return servers.map((server) => ({
-            serverId: server.id,
-            serverTitle: server.title,
-            serverDescription: server.description,
-            category: server.category,
-            toolCount: Object.keys(server.tools).length,
-            tools: Object.entries(server.tools).map(([name, tool]) => ({
-                name,
-                description: tool.description,
-                isImplemented: tool.isImplemented !== false,
-            })),
-        }));
-    },
-    /**
-     * Function to test connectivity with MCP servers
-     * Returns diagnostics about the MCP server initialization status
-     */
-    testConnectivity: async () => {
-        try {
-            const servers = await mcpConfig.getServers();
-            const results = servers.map((server) => ({
-                serverId: server.id,
-                serverTitle: server.title,
-                status: "connected",
-                toolCount: Object.keys(server.tools).length,
-                implementedTools: Object.values(server.tools).filter((tool) => tool.isImplemented !== false).length,
-            }));
-            const totalToolCount = results.reduce((acc, server) => acc + server.toolCount, 0);
-            const totalImplemented = results.reduce((acc, server) => acc + server.implementedTools, 0);
-            logger.info("[MCP Utils] Connectivity test successful", {
-                serverCount: results.length,
-                totalToolCount,
-                totalImplemented,
-            });
-            return {
-                status: "ok",
-                message: `Connected to ${results.length} MCP servers with ${totalToolCount} total tools (${totalImplemented} implemented)`,
-                servers: results,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : "Unknown error";
-            logger.error("[MCP Utils] Connectivity test failed", {
-                error: errorMessage,
-            });
-            return {
-                status: "error",
-                message: `Failed to connect to MCP servers: ${errorMessage}`,
-                timestamp: new Date().toISOString(),
-            };
-        }
-    },
-    /**
-     * Get statistics about MCP usage
-     */
-    getStatistics: async () => {
-        const servers = await mcpConfig.getServers();
-        const managerStats = MCPManager.getAllStats();
-        const toolStats = servers.reduce((acc, server) => {
-            const tools = Object.values(server.tools);
-            acc.totalTools += tools.length;
-            acc.implementedTools += tools.filter((t) => t.isImplemented !== false).length;
-            // Count by category
-            if (server.category) {
-                acc.byCategory[server.category] =
-                    (acc.byCategory[server.category] || 0) + tools.length;
-            }
-            return acc;
-        }, {
-            totalTools: 0,
-            implementedTools: 0,
-            byCategory: {},
-        });
-        return {
-            servers: {
-                total: servers.length,
-                byCategory: servers.reduce((acc, server) => {
-                    const category = server.category || "custom";
-                    acc[category] = (acc[category] || 0) + 1;
-                    return acc;
-                }, {}),
-            },
-            tools: toolStats,
-            sessions: managerStats,
-        };
-    },
-    /**
-     * Initialize MCP for a session
-     * Convenience method that sets up everything needed for a session
-     */
-    initializeSession: async (sessionId, config) => {
-        // Get or create MCP client for session
-        const client = getMCPManager(sessionId, config);
-        // Create context for tool execution
-        const context = {
-            sessionId,
-            userId: config?.userId,
-            aiProvider: config?.aiProvider,
-            modelId: config?.modelId,
-            timestamp: Date.now(),
-        };
-        // Initialize all tools
-        initializeMCPTools(sessionId, client, context);
-        // Return session info
-        return {
-            sessionId,
-            client,
-            context,
-            toolCount: Object.keys(client.getTools()).length,
-        };
-    },
-    /**
-     * Clean up a session
-     */
-    cleanupSession: async (sessionId) => {
-        return removeMCPManager(sessionId);
-    },
-};
+// Import the ecosystem singleton
+import { mcpEcosystem } from "./ecosystem.js";
 /**
- * Default export for convenience
+ * Initialize the MCP ecosystem
  */
-export default {
-    config: mcpConfig,
-    utils: MCPUtils,
-    createServer: createMCPServer,
-    getManager: getMCPManager,
-    removeManager: removeMCPManager,
-};
+export async function initializeMCPEcosystem() {
+    return mcpEcosystem.initialize();
+}
+/**
+ * List available MCPs
+ */
+export async function listMCPs() {
+    return mcpEcosystem.list();
+}
+/**
+ * Execute an MCP operation
+ */
+export async function executeMCP(name, config, args, context) {
+    return mcpEcosystem.execute(name, config, args, context);
+}
+/**
+ * Quick filesystem operations
+ */
+export async function readFile(path, basePath) {
+    return mcpEcosystem.filesystem({
+        action: "readFile",
+        path,
+        basePath,
+    });
+}
+export async function writeFile(path, content, basePath) {
+    return mcpEcosystem.filesystem({
+        action: "writeFile",
+        path,
+        content,
+        basePath,
+    });
+}
+export async function listFiles(path, basePath) {
+    return mcpEcosystem.filesystem({
+        action: "listFiles",
+        path,
+        basePath,
+    });
+}
+export async function createDirectory(path, basePath) {
+    return mcpEcosystem.filesystem({
+        action: "createDir",
+        path,
+        basePath,
+    });
+}
+/**
+ * Get MCP ecosystem statistics
+ */
+export async function getMCPStats() {
+    return mcpEcosystem.getStats();
+}

package/dist/mcp/initialize.js

@@ -3,7 +3,7 @@
  * Automatically registers built-in NeuroLink servers with the default registry
  * Ensures built-in tools are always available without manual configuration
  */
-import { defaultToolRegistry } from "./registry.js";
+import { toolRegistry, defaultToolRegistry } from "./tool-registry.js";
 import { mcpLogger } from "./logging.js";
 let isInitialized = false;
 /**
@@ -19,14 +19,14 @@ export async function initializeNeuroLinkMCP() {
         // Note: AI core server temporarily disabled due to circular dependency issues
         const { utilityServer } = await import("./servers/utilities/utility-server.js");
         // Register built-in NeuroLink servers with default registry
-        await defaultToolRegistry.registerServer(utilityServer);
+        await toolRegistry.registerServer(utilityServer.id, utilityServer);
         mcpLogger.debug("Registered neurolink-utility server with built-in tools");
         // TODO: Re-enable AI core server once circular dependencies are resolved
         // const { aiCoreServer } = await import('./servers/ai-providers/ai-core-server.js');
-        // await defaultToolRegistry.registerServer(aiCoreServer);
+        // await toolRegistry.registerServer(aiCoreServer.id, aiCoreServer);
         // mcpLogger.debug('Registered neurolink-ai-core server with AI tools');
-        const stats = defaultToolRegistry.getStats();
-        mcpLogger.info(`Initialization complete: ${stats.totalServers} servers, ${stats.totalTools} tools available`);
+        const stats = await toolRegistry.getStats();
+        mcpLogger.info(`Initialization complete: ${stats.totalServers} server, ${stats.totalTools} tools available`);
         isInitialized = true;
     }
     catch (error) {

package/dist/mcp/logging.d.ts

@@ -1,71 +1,38 @@
 /**
- * NeuroLink MCP Logging System
- * Provides configurable logging with different verbosity levels
+ * MCP Logging Utility
+ * Centralized logging for the MCP ecosystem
  */
-export declare enum LogLevel {
-    SILENT = 0,
-    ERROR = 1,
-    WARN = 2,
-    INFO = 3,
-    DEBUG = 4
-}
-export interface LoggerConfig {
+export type LogLevel = "debug" | "info" | "warn" | "error";
+interface LogEntry {
     level: LogLevel;
-    prefix?: string;
-    colors?: boolean;
-    timestamp?: boolean;
+    message: string;
+    timestamp: Date;
+    data?: unknown;
 }
-/**
- * Configurable logger for MCP operations
- */
-export declare class MCPLogger {
-    private config;
-    constructor(config?: Partial<LoggerConfig>);
-    /**
-     * Set log level
-     */
-    setLevel(level: LogLevel): void;
-    /**
-     * Get current log level
-     */
-    getLevel(): LogLevel;
-    /**
-     * Log an error message
-     */
-    error(message: string, ...args: any[]): void;
-    /**
-     * Log a warning message
-     */
-    warn(message: string, ...args: any[]): void;
-    /**
-     * Log an info message
-     */
-    info(message: string, ...args: any[]): void;
-    /**
-     * Log a debug message
-     */
-    debug(message: string, ...args: any[]): void;
-    /**
-     * Internal logging method
-     */
+declare class MCPLogger {
+    private logLevel;
+    private logs;
+    private maxLogs;
+    constructor();
+    setLogLevel(level: LogLevel): void;
+    private shouldLog;
     private log;
+    debug(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+    getLogs(level?: LogLevel): LogEntry[];
+    clearLogs(): void;
 }
-/**
- * Create logger instances for different MCP components
- */
-export declare const createLogger: (component: string) => MCPLogger;
-/**
- * Default loggers for common MCP components
- */
 export declare const mcpLogger: MCPLogger;
 export declare const autoDiscoveryLogger: MCPLogger;
 export declare const registryLogger: MCPLogger;
 export declare const unifiedRegistryLogger: MCPLogger;
-/**
- * Utility function to set global MCP log level
- */
 export declare function setGlobalMCPLogLevel(level: LogLevel): void;
-/**
- * Utility function to parse log level from string
- */
-export declare function parseLogLevel(level: string): LogLevel;
+export declare const LogLevels: {
+    readonly debug: "debug";
+    readonly info: "info";
+    readonly warn: "warn";
+    readonly error: "error";
+};
+export {};