@juspay/neurolink 6.0.0 → 6.2.0

package/dist/mcp/config.js

@@ -1,99 +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 { utilityServer } from "./servers/utilities/utility-server.js";
-import { logger } from "../utils/logger.js";
-/**
- * Lazy-loaded AI Core Server to avoid circular dependencies
- */
-let aiCoreServerCache = null;
-async function getAICoreServer() {
-    if (!aiCoreServerCache) {
-        const { aiCoreServer } = await import("./servers/ai-providers/ai-core-server.js");
-        aiCoreServerCache = aiCoreServer;
-    }
-    return aiCoreServerCache;
-}
-/**
- * Lazy-loaded Direct Tools Server to avoid circular dependencies
- */
-let directToolsServerCache = null;
-async function getDirectToolsServer() {
-    if (!directToolsServerCache) {
-        const { directToolsServer } = await import("./servers/agent/direct-tools-server.js");
-        directToolsServerCache = directToolsServer;
-    }
-    return directToolsServerCache;
-}
-/**
- * Built-in MCP servers (kept for backward compatibility)
- * Add new servers here as they are created
- */
-export const allServers = [
-    // aiCoreServer will be added dynamically in getServers()
-    utilityServer,
-    // Add more servers as they are created
-];
-/**
- * MCP Configuration following Lighthouse patterns
- * Handles built-in servers - auto-discovery is handled by unified registry
- */
-export const mcpConfig = {
-    /**
-     * Get list of active built-in MCP servers with implemented tools
-     */
-    getServers: async () => {
-        const activeServers = [];
-        // Get all servers including dynamically loaded ones
-        const aiCoreServer = await getAICoreServer();
-        const directToolsServer = await getDirectToolsServer();
-        const servers = [aiCoreServer, directToolsServer, ...allServers];
-        // Include built-in servers with filtering
-        for (const server of servers) {
-            const implementedTools = {};
-            let hasImplementedTools = false;
-            for (const toolName in server.tools) {
-                const tool = server.tools[toolName];
-                // Only include tools that are implemented (default to true if not specified)
-                if (tool.isImplemented !== false) {
-                    implementedTools[toolName] = tool;
-                    hasImplementedTools = true;
-                }
-            }
-            // Only include servers that have at least one implemented tool
-            if (hasImplementedTools) {
-                activeServers.push({
-                    ...server,
-                    tools: implementedTools,
-                });
-            }
-        }
-        logger.debug("[MCP Config] Built-in servers:", {
-            total: activeServers.length,
-            serverIds: activeServers.map((s) => s.id),
-        });
-        return activeServers;
-    },
-    /**
-     * Get all available tools across all servers
-     */
-    getAllTools: async () => {
-        const servers = await mcpConfig.getServers();
-        const allTools = [];
-        for (const server of servers) {
-            for (const toolName in server.tools) {
-                const tool = server.tools[toolName];
-                allTools.push({
-                    name: toolName,
-                    description: tool.description,
-                    serverId: server.id,
-                    serverTitle: server.title,
-                    category: tool.category,
-                });
-            }
-        }
-        return allTools;
-    },
-};

package/dist/mcp/context-manager.d.ts

