@juspay/neurolink 6.0.0 → 6.2.0

package/dist/mcp/ecosystem.js

@@ -1,162 +0,0 @@
-/**
- * MCP Ecosystem Integration - Bridge Between Research Blueprint and NeuroLink
- * Provides unified interface for plugin management and execution
- */
-import { pluginManager, PluginManager } from "./plugin-manager.js";
-import { SecurityManager } from "./security-manager.js";
-import { MCP } from "./contracts/mcp-contract.js";
-import { mcpLogger } from "./logging.js";
-import { tool } from "ai";
-import { z } from "zod";
-/**
- * MCP Ecosystem - Main Interface for Plugin Operations
- */
-export class MCPEcosystem {
-    static instance;
-    securityManager;
-    initialized = false;
-    constructor() {
-        this.securityManager = new SecurityManager("moderate");
-    }
-    static getInstance() {
-        if (!MCPEcosystem.instance) {
-            MCPEcosystem.instance = new MCPEcosystem();
-        }
-        return MCPEcosystem.instance;
-    }
-    /**
-     * Initialize the MCP ecosystem
-     */
-    async initialize() {
-        if (this.initialized) {
-            return;
-        }
-        mcpLogger.info("[MCPEcosystem] Initializing MCP ecosystem...");
-        await pluginManager.initialize();
-        this.initialized = true;
-        const stats = pluginManager.getDiscoveryStats();
-        mcpLogger.info("[MCPEcosystem] MCP ecosystem initialized", stats);
-    }
-    /**
-     * List all available MCPs
-     */
-    async list() {
-        await this.ensureInitialized();
-        return pluginManager.listDiscovered();
-    }
-    /**
-     * Get metadata for a specific MCP
-     */
-    async getMetadata(name) {
-        await this.ensureInitialized();
-        return pluginManager.getMetadata(name);
-    }
-    /**
-     * Create and execute an MCP instance
-     */
-    async execute(name, config, args, context) {
-        await this.ensureInitialized();
-        const functionTag = "MCPEcosystem.execute";
-        try {
-            // Get MCP metadata for permissions
-            const metadata = await this.getMetadata(name);
-            if (!metadata) {
-                throw new Error(`MCP ${name} not found`);
-            }
-            // Create execution context
-            const executionContext = this.securityManager.createExecutionContext(context?.sessionId || `mcp-${Date.now()}`, context?.userId || "mcp-user", metadata.permissions, config?.basePath);
-            // Create MCP instance
-            const mcpInstance = await pluginManager.createInstance(name, config);
-            // Execute the MCP
-            mcpLogger.debug(`[${functionTag}] Executing ${name}`, { args });
-            const result = await mcpInstance.execute(executionContext, args);
-            mcpLogger.debug(`[${functionTag}] ${name} execution completed`, {
-                success: true,
-                resultType: typeof result,
-            });
-            return result;
-        }
-        catch (error) {
-            mcpLogger.error(`[${functionTag}] ${name} execution failed:`, error);
-            throw error;
-        }
-    }
-    /**
-     * Execute filesystem operations using FileSystemMCP
-     */
-    async filesystem(operation) {
-        return this.execute("@neurolink-mcp/filesystem", { basePath: operation.basePath || process.cwd() }, {
-            operation: operation.action,
-            path: operation.path,
-            content: operation.content,
-        });
-    }
-    /**
-     * Get ecosystem statistics
-     */
-    async getStats() {
-        const available = await this.list();
-        return {
-            initialized: this.initialized,
-            pluginsDiscovered: available.length,
-            pluginsBySource: pluginManager.getDiscoveryStats(),
-            availablePlugins: available.map((p) => p.name),
-        };
-    }
-    /**
-     * Create an MCP instance for direct use
-     */
-    async createInstance(name, config) {
-        await this.ensureInitialized();
-        const metadata = await this.getMetadata(name);
-        if (!metadata) {
-            throw new Error(`MCP ${name} not found`);
-        }
-        return pluginManager.createInstance(name, config);
-    }
-    /**
-     * Create execution context for manual MCP usage
-     */
-    createExecutionContext(sessionId, userId, permissions, basePath) {
-        return this.securityManager.createExecutionContext(sessionId, userId, permissions, basePath);
-    }
-    /**
-     * Ensure ecosystem is initialized
-     */
-    async ensureInitialized() {
-        if (!this.initialized) {
-            await this.initialize();
-        }
-    }
-    /**
-     * Get all tools formatted for AI providers
-     */
-    async getToolsForAI() {
-        await this.ensureInitialized();
-        const plugins = await this.list();
-        const tools = {};
-        for (const plugin of plugins) {
-            // This is a simplified representation. A real implementation
-            // would parse the plugin's metadata to get tool definitions.
-            if (plugin.name.includes("filesystem")) {
-                tools["filesystem_list"] = tool({
-                    description: "List files in a directory",
-                    parameters: z.object({
-                        path: z.string().describe("The path to list files from"),
-                    }),
-                    execute: async ({ path }) => this.filesystem({ action: "listFiles", path }),
-                });
-            }
-        }
-        return tools;
-    }
-    /**
-     * Dispose of all resources
-     */
-    async dispose() {
-        await pluginManager.dispose();
-        this.initialized = false;
-    }
-}
-// Export singleton instance
-export const mcpEcosystem = MCPEcosystem.getInstance();

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

