@juspay/neurolink 6.1.0 → 6.2.1

package/dist/lib/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("*"));
-    }
-}

package/dist/lib/mcp/contracts/mcp-contract.d.ts

@@ -1,169 +0,0 @@
-/**
- * MCP Abstract Contract - The Foundation of NeuroLink's Plugin Ecosystem
- * Based on research blueprint for extensible MCP architecture
- */
-import type { ZodSchema } from "zod";
-/**
- * Metadata structure for MCP plugins following manifest-based discovery
- */
-export interface MCPMetadata {
-    /** Unique NPM-style package name */
-    name: string;
-    /** Semantic version */
-    version: string;
-    /** Entry point path */
-    main: string;
-    /** Compatible NeuroLink version range */
-    engine: {
-        neurolink: string;
-    };
-    /** Human-readable description */
-    description: string;
-    /** Declarative permissions array for security */
-    permissions: string[];
-    /** JSON Schema for configuration validation */
-    configSchema?: ZodSchema | object;
-}
-/**
- * Execution Context - Security Sandbox for MCP Operations
- * Provides sandboxed access to system resources with permission checking
- */
-export interface ExecutionContext {
-    /** Session identifier for tracking */
-    sessionId: string;
-    /** User identifier for permissions */
-    userId: string;
-    /** Sandboxed filesystem operations */
-    secureFS: {
-        readFile: (path: string, encoding?: string) => Promise<string | Buffer>;
-        writeFile: (path: string, content: string | Buffer) => Promise<void>;
-        readdir: (path: string) => Promise<string[]>;
-        stat: (path: string) => Promise<{
-            size: number;
-            isFile: () => boolean;
-            isDirectory: () => boolean;
-        }>;
-        mkdir: (path: string, options?: {
-            recursive?: boolean;
-        }) => Promise<void>;
-        exists: (path: string) => Promise<boolean>;
-    };
-    /** Sandboxed path operations */
-    path: {
-        join: (...paths: string[]) => string;
-        resolve: (...paths: string[]) => string;
-        relative: (from: string, to: string) => string;
-        dirname: (path: string) => string;
-        basename: (path: string, ext?: string) => string;
-    };
-    /** Sandboxed network operations (future) */
-    secureNet?: {
-        fetch: (url: string, options?: RequestInit) => Promise<Response>;
-    };
-    /** Plugin-specific permissions granted */
-    grantedPermissions: string[];
-    /** Log function for debugging */
-    log: (level: "debug" | "info" | "warn" | "error", message: string, data?: unknown) => void;
-    /** Plugin instance reference (for plugin bridge compatibility) */
-    plugin?: unknown;
-}
-/**
- * MCP Abstract Class - The Core Contract for All Plugins
- * Uses TypeScript generics for type-safe configuration
- */
-export declare abstract class MCP<TConfig = unknown, TArgs = unknown, TResult = unknown> {
-    /** Static metadata loaded from manifest */
-    abstract readonly metadata: MCPMetadata;
-    /** Configuration state - accessible to child classes */
-    config?: TConfig;
-    /** Initialization flag */
-    protected initialized: boolean;
-    /**
-     * Initialize the MCP with user-provided configuration
-     * @param config - Plugin-specific configuration object
-     */
-    abstract initialize(config: TConfig): Promise<void>;
-    /**
-     * Execute the MCP's primary functionality
-     * @param context - Sandboxed execution context
-     * @param args - Operation-specific arguments
-     * @returns Plugin-specific result
-     */
-    abstract execute(context: ExecutionContext, args: TArgs): Promise<TResult>;
-    /**
-     * Graceful shutdown and resource cleanup
-     */
-    abstract dispose(): Promise<void>;
-    /**
-     * Get the current configuration
-     */
-    getConfig(): TConfig | undefined;
-    /**
-     * Check if the MCP is initialized
-     */
-    isInitialized(): boolean;
-    /**
-     * Get plugin metadata
-     */
-    getMetadata(): MCPMetadata;
-    /**
-     * Validate that the MCP is ready for execution
-     */
-    protected ensureInitialized(): void;
-    /**
-     * Helper method for logging with context
-     */
-    protected log(context: ExecutionContext, level: "debug" | "info" | "warn" | "error", message: string, data?: unknown): void;
-}
-/**
- * Type definitions for plugin registry
- */
-export type MCPConstructor<T extends MCP = MCP> = new () => T;
-export type MCPInstance<T extends MCP = MCP> = T;
-/**
- * Plugin discovery result
- */
-export interface DiscoveredMCP {
-    metadata: MCPMetadata;
-    entryPath: string;
-    source: "core" | "project" | "installed";
-    constructor?: MCPConstructor;
-    [key: string]: unknown;
-}
-/**
- * Plugin load result
- */
-export interface PluginLoadResult {
-    success: boolean;
-    plugin?: MCP;
-    error?: string;
-}
-/**
- * Plugin discovery result
- */
-export interface PluginDiscoveryResult {
-    total: number;
-    loaded: number;
-    failed: number;
-    plugins: DiscoveredMCP[];
-}
-/**
- * Plugin execution result
- */
-export interface PluginExecutionResult<T = unknown> {
-    success: boolean;
-    result?: T;
-    error?: string;
-    executionTime?: number;
-}
-/**
- * MCP Category for organization
- */
-export declare enum MCPCategory {
-    FILESYSTEM = "filesystem",
-    NETWORK = "network",
-    DATABASE = "database",
-    AI = "ai",
-    UTILITY = "utility",
-    INTEGRATION = "integration"
-}