@@ -1,171 +0,0 @@
-/**
- * NeuroLink MCP Context Management System
- * Unified context creation and management for all tool executions
- * Ensures rich context flows through tool chain with session tracking
- */
-import type { NeuroLinkExecutionContext } from "./factory.js";
-/**
- * Context creation request interface
- */
-export interface ContextRequest {
-    sessionId?: string;
-    userId?: string;
-    aiProvider?: string;
-    modelId?: string;
-    temperature?: number;
-    maxTokens?: number;
-    organizationId?: string;
-    projectId?: string;
-    environmentType?: "development" | "staging" | "production";
-    frameworkType?: "react" | "vue" | "svelte" | "next" | "nuxt" | "sveltekit";
-    permissions?: string[];
-    securityLevel?: "public" | "private" | "organization";
-    [key: string]: unknown;
-}
-/**
- * Context manager for creating and managing execution contexts
- * Provides rich context for all tool executions with session tracking
- */
-export declare class ContextManager {
-    private sessionCounter;
-    private activeContexts;
-    private static cachedLogger;
-    /**
-     * Create a new execution context with rich information
-     *
-     * @param request Context creation request with optional fields
-     * @returns Complete execution context ready for tool chain
-     */
-    createContext(request?: ContextRequest): NeuroLinkExecutionContext;
-    /**
-     * Add a tool to the execution chain
-     *
-     * @param context Execution context to modify
-     * @param toolName Name of the tool being executed
-     */
-    addToToolChain(context: NeuroLinkExecutionContext, toolName: string): void;
-    /**
-     * Get the current tool chain for a context
-     *
-     * @param context Execution context
-     * @returns Array of tool names in execution order
-     */
-    getToolChain(context: NeuroLinkExecutionContext): string[];
-    /**
-     * Set parent tool for nested tool execution
-     *
-     * @param context Execution context to modify
-     * @param parentToolId ID of the parent tool
-     */
-    setParentTool(context: NeuroLinkExecutionContext, parentToolId: string): void;
-    /**
-     * Create child context for nested tool execution
-     *
-     * @param parentContext Parent execution context
-     * @param childToolName Name of the child tool
-     * @returns New child context with inherited properties
-     */
-    createChildContext(parentContext: NeuroLinkExecutionContext, childToolName: string): NeuroLinkExecutionContext;
-    /**
-     * Get context by session ID
-     *
-     * @param sessionId Session identifier
-     * @returns Execution context or undefined if not found
-     */
-    getContext(sessionId: string): NeuroLinkExecutionContext | undefined;
-    /**
-     * Update context with new information
-     *
-     * @param sessionId Session identifier
-     * @param updates Partial context updates
-     */
-    updateContext(sessionId: string, updates: Partial<NeuroLinkExecutionContext>): void;
-    /**
-     * Store context directly (used when session ID changes)
-     *
-     * @param context Complete execution context to store
-     */
-    storeContext(context: NeuroLinkExecutionContext): void;
-    /**
-     * Remove context from active tracking
-     *
-     * @param sessionId Session identifier
-     */
-    removeContext(sessionId: string): void;
-    /**
-     * Get all active contexts (for debugging/monitoring)
-     *
-     * @returns Array of all active contexts
-     */
-    getActiveContexts(): NeuroLinkExecutionContext[];
-    /**
-     * Clear all active contexts
-     */
-    clearAllContexts(): void;
-    /**
-     * Get context statistics
-     *
-     * @returns Context usage statistics
-     */
-    getStats(): {
-        activeContexts: number;
-        totalSessionsCreated: number;
-        averageToolChainLength: number;
-    };
-    /**
-     * Generate unique session ID
-     *
-     * @returns Unique session identifier
-     */
-    private generateSessionId;
-    /**
-     * Extract custom fields from request (excluding known fields)
-     *
-     * @param request Context creation request
-     * @returns Custom fields object
-     */
-    private extractCustomFields;
-}
-/**
- * Default context manager instance
- * Can be used across the application for consistent context management
- */
-export declare const defaultContextManager: ContextManager;
-/**
- * Utility function to create context with defaults
- *
- * @param request Optional context request
- * @returns Execution context with sensible defaults
- */
-export declare function createExecutionContext(request?: ContextRequest): NeuroLinkExecutionContext;
-/**
- * Utility function to add tool to default context manager
- *
- * @param context Execution context
- * @param toolName Tool name to add
- */
-export declare function addToolToChain(context: NeuroLinkExecutionContext, toolName: string): void;
-/**
- * Context validation utilities
- */
-export declare class ContextValidator {
-    /**
-     * Validate context has required fields for tool execution
-     *
-     * @param context Execution context to validate
-     * @returns Validation result with details
-     */
-    static validateContext(context: NeuroLinkExecutionContext): {
-        isValid: boolean;
-        errors: string[];
-        warnings: string[];
-    };
-    /**
-     * Validate context permissions for tool execution
-     *
-     * @param context Execution context
-     * @param requiredPermissions Permissions required by tool
-     * @returns Whether context has required permissions
-     */
-    static hasPermissions(context: NeuroLinkExecutionContext, requiredPermissions: string[]): boolean;
-}

package/dist/mcp/context-manager.js