@@ -1,254 +0,0 @@
-/**
- * NeuroLink MCP Enhanced Error Handling System
- * Provides comprehensive error tracking, categorization, and debugging capabilities
- * Based on error accumulation patterns from Cline
- */
-import type { NeuroLinkExecutionContext } from "./factory.js";
-/**
- * Error categories for classification
- */
-export declare enum ErrorCategory {
-    TOOL_ERROR = "TOOL_ERROR",
-    NETWORK_ERROR = "NETWORK_ERROR",
-    VALIDATION_ERROR = "VALIDATION_ERROR",
-    TIMEOUT_ERROR = "TIMEOUT_ERROR",
-    PERMISSION_ERROR = "PERMISSION_ERROR",
-    CONFIGURATION_ERROR = "CONFIGURATION_ERROR",
-    CONNECTION_ERROR = "CONNECTION_ERROR",
-    UNKNOWN_ERROR = "UNKNOWN_ERROR"
-}
-/**
- * Error severity levels
- */
-export declare enum ErrorSeverity {
-    LOW = "LOW",
-    MEDIUM = "MEDIUM",
-    HIGH = "HIGH",
-    CRITICAL = "CRITICAL"
-}
-/**
- * Enhanced error entry with rich context
- */
-export interface ErrorEntry {
-    id: string;
-    timestamp: number;
-    category: ErrorCategory;
-    severity: ErrorSeverity;
-    error: Error;
-    context: {
-        sessionId?: string;
-        toolName?: string;
-        parameters?: unknown;
-        executionContext?: NeuroLinkExecutionContext;
-    };
-    stackTrace?: string;
-    recovery?: {
-        attempted: boolean;
-        successful?: boolean;
-        recovered?: boolean;
-        fallbackUsed?: boolean;
-        nextAction?: string;
-        delay?: number;
-        suggestion?: string;
-    };
-}
-/**
- * Error statistics
- */
-export interface ErrorStats {
-    totalErrors: number;
-    errorsByCategory: Record<ErrorCategory, number>;
-    errorsBySeverity: Record<ErrorSeverity, number>;
-    errorRate: number;
-    lastError?: ErrorEntry;
-    mostFrequentError?: {
-        message: string;
-        count: number;
-        category: ErrorCategory;
-    };
-}
-/**
- * Options for error manager configuration
- */
-export interface ErrorManagerOptions {
-    maxHistorySize?: number;
-    enableStackTrace?: boolean;
-    autoRecovery?: boolean;
-    errorRateWindow?: number;
-}
-/**
- * Enhanced Error Manager with accumulation and analysis capabilities
- */
-export declare class ErrorManager {
-    private errorHistory;
-    private maxHistorySize;
-    private enableStackTrace;
-    private autoRecovery;
-    private errorRateWindow;
-    private errorCounter;
-    private errorFrequency;
-    private categoryCounts;
-    private severityCounts;
-    private errorRecovery;
-    constructor(options?: ErrorManagerOptions);
-    /**
-     * Record an error with context
-     *
-     * @param error The error to record
-     * @param context Additional context about the error
-     * @returns The created error entry
-     */
-    recordError(error: Error | unknown, context?: {
-        category?: ErrorCategory;
-        severity?: ErrorSeverity;
-        sessionId?: string;
-        toolName?: string;
-        parameters?: unknown;
-        executionContext?: NeuroLinkExecutionContext;
-    }): Promise<ErrorEntry>;
-    /**
-     * Get error history
-     *
-     * @param filter Optional filter criteria
-     * @returns Filtered error history
-     */
-    getErrorHistory(filter?: {
-        category?: ErrorCategory;
-        severity?: ErrorSeverity;
-        sessionId?: string;
-        toolName?: string;
-        since?: number;
-        limit?: number;
-    }): ErrorEntry[];
-    /**
-     * Get error statistics
-     *
-     * @returns Current error statistics
-     */
-    getStats(): ErrorStats;
-    /**
-     * Clear error history
-     */
-    clearHistory(): void;
-    /**
-     * Get recovery suggestions for an error
-     *
-     * @param error The error entry
-     * @returns Recovery suggestion
-     */
-    getRecoverySuggestion(error: ErrorEntry): string;
-    /**
-     * Categorize error based on message and type
-     *
-     * @private
-     */
-    private categorizeError;
-    /**
-     * Determine error severity
-     *
-     * @private
-     */
-    private determineSeverity;
-    /**
-     * Add error to circular buffer
-     *
-     * @private
-     */
-    private addToHistory;
-    /**
-     * Update error statistics
-     *
-     * @private
-     */
-    private updateStatistics;
-    /**
-     * Attempt automatic recovery
-     *
-     * @private
-     */
-    private attemptRecovery;
-    /**
-     * Generate unique error ID
-     *
-     * @private
-     */
-    private generateErrorId;
-    /**
-     * Detect error patterns in recent history
-     *
-     * @param timeWindow Time window to analyze (ms)
-     * @returns Detected patterns with counts and severity
-     */
-    detectPatterns(timeWindow?: number): {
-        patterns: Array<{
-            pattern: string;
-            count: number;
-            errors: ErrorEntry[];
-            severity: ErrorSeverity;
-            recommendation: string;
-        }>;
-        correlations: Array<{
-            error1: string;
-            error2: string;
-            correlation: number;
-        }>;
-    };
-    /**
-     * Detect correlations between errors
-     *
-     * @private
-     */
-    private detectCorrelations;
-    /**
-     * Get error trends over time
-     *
-     * @param bucketSize Time bucket size in ms (default: 1 minute)
-     * @param timeWindow Total time window to analyze
-     * @returns Error counts per time bucket
-     */
-    getErrorTrends(bucketSize?: number, timeWindow?: number): Array<{
-        timestamp: number;
-        count: number;
-        categories: Record<ErrorCategory, number>;
-    }>;
-    /**
-     * Get recovery statistics
-     *
-     * @returns Recovery statistics from error recovery system
-     */
-    getRecoveryStats(): {
-        totalAttempts: number;
-        successfulRecoveries: number;
-        failedRecoveries: number;
-        circuitBreakerStates: Record<string, import("./error-recovery.js").CircuitState>;
-        patternMatches: Record<string, number>;
-    };
-    /**
-     * Reset circuit breaker for specific resource
-     *
-     * @param resourceId Resource identifier (usually tool name)
-     */
-    resetCircuitBreaker(resourceId: string): void;
-    /**
-     * Get error insights and recommendations
-     *
-     * @returns Insights based on error analysis
-     */
-    getInsights(): {
-        criticalIssues: string[];
-        recommendations: string[];
-        healthScore: number;
-    };
-}
-/**
- * Default error manager instance
- */
-export declare const defaultErrorManager: ErrorManager;
-/**
- * Utility function to record error with default manager
- *
- * @param error Error to record
- * @param context Error context
- * @returns Error entry
- */
-export declare function recordError(error: Error | unknown, context?: Parameters<ErrorManager["recordError"]>[1]): Promise<ErrorEntry>;