@juspay/neurolink 6.1.0 → 6.2.1

package/dist/lib/mcp/core/plugin-manager.js

@@ -1,110 +0,0 @@
-/**
- * Core Plugin Manager
- * Enhanced plugin management with advanced lifecycle control
- */
-import { mcpLogger } from "../logging.js";
-/**
- * Enhanced plugin manager with core functionality
- */
-export class CorePluginManager {
-    plugins = new Map();
-    constructors = new Map();
-    metadata = new Map();
-    /**
-     * Load a plugin from constructor
-     */
-    async loadPlugin(name, Constructor, config) {
-        try {
-            const instance = new Constructor();
-            await instance.initialize(config);
-            this.plugins.set(name, instance);
-            this.constructors.set(name, Constructor);
-            this.metadata.set(name, instance.getMetadata());
-            mcpLogger.info(`[CorePluginManager] Loaded plugin: ${name}`);
-            return {
-                success: true,
-                plugin: instance,
-            };
-        }
-        catch (error) {
-            mcpLogger.error(`[CorePluginManager] Failed to load plugin ${name}:`, error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    /**
-     * Execute a plugin operation
-     */
-    async executePlugin(name, context, args) {
-        const startTime = Date.now();
-        try {
-            const plugin = this.plugins.get(name);
-            if (!plugin) {
-                throw new Error(`Plugin ${name} not loaded`);
-            }
-            const result = await plugin.execute(context, args);
-            const executionTime = Date.now() - startTime;
-            return {
-                success: true,
-                result: result,
-                executionTime,
-            };
-        }
-        catch (error) {
-            const executionTime = Date.now() - startTime;
-            mcpLogger.error(`[CorePluginManager] Plugin execution failed for ${name}:`, error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                executionTime,
-            };
-        }
-    }
-    /**
-     * Get plugin instance
-     */
-    getPlugin(name) {
-        return this.plugins.get(name);
-    }
-    /**
-     * Get plugin metadata
-     */
-    getPluginMetadata(name) {
-        return this.metadata.get(name);
-    }
-    /**
-     * List all loaded plugins
-     */
-    listPlugins() {
-        return Array.from(this.plugins.keys());
-    }
-    /**
-     * Unload a plugin
-     */
-    async unloadPlugin(name) {
-        const plugin = this.plugins.get(name);
-        if (plugin) {
-            await plugin.dispose();
-            this.plugins.delete(name);
-            this.constructors.delete(name);
-            this.metadata.delete(name);
-            mcpLogger.info(`[CorePluginManager] Unloaded plugin: ${name}`);
-        }
-    }
-    /**
-     * Dispose all plugins
-     */
-    async dispose() {
-        const pluginNames = Array.from(this.plugins.keys());
-        for (const name of pluginNames) {
-            await this.unloadPlugin(name);
-        }
-        mcpLogger.info("[CorePluginManager] All plugins disposed");
-    }
-}
-/**
- * Default core plugin manager instance
- */
-export const corePluginManager = new CorePluginManager();

package/dist/lib/mcp/demo/plugin-demo.d.ts

@@ -1,20 +0,0 @@
-/**
- * Plugin Demo - Example MCP Plugin Usage
- */
-/**
- * Demo plugin functionality
- */
-export declare class PluginDemo {
-    /**
-     * Demonstrate filesystem plugin
-     */
-    static demonstrateFileSystem(): Promise<void>;
-    /**
-     * Demonstrate plugin execution via ecosystem
-     */
-    static demonstrateEcosystem(): Promise<void>;
-    /**
-     * Demonstrate quick plugin factory
-     */
-    static demonstrateQuickFactory(): Promise<void>;
-}

package/dist/lib/mcp/demo/plugin-demo.js

@@ -1,118 +0,0 @@
-/**
- * Plugin Demo - Example MCP Plugin Usage
- */
-import { mcpEcosystem } from "../ecosystem.js";
-import { FileSystemMCP } from "../plugins/core/filesystem-mcp.js";
-import { QuickPluginFactory, executePlugin, } from "../adapters/plugin-bridge.js";
-import { mcpLogger } from "../logging.js";
-/**
- * Demo plugin functionality
- */
-export class PluginDemo {
-    /**
-     * Demonstrate filesystem plugin
-     */
-    static async demonstrateFileSystem() {
-        try {
-            // Create filesystem plugin instance
-            const fsPlugin = new FileSystemMCP();
-            await fsPlugin.initialize({ basePath: process.cwd() });
-            mcpLogger.info("FileSystem plugin demonstration started");
-            // This would normally be done through the ecosystem
-            // but we're demonstrating direct usage
-            const result = await mcpEcosystem.filesystem({
-                action: "listFiles",
-                path: ".",
-                basePath: process.cwd(),
-            });
-            mcpLogger.info("File listing result:", result);
-        }
-        catch (error) {
-            mcpLogger.error("Demo failed:", error);
-        }
-    }
-    /**
-     * Demonstrate plugin execution via ecosystem
-     */
-    static async demonstrateEcosystem() {
-        try {
-            await mcpEcosystem.initialize();
-            const stats = await mcpEcosystem.getStats();
-            mcpLogger.info("MCP Ecosystem stats:", stats);
-            // Try to read a file
-            const fsPlugin = new FileSystemMCP();
-            await fsPlugin.initialize({ basePath: process.cwd() });
-            // Cast FileSystemMCP to UnknownRecord for executePlugin compatibility
-            const pluginAsRecord = fsPlugin;
-            const result = await executePlugin(pluginAsRecord, createMockContext(), "listFiles", ".");
-            mcpLogger.info("Plugin execution result:", result);
-        }
-        catch (error) {
-            mcpLogger.error("Ecosystem demo failed:", error);
-        }
-    }
-    /**
-     * Demonstrate quick plugin factory
-     */
-    static async demonstrateQuickFactory() {
-        try {
-            const fsPlugin = new FileSystemMCP();
-            await fsPlugin.initialize({ basePath: process.cwd() });
-            const quickPlugin = await QuickPluginFactory.create("demo-plugin", {
-                basePath: process.cwd(),
-            });
-            mcpLogger.info("Quick plugin created:", quickPlugin);
-        }
-        catch (error) {
-            mcpLogger.error("Quick factory demo failed:", error);
-        }
-    }
-}
-/**
- * Create a mock execution context for testing
- */
-function createMockContext() {
-    return {
-        sessionId: "demo-session",
-        userId: "demo-user",
-        grantedPermissions: ["fs:read:./**/*", "fs:write:./temp/**/*"],
-        secureFS: {
-            async readFile(path, encoding) {
-                return `Mock content from ${path}`;
-            },
-            async writeFile(path, content) {
-                mcpLogger.info(`Mock write to ${path}`);
-            },
-            async readdir(path) {
-                return ["file1.txt", "file2.json", "subdir"];
-            },
-            async stat(path) {
-                return {
-                    size: 1024,
-                    mtime: new Date(),
-                    isDirectory: () => false,
-                    isFile: () => true,
-                };
-            },
-            async mkdir(path, options) {
-                mcpLogger.info(`Mock mkdir: ${path}`);
-            },
-            async exists(path) {
-                return true;
-            },
-        },
-        path: {
-            join: (...paths) => paths.join("/"),
-            resolve: (...paths) => "/" + paths.join("/"),
-            relative: (from, to) => to,
-            dirname: (path) => path.split("/").slice(0, -1).join("/"),
-            basename: (path, ext) => {
-                const name = path.split("/").pop() || "";
-                return ext ? name.replace(ext, "") : name;
-            },
-        },
-        log: (level, message, data) => {
-            mcpLogger[level](`[MockContext] ${message}`, data);
-        },
-    };
-}

package/dist/lib/mcp/dynamic-chain-executor.d.ts

@@ -1,225 +0,0 @@
-/**
- * Dynamic AI Tool Chain Executor
- * Allows AI to dynamically decide tool execution sequences based on context and results
- */
-import type { MCPOrchestrator } from "./orchestrator.js";
-import type { MCPRegistry } from "./registry.js";
-import type { NeuroLinkExecutionContext } from "./factory.js";
-import type { JsonValue, UnknownRecord } from "../types/common.js";
-import { ErrorManager } from "./error-manager.js";
-/**
- * Tool input schema structure
- */
-export interface ToolInputSchema {
-    type?: string;
-    properties?: Record<string, unknown>;
-    required?: string[];
-    [key: string]: unknown;
-}
-/**
- * Tool execution parameters
- */
-export interface ToolExecutionParameters extends Record<string, JsonValue> {
-}
-/**
- * Context evolution entry tracking data changes
- */
-export interface ContextEvolutionEntry {
-    step: string;
-    timestamp: number;
-    dataKeys: string[];
-    [key: string]: JsonValue;
-}
-/**
- * AI model planning response structure
- */
-export interface AIPlanningResponse {
-    toolName: string | null;
-    parameters?: ToolExecutionParameters;
-    reasoning?: string;
-    confidence?: number;
-    expectedOutcome?: string;
-}
-/**
- * AI model evaluation response structure
- */
-export interface AIEvaluationResponse {
-    goalAchieved: boolean;
-    confidence: number;
-    nextAction: "continue" | "retry" | "abort" | "complete";
-    reasoning: string;
-}
-/**
- * Available tool descriptor
- */
-export interface AvailableToolDescriptor {
-    name: string;
-    description: string;
-    inputSchema: ToolInputSchema;
-}
-/**
- * Tool execution result with metadata
- */
-export interface ToolExecutionResult {
-    toolName: string;
-    success: boolean;
-    result?: JsonValue;
-    error?: Error;
-    timestamp: number;
-    executionTime: number;
-    context?: UnknownRecord;
-}
-/**
- * Chain execution step
- */
-export interface ChainStep {
-    stepId: string;
-    toolName: string;
-    parameters: ToolExecutionParameters;
-    reasoning: string;
-    confidence: number;
-    expectedOutcome: string;
-}
-/**
- * Chain execution context
- */
-export interface ChainExecutionContext {
-    goal: string;
-    currentStep: number;
-    totalSteps?: number;
-    executionHistory: ToolExecutionResult[];
-    accumulatedContext: UnknownRecord;
-    userContext?: NeuroLinkExecutionContext;
-    maxSteps: number;
-    aiModel?: string;
-}
-/**
- * Chain execution result
- */
-export interface ChainExecutionResult {
-    success: boolean;
-    goal: string;
-    totalSteps: number;
-    executionTime: number;
-    results: ToolExecutionResult[];
-    finalResult?: JsonValue;
-    reasoning: string;
-    error?: Error;
-    metadata: {
-        toolsUsed: string[];
-        averageConfidence: number;
-        contextEvolution: ContextEvolutionEntry[];
-    };
-}
-/**
- * AI Tool Chain Planner interface
- */
-export interface AIChainPlanner {
-    name: string;
-    planNextStep(goal: string, availableTools: AvailableToolDescriptor[], executionHistory: ToolExecutionResult[], accumulatedContext: UnknownRecord): Promise<ChainStep | null>;
-    evaluateResult(step: ChainStep, result: ToolExecutionResult, goal: string): Promise<AIEvaluationResponse>;
-}
-/**
- * Simple AI Chain Planner using heuristics
- */
-export declare class HeuristicChainPlanner implements AIChainPlanner {
-    name: string;
-    planNextStep(goal: string, availableTools: AvailableToolDescriptor[], executionHistory: ToolExecutionResult[], accumulatedContext: UnknownRecord): Promise<ChainStep | null>;
-    evaluateResult(step: ChainStep, result: ToolExecutionResult, goal: string): Promise<AIEvaluationResponse>;
-    private generateParameters;
-}
-/**
- * Advanced AI Chain Planner using actual AI model
- */
-export declare class AIModelChainPlanner implements AIChainPlanner {
-    name: string;
-    private aiModel;
-    constructor(aiModel?: string);
-    planNextStep(goal: string, availableTools: AvailableToolDescriptor[], executionHistory: ToolExecutionResult[], accumulatedContext: UnknownRecord): Promise<ChainStep | null>;
-    evaluateResult(step: ChainStep, result: ToolExecutionResult, goal: string): Promise<AIEvaluationResponse>;
-    private buildPlanningPrompt;
-    private buildEvaluationPrompt;
-    private callAIModel;
-    private parseAIResponse;
-    private parseEvaluationResponse;
-}
-/**
- * Dynamic Chain Executor
- */
-export declare class DynamicChainExecutor {
-    private orchestrator;
-    private registry;
-    private errorManager;
-    private planner;
-    constructor(orchestrator: MCPOrchestrator, registry: MCPRegistry, errorManager: ErrorManager, planner?: AIChainPlanner);
-    /**
-     * Execute dynamic tool chain to achieve a goal
-     *
-     * @param goal The goal to achieve
-     * @param initialContext Initial context data
-     * @param userContext User execution context
-     * @param options Execution options
-     * @returns Chain execution result
-     */
-    executeChain(goal: string, initialContext?: UnknownRecord, userContext?: NeuroLinkExecutionContext, options?: {
-        maxSteps?: number;
-        aiModel?: string;
-        timeout?: number;
-    }): Promise<ChainExecutionResult>;
-    /**
-     * Execute chain steps iteratively
-     *
-     * @private
-     */
-    private executeChainSteps;
-    /**
-     * Execute a single step
-     *
-     * @private
-     */
-    private executeStep;
-    /**
-     * Update accumulated context with new result
-     *
-     * @private
-     */
-    private updateAccumulatedContext;
-    /**
-     * Calculate average confidence across execution history
-     *
-     * @private
-     */
-    private calculateAverageConfidence;
-    /**
-     * Track context evolution through execution
-     *
-     * @private
-     */
-    private trackContextEvolution;
-    /**
-     * Set AI planner
-     *
-     * @param planner AI chain planner instance
-     */
-    setPlanner(planner: AIChainPlanner): void;
-    /**
-     * Get current planner
-     *
-     * @returns Current AI chain planner
-     */
-    getPlanner(): AIChainPlanner;
-}
-/**
- * Default dynamic chain executor instance
- */
-export declare let defaultDynamicChainExecutor: DynamicChainExecutor | null;
-/**
- * Initialize default dynamic chain executor
- *
- * @param orchestrator MCP orchestrator
- * @param registry Tool registry
- * @param errorManager Error manager
- * @param planner Optional AI planner
- * @returns Dynamic chain executor instance
- */
-export declare function initializeDynamicChainExecutor(orchestrator: MCPOrchestrator, registry: MCPRegistry, errorManager: ErrorManager, planner?: AIChainPlanner): DynamicChainExecutor;