package/dist/lib/mcp/contracts/mcp-contract.js

@@ -1,58 +0,0 @@
-/**
- * MCP Abstract Contract - The Foundation of NeuroLink's Plugin Ecosystem
- * Based on research blueprint for extensible MCP architecture
- */
-/**
- * MCP Abstract Class - The Core Contract for All Plugins
- * Uses TypeScript generics for type-safe configuration
- */
-export class MCP {
-    /** Configuration state - accessible to child classes */
-    config;
-    /** Initialization flag */
-    initialized = false;
-    /**
-     * Get the current configuration
-     */
-    getConfig() {
-        return this.config;
-    }
-    /**
-     * Check if the MCP is initialized
-     */
-    isInitialized() {
-        return this.initialized;
-    }
-    /**
-     * Get plugin metadata
-     */
-    getMetadata() {
-        return this.metadata;
-    }
-    /**
-     * Validate that the MCP is ready for execution
-     */
-    ensureInitialized() {
-        if (!this.initialized) {
-            throw new Error(`MCP ${this.metadata.name} is not initialized. Call initialize() first.`);
-        }
-    }
-    /**
-     * Helper method for logging with context
-     */
-    log(context, level, message, data) {
-        context.log(level, `[${this.metadata.name}] ${message}`, data);
-    }
-}
-/**
- * MCP Category for organization
- */
-export var MCPCategory;
-(function (MCPCategory) {
-    MCPCategory["FILESYSTEM"] = "filesystem";
-    MCPCategory["NETWORK"] = "network";
-    MCPCategory["DATABASE"] = "database";
-    MCPCategory["AI"] = "ai";
-    MCPCategory["UTILITY"] = "utility";
-    MCPCategory["INTEGRATION"] = "integration";
-})(MCPCategory || (MCPCategory = {}));

package/dist/lib/mcp/core/plugin-manager.d.ts

@@ -1,46 +0,0 @@
-/**
- * Core Plugin Manager
- * Enhanced plugin management with advanced lifecycle control
- */
-import type { MCP, MCPMetadata, MCPConstructor, PluginLoadResult, PluginExecutionResult, ExecutionContext } from "../contracts/mcp-contract.js";
-import type { UnknownRecord, Unknown } from "../../types/common.js";
-/**
- * Enhanced plugin manager with core functionality
- */
-export declare class CorePluginManager {
-    private plugins;
-    private constructors;
-    private metadata;
-    /**
-     * Load a plugin from constructor
-     */
-    loadPlugin(name: string, Constructor: MCPConstructor, config: UnknownRecord): Promise<PluginLoadResult>;
-    /**
-     * Execute a plugin operation
-     */
-    executePlugin<T = Unknown>(name: string, context: ExecutionContext, args: Unknown): Promise<PluginExecutionResult<T>>;
-    /**
-     * Get plugin instance
-     */
-    getPlugin(name: string): MCP | undefined;
-    /**
-     * Get plugin metadata
-     */
-    getPluginMetadata(name: string): MCPMetadata | undefined;
-    /**
-     * List all loaded plugins
-     */
-    listPlugins(): string[];
-    /**
-     * Unload a plugin
-     */
-    unloadPlugin(name: string): Promise<void>;
-    /**
-     * Dispose all plugins
-     */
-    dispose(): Promise<void>;
-}
-/**
- * Default core plugin manager instance
- */
-export declare const corePluginManager: CorePluginManager;