@@ -1,362 +0,0 @@
-/**
- * NeuroLink MCP Context Management System
- * Unified context creation and management for all tool executions
- * Ensures rich context flows through tool chain with session tracking
- */
-/**
- * Context manager for creating and managing execution contexts
- * Provides rich context for all tool executions with session tracking
- */
-export class ContextManager {
-    sessionCounter = 0;
-    activeContexts = new Map();
-    static cachedLogger = null;
-    /**
-     * Create a new execution context with rich information
-     *
-     * @param request Context creation request with optional fields
-     * @returns Complete execution context ready for tool chain
-     */
-    createContext(request = {}) {
-        // Generate session ID if not provided
-        const sessionId = request.sessionId || this.generateSessionId();
-        // Create comprehensive context
-        const context = {
-            // Session Management
-            sessionId,
-            userId: request.userId || "unknown-user",
-            // Required ExecutionContext properties
-            secureFS: {
-                readFile: async (path, encoding) => {
-                    const fs = await import("fs/promises");
-                    if (encoding) {
-                        return fs.readFile(path, { encoding: encoding });
-                    }
-                    else {
-                        return fs.readFile(path);
-                    }
-                },
-                writeFile: async (path, content) => {
-                    const fs = await import("fs/promises");
-                    return fs.writeFile(path, content);
-                },
-                readdir: async (path) => {
-                    const fs = await import("fs/promises");
-                    return fs.readdir(path);
-                },
-                stat: async (path) => {
-                    const fs = await import("fs/promises");
-                    return fs.stat(path);
-                },
-                mkdir: async (path, options) => {
-                    const fs = await import("fs/promises");
-                    await fs.mkdir(path, options);
-                },
-                exists: async (path) => {
-                    const fs = await import("fs/promises");
-                    try {
-                        await fs.access(path);
-                        return true;
-                    }
-                    catch {
-                        return false;
-                    }
-                },
-            },
-            path: {
-                join: (...paths) => {
-                    // Use dynamic require for synchronous path operations
-                    const path = require("path");
-                    return path.join(...paths);
-                },
-                resolve: (...paths) => {
-                    const path = require("path");
-                    return path.resolve(...paths);
-                },
-                relative: (from, to) => {
-                    const path = require("path");
-                    return path.relative(from, to);
-                },
-                dirname: (path) => {
-                    const pathModule = require("path");
-                    return pathModule.dirname(path);
-                },
-                basename: (path, ext) => {
-                    const pathModule = require("path");
-                    return pathModule.basename(path, ext);
-                },
-            },
-            grantedPermissions: request.permissions || [],
-            log: async (level, message, data) => {
-                // Use cached logger if available, otherwise import and cache
-                try {
-                    if (!ContextManager.cachedLogger) {
-                        ContextManager.cachedLogger = await import("../utils/logger.js").then(({ logger }) => logger);
-                    }
-                    ContextManager.cachedLogger[level](message, data);
-                }
-                catch {
-                    console[level === "debug" ? "log" : level](message, data);
-                }
-            },
-            // AI Provider Context (from existing NeuroLink)
-            aiProvider: request.aiProvider,
-            modelId: request.modelId,
-            temperature: request.temperature,
-            maxTokens: request.maxTokens,
-            // Business Context (new for MCP)
-            organizationId: request.organizationId,
-            projectId: request.projectId,
-            environmentType: request.environmentType || "development",
-            // Framework Context (new for MCP)
-            frameworkType: request.frameworkType,
-            // Tool Execution Context (initialized empty)
-            toolChain: [],
-            parentToolId: undefined,
-            // Security & Permissions
-            permissions: request.permissions || [],
-            securityLevel: request.securityLevel || "private",
-            // Copy any additional custom fields
-            ...this.extractCustomFields(request),
-        };
-        // Store context for session management
-        this.activeContexts.set(sessionId, context);
-        return context;
-    }
-    /**
-     * Add a tool to the execution chain
-     *
-     * @param context Execution context to modify
-     * @param toolName Name of the tool being executed
-     */
-    addToToolChain(context, toolName) {
-        if (!context.toolChain) {
-            context.toolChain = [];
-        }
-        context.toolChain.push(toolName);
-        // Update the active context
-        this.activeContexts.set(context.sessionId, context);
-    }
-    /**
-     * Get the current tool chain for a context
-     *
-     * @param context Execution context
-     * @returns Array of tool names in execution order
-     */
-    getToolChain(context) {
-        return context.toolChain || [];
-    }
-    /**
-     * Set parent tool for nested tool execution
-     *
-     * @param context Execution context to modify
-     * @param parentToolId ID of the parent tool
-     */
-    setParentTool(context, parentToolId) {
-        context.parentToolId = parentToolId;
-        this.activeContexts.set(context.sessionId, context);
-    }
-    /**
-     * Create child context for nested tool execution
-     *
-     * @param parentContext Parent execution context
-     * @param childToolName Name of the child tool
-     * @returns New child context with inherited properties
-     */
-    createChildContext(parentContext, childToolName) {
-        const childContext = {
-            // Inherit all parent context
-            ...parentContext,
-            // Create new session ID for child
-            sessionId: this.generateSessionId(),
-            // Set parent tool reference
-            parentToolId: parentContext.toolChain?.[parentContext.toolChain.length - 1],
-            // Reset tool chain for child (will be populated as child executes tools)
-            toolChain: [],
-        };
-        // Store child context
-        this.activeContexts.set(childContext.sessionId, childContext);
-        return childContext;
-    }
-    /**
-     * Get context by session ID
-     *
-     * @param sessionId Session identifier
-     * @returns Execution context or undefined if not found
-     */
-    getContext(sessionId) {
-        return this.activeContexts.get(sessionId);
-    }
-    /**
-     * Update context with new information
-     *
-     * @param sessionId Session identifier
-     * @param updates Partial context updates
-     */
-    updateContext(sessionId, updates) {
-        const context = this.activeContexts.get(sessionId);
-        if (context) {
-            const updatedContext = { ...context, ...updates };
-            this.activeContexts.set(sessionId, updatedContext);
-        }
-    }
-    /**
-     * Store context directly (used when session ID changes)
-     *
-     * @param context Complete execution context to store
-     */
-    storeContext(context) {
-        this.activeContexts.set(context.sessionId, context);
-    }
-    /**
-     * Remove context from active tracking
-     *
-     * @param sessionId Session identifier
-     */
-    removeContext(sessionId) {
-        this.activeContexts.delete(sessionId);
-    }
-    /**
-     * Get all active contexts (for debugging/monitoring)
-     *
-     * @returns Array of all active contexts
-     */
-    getActiveContexts() {
-        return Array.from(this.activeContexts.values());
-    }
-    /**
-     * Clear all active contexts
-     */
-    clearAllContexts() {
-        this.activeContexts.clear();
-        this.sessionCounter = 0;
-    }
-    /**
-     * Get context statistics
-     *
-     * @returns Context usage statistics
-     */
-    getStats() {
-        const contexts = Array.from(this.activeContexts.values());
-        const totalToolChainLength = contexts.reduce((sum, ctx) => sum + (ctx.toolChain?.length || 0), 0);
-        return {
-            activeContexts: contexts.length,
-            totalSessionsCreated: this.sessionCounter,
-            averageToolChainLength: contexts.length > 0 ? totalToolChainLength / contexts.length : 0,
-        };
-    }
-    /**
-     * Generate unique session ID
-     *
-     * @returns Unique session identifier
-     */
-    generateSessionId() {
-        this.sessionCounter++;
-        const timestamp = Date.now();
-        const random = Math.random().toString(36).substring(2, 8);
-        return `nlmcp-${timestamp}-${this.sessionCounter}-${random}`;
-    }
-    /**
-     * Extract custom fields from request (excluding known fields)
-     *
-     * @param request Context creation request
-     * @returns Custom fields object
-     */
-    extractCustomFields(request) {
-        const knownFields = new Set([
-            "sessionId",
-            "userId",
-            "aiProvider",
-            "modelId",
-            "temperature",
-            "maxTokens",
-            "organizationId",
-            "projectId",
-            "environmentType",
-            "frameworkType",
-            "permissions",
-            "securityLevel",
-        ]);
-        const customFields = {};
-        for (const [key, value] of Object.entries(request)) {
-            if (!knownFields.has(key)) {
-                customFields[key] = value;
-            }
-        }
-        return customFields;
-    }
-}
-/**
- * Default context manager instance
- * Can be used across the application for consistent context management
- */
-export const defaultContextManager = new ContextManager();
-/**
- * Utility function to create context with defaults
- *
- * @param request Optional context request
- * @returns Execution context with sensible defaults
- */
-export function createExecutionContext(request = {}) {
-    return defaultContextManager.createContext(request);
-}
-/**
- * Utility function to add tool to default context manager
- *
- * @param context Execution context
- * @param toolName Tool name to add
- */
-export function addToolToChain(context, toolName) {
-    defaultContextManager.addToToolChain(context, toolName);
-}
-/**
- * Context validation utilities
- */
-export class ContextValidator {
-    /**
-     * Validate context has required fields for tool execution
-     *
-     * @param context Execution context to validate
-     * @returns Validation result with details
-     */
-    static validateContext(context) {
-        const errors = [];
-        const warnings = [];
-        // Required field validation
-        if (!context.sessionId) {
-            errors.push("sessionId is required");
-        }
-        // Optional field validation with warnings
-        if (!context.environmentType) {
-            warnings.push("environmentType not specified, defaulting to development");
-        }
-        if (!context.securityLevel) {
-            warnings.push("securityLevel not specified, defaulting to private");
-        }
-        // Tool chain validation
-        if (context.toolChain && context.toolChain.length > 10) {
-            warnings.push("Tool chain is getting long (>10 tools), consider breaking into smaller workflows");
-        }
-        return {
-            isValid: errors.length === 0,
-            errors,
-            warnings,
-        };
-    }
-    /**
-     * Validate context permissions for tool execution
-     *
-     * @param context Execution context
-     * @param requiredPermissions Permissions required by tool
-     * @returns Whether context has required permissions
-     */
-    static hasPermissions(context, requiredPermissions) {
-        if (!requiredPermissions || requiredPermissions.length === 0) {
-            return true;
-        }
-        const contextPermissions = context.permissions || [];
-        // Check if context has all required permissions
-        return requiredPermissions.every((permission) => contextPermissions.includes(permission) ||
-            contextPermissions.includes("*"));
-    }
-}