@identikey/coding-mcp 2.0.1

package/build/core/CommandDispatcher.js

@@ -0,0 +1,242 @@
+/**
+ * Command Dispatcher - Replaces the monolithic switch statement
+ * Routes MCP requests to appropriate tool commands with structured error handling
+ */
+import { ToolNotFoundError, ToolValidationError, ToolExecutionError, ToolTimeoutError, ToolError } from './ToolCommand.js';
+import { eventBus } from '../infra/eventBus.js';
+import { ZodError } from 'zod';
+export class CommandDispatcher {
+    registry;
+    eventBus;
+    config;
+    activeExecutions = new Map();
+    executionCounter = 0;
+    constructor(registry, eventBusInstance, config = {}) {
+        this.registry = registry;
+        this.eventBus = eventBusInstance || eventBus;
+        this.config = {
+            defaultTimeout: config.defaultTimeout || 30000, // 30 seconds
+            enableTracing: config.enableTracing ?? true,
+            maxConcurrentExecutions: config.maxConcurrentExecutions || 10
+        };
+    }
+    /**
+     * Dispatch an MCP tool request to the appropriate command
+     */
+    async dispatch(request) {
+        const { name: toolName, arguments: args } = request.params;
+        const requestId = this.generateRequestId();
+        const startTime = Date.now();
+        try {
+            // Check concurrent execution limit
+            if (this.activeExecutions.size >= this.config.maxConcurrentExecutions) {
+                throw new ToolError(`Maximum concurrent executions (${this.config.maxConcurrentExecutions}) reached`, 'RESOURCE_ERROR', toolName);
+            }
+            // Get the tool command
+            const tool = this.registry.get(toolName);
+            if (!tool) {
+                throw new ToolNotFoundError(toolName);
+            }
+            // Track active execution
+            this.activeExecutions.set(requestId, { toolName, startTime });
+            // Emit execution start event
+            this.eventBus.emit('tool:execute:start', {
+                name: toolName,
+                requestId,
+                args
+            });
+            // Execute the tool with timeout
+            const result = await this.executeWithTimeout(tool, args, requestId, startTime);
+            // Clean up active execution tracking
+            this.activeExecutions.delete(requestId);
+            // Emit execution end event
+            const executionTime = Date.now() - startTime;
+            this.eventBus.emit('tool:execute:end', {
+                name: toolName,
+                requestId,
+                success: result.success,
+                executionTime
+            });
+            // Return MCP-compatible response
+            if (result.success && result.result) {
+                return this.formatMCPResponse(result.result);
+            }
+            else {
+                throw result.error || new ToolExecutionError(toolName, 'Unknown execution error');
+            }
+        }
+        catch (error) {
+            // Clean up active execution tracking
+            this.activeExecutions.delete(requestId);
+            // Convert to ToolError if not already
+            const toolError = this.normalizeError(error, toolName);
+            // Emit error event
+            this.eventBus.emit('tool:error', {
+                name: toolName,
+                error: toolError,
+                requestId
+            });
+            // Emit execution end event with failure
+            const executionTime = Date.now() - startTime;
+            this.eventBus.emit('tool:execute:end', {
+                name: toolName,
+                requestId,
+                success: false,
+                executionTime
+            });
+            // Return error response in MCP format
+            return this.formatErrorResponse(toolError);
+        }
+    }
+    /**
+     * Execute a tool with timeout and validation
+     */
+    async executeWithTimeout(tool, args, requestId, startTime) {
+        try {
+            // Validate arguments using tool's schema
+            let validatedArgs;
+            try {
+                validatedArgs = tool.schema.parse(args);
+            }
+            catch (error) {
+                if (error instanceof ZodError) {
+                    throw new ToolValidationError(tool.name, `Invalid arguments: ${error.errors.map(e => `${e.path.join('.')}: ${e.message}`).join(', ')}`, error);
+                }
+                throw new ToolValidationError(tool.name, 'Failed to validate arguments', error);
+            }
+            // Create execution context
+            const context = {
+                eventBus: this.eventBus,
+                requestId,
+                startTime,
+                config: tool.metadata?.constraints
+            };
+            // Determine timeout (tool-specific or default)
+            const timeout = tool.metadata?.constraints?.maxExecutionTime || this.config.defaultTimeout;
+            // Execute with timeout
+            const result = await this.withTimeout(tool.execute(validatedArgs, context), timeout, tool.name);
+            return {
+                success: true,
+                result,
+                executionTime: Date.now() - startTime,
+                metadata: {
+                    toolName: tool.name,
+                    version: tool.version,
+                    requestId
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: this.normalizeError(error, tool.name),
+                executionTime: Date.now() - startTime,
+                metadata: {
+                    toolName: tool.name,
+                    version: tool.version,
+                    requestId
+                }
+            };
+        }
+    }
+    /**
+     * Execute a promise with timeout
+     */
+    async withTimeout(promise, timeoutMs, toolName) {
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new ToolTimeoutError(toolName, timeoutMs));
+            }, timeoutMs);
+        });
+        return Promise.race([promise, timeoutPromise]);
+    }
+    /**
+     * Normalize errors to ToolError instances
+     */
+    normalizeError(error, toolName) {
+        if (error instanceof ToolError) {
+            return error;
+        }
+        if (error instanceof Error) {
+            return new ToolExecutionError(toolName, error.message, error);
+        }
+        return new ToolExecutionError(toolName, String(error));
+    }
+    /**
+     * Format successful result as MCP response
+     */
+    formatMCPResponse(result) {
+        // If result is already in MCP format, return as-is
+        if (this.isMCPResponse(result)) {
+            return result;
+        }
+        // Convert to MCP format
+        return {
+            content: [{
+                    type: "text",
+                    text: typeof result === 'string' ? result : JSON.stringify(result, null, 2)
+                }]
+        };
+    }
+    /**
+     * Format error as MCP response
+     */
+    formatErrorResponse(error) {
+        const errorMessage = this.config.enableTracing
+            ? `${error.message}\n\nError Code: ${error.code}\nTool: ${error.toolName || 'unknown'}`
+            : error.message;
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error: ${errorMessage}`
+                }]
+        };
+    }
+    /**
+     * Check if result is already in MCP response format
+     */
+    isMCPResponse(result) {
+        return (typeof result === 'object' &&
+            result !== null &&
+            'content' in result &&
+            Array.isArray(result.content));
+    }
+    /**
+     * Generate unique request ID
+     */
+    generateRequestId() {
+        return `req_${Date.now()}_${++this.executionCounter}`;
+    }
+    /**
+     * Get active executions for monitoring
+     */
+    getActiveExecutions() {
+        return new Map(this.activeExecutions);
+    }
+    /**
+     * Get dispatcher statistics
+     */
+    getStats() {
+        // This would need execution history tracking for accurate stats
+        // For now, return basic info
+        return {
+            activeExecutions: this.activeExecutions.size,
+            totalExecutions: this.executionCounter,
+            averageExecutionTime: 0, // Would need history tracking
+            errorRate: 0 // Would need error tracking
+        };
+    }
+    /**
+     * Create dispatcher with default configuration
+     */
+    static create(registry, config) {
+        return new CommandDispatcher(registry, eventBus, config);
+    }
+}
+/**
+ * Create a simple dispatch function for MCP server integration
+ */
+export function createDispatchHandler(registry, config) {
+    const dispatcher = new CommandDispatcher(registry, eventBus, config);
+    return (request) => dispatcher.dispatch(request);
+}

package/build/core/ToolCommand.d.ts

@@ -0,0 +1,188 @@
+/**
+ * Core types and interfaces for the MCP Tool Command system
+ * Follows the Command pattern for pluggable tool architecture
+ */
+import { z } from "zod";
+import type { EventBus } from "../infra/eventBus.js";
+/**
+ * Context provided to each tool execution
+ */
+export interface CommandContext {
+    /** Event bus for inter-tool communication */
+    eventBus: EventBus;
+    /** Request metadata */
+    requestId?: string;
+    /** Tool execution start time */
+    startTime: number;
+    /** Tool-specific configuration */
+    config?: Record<string, any>;
+}
+/**
+ * Tool command interface - all MCP tools must implement this
+ */
+export interface ToolCommand<TArgs = any, TResult = any> {
+    /** Unique tool identifier */
+    readonly name: string;
+    /** Human-readable description */
+    readonly description: string;
+    /** Zod schema for argument validation */
+    readonly schema: z.ZodSchema<TArgs>;
+    /** Tool version (semantic versioning) */
+    readonly version?: string;
+    /** Tool metadata */
+    readonly metadata?: ToolMetadata;
+    /** Execute the tool with validated arguments */
+    execute(args: TArgs, context: CommandContext): Promise<TResult>;
+    /** Optional lifecycle hooks */
+    onLoad?(): void | Promise<void>;
+    onUnload?(): void | Promise<void>;
+    /** Health check for the tool */
+    healthCheck?(): Promise<ToolHealthStatus>;
+}
+/**
+ * Tool metadata for discovery and management
+ */
+export interface ToolMetadata {
+    /** Tool category */
+    category?: string;
+    /** Author information */
+    author?: string;
+    /** Tool tags for filtering */
+    tags?: string[];
+    /** Execution constraints */
+    constraints?: {
+        maxExecutionTime?: number;
+        maxMemory?: number;
+        requiresSandbox?: boolean;
+    };
+    /** Dependencies */
+    dependencies?: string[];
+    /** Configuration schema */
+    configSchema?: z.ZodSchema<any>;
+}
+/**
+ * Tool health status
+ */
+export interface ToolHealthStatus {
+    healthy: boolean;
+    message?: string;
+    lastChecked: number;
+    metrics?: {
+        executionCount?: number;
+        averageExecutionTime?: number;
+        errorRate?: number;
+    };
+}
+/**
+ * Tool registration info
+ */
+export interface ToolRegistration {
+    tool: ToolCommand;
+    registeredAt: number;
+    source: string;
+    enabled: boolean;
+}
+/**
+ * Tool execution result wrapper
+ */
+export interface ToolExecutionResult<T = any> {
+    success: boolean;
+    result?: T;
+    error?: ToolError;
+    executionTime: number;
+    metadata?: {
+        toolName: string;
+        version?: string;
+        requestId?: string;
+    };
+}
+/**
+ * Base class for tool errors
+ */
+export declare class ToolError extends Error {
+    readonly code: ToolErrorCode;
+    readonly toolName?: string | undefined;
+    readonly cause?: Error | undefined;
+    constructor(message: string, code: ToolErrorCode, toolName?: string | undefined, cause?: Error | undefined);
+}
+/**
+ * Specific error types
+ */
+export declare class ToolNotFoundError extends ToolError {
+    constructor(toolName: string);
+}
+export declare class DuplicateToolError extends ToolError {
+    constructor(toolName: string);
+}
+export declare class ToolValidationError extends ToolError {
+    constructor(toolName: string, validationMessage: string, cause?: Error);
+}
+export declare class ToolExecutionError extends ToolError {
+    constructor(toolName: string, executionMessage: string, cause?: Error);
+}
+export declare class ToolTimeoutError extends ToolError {
+    constructor(toolName: string, timeout: number);
+}
+/**
+ * Tool error codes
+ */
+export type ToolErrorCode = 'TOOL_NOT_FOUND' | 'DUPLICATE_TOOL' | 'VALIDATION_ERROR' | 'EXECUTION_ERROR' | 'TIMEOUT_ERROR' | 'SANDBOX_ERROR' | 'PERMISSION_ERROR' | 'RESOURCE_ERROR' | 'UNKNOWN_ERROR';
+/**
+ * Tool lifecycle states
+ */
+export declare enum ToolLifecycle {
+    LOADING = "loading",
+    READY = "ready",
+    ERROR = "error",
+    UNLOADING = "unloading",
+    DISPOSED = "disposed"
+}
+/**
+ * Event types for tool system
+ */
+export interface ToolEventMap {
+    'tool:registered': {
+        name: string;
+        version?: string;
+        source: string;
+    };
+    'tool:unregistered': {
+        name: string;
+        reason?: string;
+    };
+    'tool:execute:start': {
+        name: string;
+        requestId?: string;
+        args: any;
+    };
+    'tool:execute:end': {
+        name: string;
+        requestId?: string;
+        success: boolean;
+        executionTime: number;
+    };
+    'tool:error': {
+        name: string;
+        error: ToolError;
+        requestId?: string;
+    };
+    'tool:lifecycle': {
+        name: string;
+        state: ToolLifecycle;
+        metadata?: any;
+    };
+    'tool:health': {
+        name: string;
+        status: ToolHealthStatus;
+    };
+}
+/**
+ * Utility type for MCP tool responses
+ */
+export interface MCPToolResponse {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}
+//# sourceMappingURL=ToolCommand.d.ts.map

package/build/core/ToolCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolCommand.d.ts","sourceRoot":"","sources":["../../src/core/ToolCommand.ts"],"names":[],"mappings":"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"}

package/build/core/ToolCommand.js

@@ -0,0 +1,63 @@
+/**
+ * Core types and interfaces for the MCP Tool Command system
+ * Follows the Command pattern for pluggable tool architecture
+ */
+/**
+ * Base class for tool errors
+ */
+export class ToolError extends Error {
+    code;
+    toolName;
+    cause;
+    constructor(message, code, toolName, cause) {
+        super(message);
+        this.code = code;
+        this.toolName = toolName;
+        this.cause = cause;
+        this.name = 'ToolError';
+    }
+}
+/**
+ * Specific error types
+ */
+export class ToolNotFoundError extends ToolError {
+    constructor(toolName) {
+        super(`Tool '${toolName}' not found`, 'TOOL_NOT_FOUND', toolName);
+        this.name = 'ToolNotFoundError';
+    }
+}
+export class DuplicateToolError extends ToolError {
+    constructor(toolName) {
+        super(`Tool '${toolName}' is already registered`, 'DUPLICATE_TOOL', toolName);
+        this.name = 'DuplicateToolError';
+    }
+}
+export class ToolValidationError extends ToolError {
+    constructor(toolName, validationMessage, cause) {
+        super(`Validation failed for tool '${toolName}': ${validationMessage}`, 'VALIDATION_ERROR', toolName, cause);
+        this.name = 'ToolValidationError';
+    }
+}
+export class ToolExecutionError extends ToolError {
+    constructor(toolName, executionMessage, cause) {
+        super(`Execution failed for tool '${toolName}': ${executionMessage}`, 'EXECUTION_ERROR', toolName, cause);
+        this.name = 'ToolExecutionError';
+    }
+}
+export class ToolTimeoutError extends ToolError {
+    constructor(toolName, timeout) {
+        super(`Tool '${toolName}' execution timed out after ${timeout}ms`, 'TIMEOUT_ERROR', toolName);
+        this.name = 'ToolTimeoutError';
+    }
+}
+/**
+ * Tool lifecycle states
+ */
+export var ToolLifecycle;
+(function (ToolLifecycle) {
+    ToolLifecycle["LOADING"] = "loading";
+    ToolLifecycle["READY"] = "ready";
+    ToolLifecycle["ERROR"] = "error";
+    ToolLifecycle["UNLOADING"] = "unloading";
+    ToolLifecycle["DISPOSED"] = "disposed";
+})(ToolLifecycle || (ToolLifecycle = {}));

package/build/core/ToolRegistry.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Tool Registry - Central hub for managing MCP tool commands
+ * Implements the Command pattern with EventBus integration
+ */
+import { ToolCommand, ToolRegistration, ToolHealthStatus } from './ToolCommand.js';
+import { type EventBus } from '../infra/eventBus.js';
+export declare class ToolRegistry {
+    private tools;
+    private healthCache;
+    private readonly eventBus;
+    constructor(eventBusInstance?: EventBus);
+    /**
+     * Register a new tool command
+     */
+    register(tool: ToolCommand, source?: string): Promise<void>;
+    /**
+     * Unregister a tool command
+     */
+    unregister(name: string, reason?: string): Promise<boolean>;
+    /**
+     * Get a registered tool by name
+     */
+    get(name: string): ToolCommand | undefined;
+    /**
+     * Get tool registration info
+     */
+    getRegistration(name: string): ToolRegistration | undefined;
+    /**
+     * Check if a tool is registered
+     */
+    has(name: string): boolean;
+    /**
+     * List all registered tools
+     */
+    list(): ToolCommand[];
+    /**
+     * List all tool registrations (including disabled)
+     */
+    listRegistrations(): ToolRegistration[];
+    /**
+     * Get tool names only
+     */
+    getToolNames(): string[];
+    /**
+     * Get registry statistics
+     */
+    getStats(): {
+        totalTools: number;
+        enabledTools: number;
+        disabledTools: number;
+        categories: Record<string, number>;
+        sources: Record<string, number>;
+    };
+    /**
+     * Enable/disable a tool
+     */
+    setEnabled(name: string, enabled: boolean): boolean;
+    /**
+     * Check tool health
+     */
+    checkHealth(name: string, useCache?: boolean): Promise<ToolHealthStatus>;
+    /**
+     * Check health of all tools
+     */
+    checkAllHealth(): Promise<Record<string, ToolHealthStatus>>;
+    /**
+     * Clear all tools (for testing or shutdown)
+     */
+    clear(): Promise<void>;
+    /**
+     * Handle system shutdown
+     */
+    private handleShutdown;
+    /**
+     * Create a new registry instance (for testing)
+     */
+    static create(eventBusInstance?: EventBus): ToolRegistry;
+}
+export declare const toolRegistry: ToolRegistry;
+//# sourceMappingURL=ToolRegistry.d.ts.map

package/build/core/ToolRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolRegistry.d.ts","sourceRoot":"","sources":["../../src/core/ToolRegistry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,WAAW,EACX,gBAAgB,EAKhB,gBAAgB,EACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAE/D,qBAAa,YAAY;IACvB,OAAO,CAAC,KAAK,CAAuC;IACpD,OAAO,CAAC,WAAW,CAAuC;IAC1D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;gBAExB,gBAAgB,CAAC,EAAE,QAAQ;IAOvC;;OAEG;IACG,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,GAAE,MAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAiE5E;;OAEG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAqDjE;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAK1C;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAI3D;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B;;OAEG;IACH,IAAI,IAAI,WAAW,EAAE;IAMrB;;OAEG;IACH,iBAAiB,IAAI,gBAAgB,EAAE;IAIvC;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE;IAIxB;;OAEG;IACH,QAAQ,IAAI;QACV,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;QACtB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACnC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACjC;IAuBD;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO;IAiBnD;;OAEG;IACG,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,OAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA4CpF;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAqBjE;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B;;OAEG;YACW,cAAc;IAM5B;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,EAAE,QAAQ,GAAG,YAAY;CAGzD;AAGD,eAAO,MAAM,YAAY,cAAqB,CAAC"}