@identikey/coding-mcp 2.0.1

package/build/core/ToolRegistry.js

@@ -0,0 +1,279 @@
+/**
+ * Tool Registry - Central hub for managing MCP tool commands
+ * Implements the Command pattern with EventBus integration
+ */
+import { ToolLifecycle, ToolNotFoundError, DuplicateToolError, ToolError } from './ToolCommand.js';
+import { eventBus } from '../infra/eventBus.js';
+export class ToolRegistry {
+    tools = new Map();
+    healthCache = new Map();
+    eventBus;
+    constructor(eventBusInstance) {
+        this.eventBus = eventBusInstance || eventBus;
+        // Listen for system events
+        this.eventBus.on('system:shutdown', this.handleShutdown.bind(this), 'ToolRegistry');
+    }
+    /**
+     * Register a new tool command
+     */
+    async register(tool, source = 'unknown') {
+        if (this.tools.has(tool.name)) {
+            throw new DuplicateToolError(tool.name);
+        }
+        // Create registration record
+        const registration = {
+            tool,
+            registeredAt: Date.now(),
+            source,
+            enabled: true
+        };
+        // Emit lifecycle event
+        this.eventBus.emit('tool:lifecycle', {
+            name: tool.name,
+            state: ToolLifecycle.LOADING,
+            metadata: { source, version: tool.version }
+        });
+        try {
+            // Call onLoad hook if present
+            if (tool.onLoad) {
+                await tool.onLoad();
+            }
+            // Register the tool
+            this.tools.set(tool.name, registration);
+            // Update lifecycle state
+            this.eventBus.emit('tool:lifecycle', {
+                name: tool.name,
+                state: ToolLifecycle.READY
+            });
+            // Emit registration event
+            this.eventBus.emit('tool:registered', {
+                name: tool.name,
+                version: tool.version,
+                source
+            });
+            console.log(`✅ Tool '${tool.name}' registered from ${source}`);
+        }
+        catch (error) {
+            // Handle registration failure
+            this.eventBus.emit('tool:lifecycle', {
+                name: tool.name,
+                state: ToolLifecycle.ERROR,
+                metadata: { error: error instanceof Error ? error.message : String(error) }
+            });
+            this.eventBus.emit('tool:error', {
+                name: tool.name,
+                error: error instanceof Error ? error : new Error(String(error))
+            });
+            throw new ToolError(`Failed to register tool '${tool.name}': ${error instanceof Error ? error.message : String(error)}`, 'EXECUTION_ERROR', tool.name, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Unregister a tool command
+     */
+    async unregister(name, reason) {
+        const registration = this.tools.get(name);
+        if (!registration) {
+            return false;
+        }
+        // Emit lifecycle event
+        this.eventBus.emit('tool:lifecycle', {
+            name,
+            state: ToolLifecycle.UNLOADING,
+            metadata: { reason }
+        });
+        try {
+            // Call onUnload hook if present
+            if (registration.tool.onUnload) {
+                await registration.tool.onUnload();
+            }
+            // Remove from registry
+            this.tools.delete(name);
+            this.healthCache.delete(name);
+            // Update lifecycle state
+            this.eventBus.emit('tool:lifecycle', {
+                name,
+                state: ToolLifecycle.DISPOSED
+            });
+            // Emit unregistration event
+            this.eventBus.emit('tool:unregistered', {
+                name,
+                reason
+            });
+            console.log(`❌ Tool '${name}' unregistered${reason ? `: ${reason}` : ''}`);
+            return true;
+        }
+        catch (error) {
+            // Handle unload failure
+            this.eventBus.emit('tool:error', {
+                name,
+                error: error instanceof Error ? error : new Error(String(error))
+            });
+            // Force removal even if unload fails
+            this.tools.delete(name);
+            this.healthCache.delete(name);
+            console.warn(`⚠️ Tool '${name}' forcibly removed due to unload error:`, error);
+            return true;
+        }
+    }
+    /**
+     * Get a registered tool by name
+     */
+    get(name) {
+        const registration = this.tools.get(name);
+        return registration?.enabled ? registration.tool : undefined;
+    }
+    /**
+     * Get tool registration info
+     */
+    getRegistration(name) {
+        return this.tools.get(name);
+    }
+    /**
+     * Check if a tool is registered
+     */
+    has(name) {
+        return this.tools.has(name);
+    }
+    /**
+     * List all registered tools
+     */
+    list() {
+        return Array.from(this.tools.values())
+            .filter(reg => reg.enabled)
+            .map(reg => reg.tool);
+    }
+    /**
+     * List all tool registrations (including disabled)
+     */
+    listRegistrations() {
+        return Array.from(this.tools.values());
+    }
+    /**
+     * Get tool names only
+     */
+    getToolNames() {
+        return Array.from(this.tools.keys());
+    }
+    /**
+     * Get registry statistics
+     */
+    getStats() {
+        const registrations = Array.from(this.tools.values());
+        const categories = {};
+        const sources = {};
+        registrations.forEach(reg => {
+            // Count categories
+            const category = reg.tool.metadata?.category || 'uncategorized';
+            categories[category] = (categories[category] || 0) + 1;
+            // Count sources
+            sources[reg.source] = (sources[reg.source] || 0) + 1;
+        });
+        return {
+            totalTools: registrations.length,
+            enabledTools: registrations.filter(r => r.enabled).length,
+            disabledTools: registrations.filter(r => !r.enabled).length,
+            categories,
+            sources
+        };
+    }
+    /**
+     * Enable/disable a tool
+     */
+    setEnabled(name, enabled) {
+        const registration = this.tools.get(name);
+        if (!registration) {
+            return false;
+        }
+        registration.enabled = enabled;
+        this.eventBus.emit('tool:lifecycle', {
+            name,
+            state: enabled ? ToolLifecycle.READY : ToolLifecycle.DISPOSED,
+            metadata: { enabled }
+        });
+        return true;
+    }
+    /**
+     * Check tool health
+     */
+    async checkHealth(name, useCache = true) {
+        const registration = this.tools.get(name);
+        if (!registration) {
+            throw new ToolNotFoundError(name);
+        }
+        // Check cache first
+        if (useCache) {
+            const cached = this.healthCache.get(name);
+            if (cached && (Date.now() - cached.lastChecked) < 30000) { // 30 second cache
+                return cached;
+            }
+        }
+        let healthStatus = {
+            healthy: true,
+            lastChecked: Date.now()
+        };
+        try {
+            // Use tool's health check if available
+            if (registration.tool.healthCheck) {
+                healthStatus = await registration.tool.healthCheck();
+            }
+        }
+        catch (error) {
+            healthStatus = {
+                healthy: false,
+                message: error instanceof Error ? error.message : String(error),
+                lastChecked: Date.now()
+            };
+        }
+        // Cache result
+        this.healthCache.set(name, healthStatus);
+        // Emit health event
+        this.eventBus.emit('tool:health', {
+            name,
+            status: healthStatus
+        });
+        return healthStatus;
+    }
+    /**
+     * Check health of all tools
+     */
+    async checkAllHealth() {
+        const results = {};
+        const names = this.getToolNames();
+        await Promise.allSettled(names.map(async (name) => {
+            try {
+                results[name] = await this.checkHealth(name, false);
+            }
+            catch (error) {
+                results[name] = {
+                    healthy: false,
+                    message: error instanceof Error ? error.message : String(error),
+                    lastChecked: Date.now()
+                };
+            }
+        }));
+        return results;
+    }
+    /**
+     * Clear all tools (for testing or shutdown)
+     */
+    async clear() {
+        const names = Array.from(this.tools.keys());
+        await Promise.allSettled(names.map(name => this.unregister(name, 'registry cleared')));
+    }
+    /**
+     * Handle system shutdown
+     */
+    async handleShutdown() {
+        console.log('🔄 ToolRegistry: Shutting down, unregistering all tools...');
+        await this.clear();
+        console.log('✅ ToolRegistry: Shutdown complete');
+    }
+    /**
+     * Create a new registry instance (for testing)
+     */
+    static create(eventBusInstance) {
+        return new ToolRegistry(eventBusInstance);
+    }
+}
+// Singleton instance
+export const toolRegistry = new ToolRegistry();

package/build/index.d.ts

@@ -0,0 +1,8 @@
+import "./personas/charles/index.js";
+import "./personas/ada/index.js";
+import "./personas/xavier/index.js";
+import "./personas/atlas/index.js";
+import "./personas/hermes/index.js";
+import "./personas/sentinel/index.js";
+import "./personas/iris/index.js";
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAgEA,OAAO,6BAA6B,CAAC;AACrC,OAAO,yBAAyB,CAAC;AACjC,OAAO,4BAA4B,CAAC;AACpC,OAAO,2BAA2B,CAAC;AACnC,OAAO,4BAA4B,CAAC;AACpC,OAAO,8BAA8B,CAAC;AACtC,OAAO,0BAA0B,CAAC"}

package/build/index.js

@@ -0,0 +1,329 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { screenshotToolName, screenshotToolDescription, ScreenshotToolSchema, runScreenshotTool, } from "./tools/screenshot.js";
+import { architectToolName, architectToolDescription, ArchitectToolSchema, runArchitectTool, } from "./tools/architect.js";
+import { codeReviewToolName, codeReviewToolDescription, CodeReviewToolSchema, runCodeReviewTool, } from "./tools/codeReview.js";
+import { codeAdviceToolName, codeAdviceToolDescription, CodeAdviceToolSchema, runCodeAdviceTool, } from "./tools/codeadvice.js";
+import { researcherToolName, researcherToolDescription, ResearcherToolSchema, runResearcherTool, } from "./tools/researcher.js";
+import { personaToolName, personaToolDescription, PersonaToolSchema, runPersonaTool, } from "./tools/persona.js";
+import { askToolName, askToolDescription, AskToolSchema, runAskTool, } from "./tools/ask.js";
+import { discoverToolName, discoverToolDescription, DiscoverToolSchema, runDiscoverTool, } from "./tools/discover.js";
+// Import personas to auto-register
+import "./personas/charles/index.js";
+import "./personas/ada/index.js";
+import "./personas/xavier/index.js";
+import "./personas/atlas/index.js";
+import "./personas/hermes/index.js";
+import "./personas/sentinel/index.js";
+import "./personas/iris/index.js";
+/**
+ * MCP server providing Cursor Tools:
+ *   1) Screenshot
+ *   2) Architect
+ *   3) CodeReview
+ *   4) CodeAdvice
+ *   5) Researcher
+ *   6) Persona (Direct access)
+ *   7) Ask (Smart routing)
+ *   8) Discover (List personas)
+ */
+// 1. Create an MCP server instance
+const server = new Server({
+    name: "cursor-tools",
+    version: "2.0.1",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// 2. Define the list of tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: screenshotToolName,
+                description: screenshotToolDescription,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        url: {
+                            type: "string",
+                            description: "Full URL to screenshot",
+                        },
+                        relativePath: {
+                            type: "string",
+                            description: "Relative path appended to http://localhost:3000",
+                        },
+                        fullPathToScreenshot: {
+                            type: "string",
+                            description: "Path to where the screenshot file should be saved. This should be a cwd-style full path to the file (not relative to the current working directory) including the file name and extension.",
+                        },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: architectToolName,
+                description: architectToolDescription,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        task: {
+                            type: "string",
+                            description: "Description of the task",
+                        },
+                        code: {
+                            type: "string",
+                            description: "Concatenated code from one or more files",
+                        },
+                        reasoning_effort: {
+                            type: "string",
+                            enum: ["low", "medium", "high"],
+                            description: "How hard the model should think (default: high)",
+                        },
+                        persona: {
+                            type: "string",
+                            description: "Persona to apply (e.g., 'charles' for British architect)",
+                        },
+                    },
+                    required: ["task", "code"],
+                },
+            },
+            {
+                name: codeReviewToolName,
+                description: codeReviewToolDescription,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        folderPath: {
+                            type: "string",
+                            description: "Path to the full root directory of the repository to diff against main",
+                        },
+                    },
+                    required: ["folderPath"],
+                },
+            },
+            {
+                name: codeAdviceToolName,
+                description: codeAdviceToolDescription,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        task: {
+                            type: "string",
+                            description: "Description of the problem or advice needed",
+                        },
+                        code: {
+                            type: "string",
+                            description: "Relevant code snippet",
+                        },
+                        reasoning_effort: {
+                            type: "string",
+                            enum: ["low", "medium", "high"],
+                            description: "How hard the model should think (low/medium/high)",
+                        },
+                    },
+                    required: ["task", "code"],
+                },
+            },
+            {
+                name: researcherToolName,
+                description: researcherToolDescription,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: {
+                            type: "string",
+                            description: "Research query to investigate",
+                        },
+                        search_engines: {
+                            type: "array",
+                            items: {
+                                type: "string",
+                                enum: [
+                                    "google",
+                                    "xai",
+                                    "arxiv",
+                                    "wikipedia",
+                                    "github",
+                                    "stackexchange",
+                                    "pubmed",
+                                    "semantic_scholar",
+                                ],
+                            },
+                            description: "Search engines to use (default: google, xai)",
+                        },
+                        max_results_per_engine: {
+                            type: "number",
+                            description: "Maximum results per search engine (1-20, default: 5)",
+                        },
+                        deep_search: {
+                            type: "boolean",
+                            description: "Whether to perform deep search by following links",
+                        },
+                        include_academic: {
+                            type: "boolean",
+                            description: "Whether to prioritize academic sources",
+                        },
+                        citation_style: {
+                            type: "string",
+                            enum: ["apa", "mla", "chicago", "ieee", "inline"],
+                            description: "Citation style to use (default: inline)",
+                        },
+                    },
+                    required: ["query"],
+                },
+            },
+            {
+                name: personaToolName,
+                description: personaToolDescription,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        persona_id: {
+                            type: "string",
+                            description: "ID of the persona (e.g., 'charles')",
+                        },
+                        query: {
+                            type: "string",
+                            description: "Question or request for the persona",
+                        },
+                        context: {
+                            type: "string",
+                            description: "Additional context or code to analyze",
+                        },
+                        analysis_type: {
+                            type: "string",
+                            enum: ["comprehensive", "advice", "research", "review"],
+                            description: "Type of analysis (default: advice)",
+                        },
+                        reasoning_effort: {
+                            type: "string",
+                            enum: ["low", "medium", "high"],
+                            description: "Reasoning effort level",
+                        },
+                    },
+                    required: ["persona_id", "query"],
+                },
+            },
+            {
+                name: askToolName,
+                description: askToolDescription,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        persona_id: {
+                            type: "string",
+                            description: "Persona to use: 'auto' (default) routes to best expert, or a specific id like 'charles', 'ada', 'xavier'",
+                        },
+                        query: {
+                            type: "string",
+                            description: "Your question or request",
+                        },
+                        context: {
+                            type: "string",
+                            description: "Additional code or context for analysis",
+                        },
+                        hint: {
+                            type: "string",
+                            description: "Optional hint for routing (e.g., 'architecture', 'security')",
+                        },
+                        explain_routing: {
+                            type: "boolean",
+                            description: "Show which persona was selected and why",
+                        },
+                        reasoning_effort: {
+                            type: "string",
+                            enum: ["low", "medium", "high"],
+                            description: "How thoroughly to think about the answer",
+                        },
+                        provider: {
+                            type: "string",
+                            enum: ["xai", "openai"],
+                            description: "Optional provider override; defaults to persona preference or heuristic",
+                        },
+                    },
+                    required: ["query"],
+                },
+            },
+            {
+                name: discoverToolName,
+                description: discoverToolDescription,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        category: {
+                            type: "string",
+                            enum: [
+                                "architecture",
+                                "algorithms",
+                                "security",
+                                "frontend",
+                                "backend",
+                                "data",
+                                "all",
+                            ],
+                            description: "Filter personas by category",
+                        },
+                        verbose: {
+                            type: "boolean",
+                            description: "Show detailed information including example queries",
+                        },
+                    },
+                    required: [],
+                },
+            },
+        ],
+    };
+});
+// 3. Implement the tool call logic
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    switch (name) {
+        case screenshotToolName: {
+            const validated = ScreenshotToolSchema.parse(args);
+            return await runScreenshotTool(validated);
+        }
+        case architectToolName: {
+            const validated = ArchitectToolSchema.parse(args);
+            return await runArchitectTool(validated);
+        }
+        case codeReviewToolName: {
+            const validated = CodeReviewToolSchema.parse(args);
+            return await runCodeReviewTool(validated);
+        }
+        case codeAdviceToolName: {
+            const validated = CodeAdviceToolSchema.parse(args);
+            return await runCodeAdviceTool(validated);
+        }
+        case researcherToolName: {
+            const validated = ResearcherToolSchema.parse(args);
+            return await runResearcherTool(validated);
+        }
+        case personaToolName: {
+            const validated = PersonaToolSchema.parse(args);
+            return await runPersonaTool(validated);
+        }
+        case askToolName: {
+            const validated = AskToolSchema.parse(args);
+            return await runAskTool(validated);
+        }
+        case discoverToolName: {
+            const validated = DiscoverToolSchema.parse(args);
+            return await runDiscoverTool(validated);
+        }
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+});
+// 4. Start the MCP server with a stdio transport
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Cursor Tools MCP Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});