@evolith/smart-cli 0.0.1-beta → 0.0.3-beta

package/dist/core/mcp/server.js

@@ -33,175 +33,367 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EvolithMcpServer = void 0;
 exports.startMcpServer = startMcpServer;
 const common_1 = require("@nestjs/common");
+const http = __importStar(require("node:http"));
 const ruleset_validator_service_1 = require("../validators/ruleset-validator.service");
 const validate_1 = require("./tools/validate");
 const agent_1 = require("./tools/agent");
 const architecture_1 = require("./tools/architecture");
 const sdlc_1 = require("./tools/sdlc");
-const resources_1 = require("./resources");
-const prompts_1 = require("./prompts");
+const moscow_1 = require("./tools/moscow");
 const metrics_service_1 = require("./metrics.service");
-let ServerClass;
-let StdioTransportClass;
-let StreamableHttpTransportClass;
-async function loadMcpSdk() {
-    if (ServerClass)
-        return;
-    try {
-        const mcp = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk')));
-        ServerClass = mcp.Server;
-        StdioTransportClass = mcp.StdioServerTransport;
-        const httpTransport = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/server/streamableHttp')));
-        if (httpTransport.StreamableHTTPServerTransport) {
-            StreamableHttpTransportClass = httpTransport.StreamableHTTPServerTransport;
-        }
+class MinimalStdioTransport {
+    constructor(stdin, stdout) {
+        this.readBuffer = '';
+        this.stdin = stdin || process.stdin;
+        this.stdout = stdout || process.stdout;
+        this.readBuffer = '';
+        this.started = false;
     }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to load @modelcontextprotocol/sdk: ${msg}. Install with: npm install @modelcontextprotocol/sdk`);
+    async start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.stdin.on('data', (chunk) => {
+            this.readBuffer += chunk.toString();
+            let newlineIndex;
+            while ((newlineIndex = this.readBuffer.indexOf('\n')) !== -1) {
+                const line = this.readBuffer.slice(0, newlineIndex).trim();
+                this.readBuffer = this.readBuffer.slice(newlineIndex + 1);
+                if (line) {
+                    try {
+                        const message = JSON.parse(line);
+                        if (this.onmessage) {
+                            this.onmessage(message);
+                        }
+                    }
+                    catch (e) {
+                        if (this.onerror) {
+                            this.onerror(new Error(`Invalid JSON: ${line}`));
+                        }
+                    }
+                }
+            }
+        });
+        this.stdin.on('end', () => {
+            if (this.onclose) {
+                this.onclose();
+            }
+        });
+        this.stdin.on('error', (err) => {
+            if (this.onerror) {
+                this.onerror(err);
+            }
+        });
+    }
+    async close() {
+        this.started = false;
+    }
+    async send(message) {
+        return new Promise((resolve, reject) => {
+            const json = JSON.stringify(message) + '\n';
+            this.stdout.write(json, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
     }
 }
-function validateApiKey(apiKey, validKey) {
-    if (!validKey)
-        return true;
-    if (!apiKey)
-        return false;
-    return apiKey === validKey;
-}
-const LIST_TOOLS_REQUEST_SCHEMA = {
-    name: 'tools/list',
-    description: 'List available tools',
-};
-const CALL_TOOL_REQUEST_SCHEMA = {
-    name: 'tools/call',
-    description: 'Call a tool by name',
-};
-const LIST_RESOURCES_REQUEST_SCHEMA = {
-    name: 'resources/list',
-    description: 'List available resources',
-};
-const READ_RESOURCE_REQUEST_SCHEMA = {
-    name: 'resources/read',
-    description: 'Read a resource',
-};
-const LIST_PROMPTS_REQUEST_SCHEMA = {
-    name: 'prompts/list',
-    description: 'List available prompts',
-};
-const GET_PROMPT_REQUEST_SCHEMA = {
-    name: 'prompts/get',
-    description: 'Get a prompt template',
-};
-class EvolithMcpServer {
-    constructor(options = {}) {
-        this.logger = new common_1.Logger(EvolithMcpServer.name);
-        this.serverInstance = null;
-        this.rulesetValidator = options.rulesetValidator || new ruleset_validator_service_1.RulesetValidatorService();
-        this.metricsService = options.metricsService || new metrics_service_1.McpMetricsService();
-        this.apiKey = options.apiKey || process.env.EVOLITH_API_KEY;
-        this.port = options.port || parseInt(process.env.PORT || '3000', 10);
+class MinimalHttpTransport {
+    constructor(port, apiKey) {
+        this.server = null;
+        this.logger = new common_1.Logger(MinimalHttpTransport.name);
+        this.sseClients = [];
+        this.started = false;
+        this.port = port;
+        this.apiKey = apiKey;
     }
-    async initialize() {
-        await loadMcpSdk();
-        this.serverInstance = new ServerClass({
-            name: 'evolith-mcp-server',
-            version: '1.0.0',
+    async start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.server = http.createServer((req, res) => {
+            this.handleRequest(req, res);
         });
-        this.serverInstance.setRequestHandler(LIST_TOOLS_REQUEST_SCHEMA, async () => {
-            return this.handleListTools();
+        this.server.on('error', (error) => {
+            this.logger.error(`HTTP server error: ${error.message}`);
+            if (this.onerror) {
+                this.onerror(error);
+            }
         });
-        this.serverInstance.setRequestHandler(CALL_TOOL_REQUEST_SCHEMA, async (request) => {
-            const req = request;
-            if (!validateApiKey(req.arguments?.apiKey, this.apiKey)) {
-                return {
-                    content: [{ type: 'text', text: JSON.stringify({ error: true, message: 'Invalid API key' }) }],
-                    isError: true,
-                };
+        this.server.on('close', () => {
+            if (this.onclose) {
+                this.onclose();
+            }
+        });
+        await new Promise((resolve, reject) => {
+            this.server.listen(this.port, '127.0.0.1', () => {
+                this.logger.log(`Evolith MCP HTTP server listening on http://127.0.0.1:${this.port}`);
+                resolve();
+            });
+            this.server.on('error', reject);
+        });
+    }
+    async close() {
+        this.started = false;
+        for (const client of this.sseClients) {
+            client.res.end();
+        }
+        this.sseClients = [];
+        if (this.server) {
+            await new Promise((resolve) => {
+                this.server.close(() => resolve());
+            });
+            this.server = null;
+        }
+    }
+    async send(message) {
+        const data = `event: message\ndata: ${JSON.stringify(message)}\n\n`;
+        const clientsToRemove = [];
+        for (const client of this.sseClients) {
+            try {
+                client.res.write(data);
+            }
+            catch {
+                clientsToRemove.push(client);
             }
-            const args = { ...req.arguments };
-            delete args.apiKey;
-            return this.handleCallTool(req.name, args);
+        }
+        for (const client of clientsToRemove) {
+            const index = this.sseClients.indexOf(client);
+            if (index > -1) {
+                this.sseClients.splice(index, 1);
+            }
+        }
+    }
+    handleRequest(req, res) {
+        const url = new URL(req.url || '/', `http://127.0.0.1:${this.port}`);
+        if (!this.validateAuth(req, res)) {
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/message') {
+            this.handlePostMessage(req, res);
+        }
+        else if (req.method === 'GET' && url.pathname === '/sse') {
+            this.handleSseConnection(req, res);
+        }
+        else if (req.method === 'GET' && url.pathname === '/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'ok', transport: 'http', protocol: 'mcp' }));
+        }
+        else {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Not found' }));
+        }
+    }
+    validateAuth(req, res) {
+        if (!this.apiKey)
+            return true;
+        const authHeader = req.headers.authorization || '';
+        const bearerToken = authHeader.startsWith('Bearer ') ? authHeader.slice(7) : '';
+        const apiKeyHeader = req.headers['x-api-key'];
+        if (bearerToken !== this.apiKey && apiKeyHeader !== this.apiKey) {
+            res.writeHead(401, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Unauthorized', message: 'Invalid or missing API key' }));
+            return false;
+        }
+        return true;
+    }
+    async handlePostMessage(req, res) {
+        let body = '';
+        req.on('data', (chunk) => {
+            body += chunk.toString();
         });
-        this.serverInstance.setRequestHandler(LIST_RESOURCES_REQUEST_SCHEMA, async () => {
-            return (0, resources_1.listResources)();
+        req.on('end', async () => {
+            try {
+                const message = JSON.parse(body);
+                if (this.onmessage) {
+                    await this.onmessage(message);
+                }
+                res.writeHead(202, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ status: 'accepted' }));
+            }
+            catch (error) {
+                this.logger.error(`Invalid POST message: ${error}`);
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Invalid JSON' }));
+            }
         });
-        this.serverInstance.setRequestHandler(READ_RESOURCE_REQUEST_SCHEMA, async (request) => {
-            return (0, resources_1.readResource)(request);
+        req.on('error', (error) => {
+            this.logger.error(`Request error: ${error.message}`);
+            if (this.onerror) {
+                this.onerror(error);
+            }
+            if (!res.headersSent) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Internal server error' }));
+            }
         });
-        this.serverInstance.setRequestHandler(LIST_PROMPTS_REQUEST_SCHEMA, async () => {
-            return (0, prompts_1.listPrompts)();
+    }
+    handleSseConnection(req, res) {
+        const clientId = `client-${Date.now()}-${Math.random().toString(36).substring(2, 7)}`;
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'Access-Control-Allow-Origin': '*',
         });
-        this.serverInstance.setRequestHandler(GET_PROMPT_REQUEST_SCHEMA, async (request) => {
-            return (0, prompts_1.getPrompt)(request);
+        res.write(': connected\n\n');
+        this.sseClients.push({ id: clientId, res });
+        req.on('close', () => {
+            const index = this.sseClients.findIndex(c => c.id === clientId);
+            if (index > -1) {
+                this.sseClients.splice(index, 1);
+            }
+            this.logger.debug(`SSE client disconnected: ${clientId}`);
         });
-        this.logger.log('Evolith MCP Server initialized');
+        this.logger.debug(`SSE client connected: ${clientId}`);
     }
-    async connect(transport = 'stdio') {
-        if (!this.serverInstance) {
-            await this.initialize();
-        }
-        if (transport === 'http') {
-            await this.startHttpServer();
+}
+class DirectMcpServer {
+    constructor(transportType = 'stdio', port = 49100, apiKey, rulesetValidator, metricsService) {
+        this.logger = new common_1.Logger(DirectMcpServer.name);
+        this.transportType = transportType;
+        this.rulesetValidator = rulesetValidator || new ruleset_validator_service_1.RulesetValidatorService();
+        this.metricsService = metricsService || new metrics_service_1.McpMetricsService();
+        if (transportType === 'http') {
+            this.transport = new MinimalHttpTransport(port, apiKey);
         }
         else {
-            const stdioTransport = new StdioTransportClass();
-            await this.serverInstance.connect(stdioTransport);
+            this.transport = new MinimalStdioTransport();
         }
     }
-    async startHttpServer() {
-        if (!StreamableHttpTransportClass) {
-            this.logger.warn('Streamable HTTP transport not available, falling back to stdio');
-            const stdioTransport = new StdioTransportClass();
-            await this.serverInstance.connect(stdioTransport);
-            return;
+    async start() {
+        const transport = this.transport;
+        transport.onmessage = async (message) => {
+            await this.handleMessage(message);
+        };
+        transport.onerror = (error) => {
+            this.logger.error(`Transport error: ${error.message}`);
+        };
+        await transport.start();
+        this.logger.log(`Evolith MCP Server started on ${this.transportType}`);
+    }
+    async stop() {
+        await this.transport.close();
+    }
+    async handleMessage(rawMessage) {
+        try {
+            const request = rawMessage;
+            this.logger.debug(`Received: ${JSON.stringify(request)}`);
+            if (request.method === 'initialize') {
+                const response = {
+                    jsonrpc: '2.0',
+                    id: request.id,
+                    result: {
+                        protocolVersion: '2024-11-05',
+                        capabilities: {
+                            tools: {},
+                            resources: {},
+                            prompts: {},
+                        },
+                        serverInfo: {
+                            name: 'evolith-mcp-server',
+                            version: '1.0.0',
+                        },
+                    },
+                };
+                await this.transport.send(response);
+                return;
+            }
+            let result;
+            try {
+                result = await this.dispatchRequest(request.method, request.params || {});
+            }
+            catch (error) {
+                const errorResponse = {
+                    jsonrpc: '2.0',
+                    id: request.id,
+                    error: {
+                        code: -32603,
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                };
+                await this.transport.send(errorResponse);
+                return;
+            }
+            const response = {
+                jsonrpc: '2.0',
+                id: request.id,
+                result,
+            };
+            await this.transport.send(response);
+        }
+        catch (error) {
+            this.logger.error(`Error handling message: ${error}`);
+            const errorResponse = {
+                jsonrpc: '2.0',
+                id: null,
+                error: {
+                    code: -32603,
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            };
+            await this.transport.send(errorResponse);
+        }
+    }
+    async dispatchRequest(method, params) {
+        switch (method) {
+            case 'tools/list':
+                return this.handleListTools();
+            case 'tools/call':
+                return this.handleCallTool(params);
+            case 'resources/list':
+                return this.handleListResources();
+            case 'resources/read':
+                return this.handleReadResource(params);
+            case 'prompts/list':
+                return this.handleListPrompts();
+            case 'prompts/get':
+                return this.handleGetPrompt(params);
+            default:
+                throw new Error(`Method not found: ${method}`);
         }
-        this.logger.log(`Starting HTTP MCP server on port ${this.port}`);
-        const httpTransport = new StreamableHttpTransportClass({
-            port: this.port,
-            host: '0.0.0.0',
-        });
-        await this.serverInstance.connect(httpTransport);
     }
-    async handleListTools() {
+    handleListTools() {
         return {
             tools: [
                 {
                     name: 'evolith-validate',
-                    description: 'Validate a repository against Evolith governance rules. Returns validation status, rules checked, and any issues found.',
+                    description: 'Validate a repository against Evolith governance rules',
                     inputSchema: {
                         type: 'object',
                         properties: {
                             path: { type: 'string', description: 'Path to the repository to validate' },
                             format: { type: 'string', description: 'Output format: json, summary, table', default: 'json' },
-                            ruleset: { type: 'string', description: 'Specific ruleset to validate (acl, open-core, inheritance, adr-XXXX)' },
-                            corePath: { type: 'string', description: 'Path to Evolith Core (optional, auto-detected)' },
+                            ruleset: { type: 'string', description: 'Specific ruleset to validate' },
+                            corePath: { type: 'string', description: 'Path to Evolith Core' },
                         },
                         required: ['path'],
                     },
                 },
                 {
                     name: 'evolith-agent-install',
-                    description: 'Install a new Evolith agent with specified name and template',
+                    description: 'Install a new Evolith agent',
                     inputSchema: {
                         type: 'object',
                         properties: {
                             name: { type: 'string', description: 'Name of the agent to install' },
-                            template: { type: 'string', description: 'Template to use: standard, minimal, enterprise', default: 'standard' },
-                            dir: { type: 'string', description: 'Directory to install into (defaults to current working directory)' },
+                            template: { type: 'string', description: 'Template: standard, minimal, enterprise', default: 'standard' },
+                            dir: { type: 'string', description: 'Directory to install into' },
                         },
                         required: ['name'],
                     },
                 },
                 {
                     name: 'evolith-agent-list',
-                    description: 'List all installed Evolith agents in a repository',
+                    description: 'List all installed Evolith agents',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            dir: { type: 'string', description: 'Directory to search for agents (defaults to current working directory)' },
+                            dir: { type: 'string', description: 'Directory to search' },
                         },
                     },
                 },
@@ -211,44 +403,45 @@ class EvolithMcpServer {
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            name: { type: 'string', description: 'Name of the agent to validate' },
-                            dir: { type: 'string', description: 'Directory containing the agent (defaults to current working directory)' },
+                            name: { type: 'string' },
+                            dir: { type: 'string' },
                         },
                         required: ['name'],
                     },
                 },
                 {
                     name: 'evolith-agent-upgrade',
-                    description: 'Upgrade an existing Evolith agent to the latest version',
+                    description: 'Upgrade an existing Evolith agent',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            name: { type: 'string', description: 'Name of the agent to upgrade' },
-                            dir: { type: 'string', description: 'Directory containing the agent (defaults to current working directory)' },
+                            name: { type: 'string' },
+                            dir: { type: 'string' },
                         },
                         required: ['name'],
                     },
                 },
                 {
                     name: 'evolith-agent-remove',
-                    description: 'Remove an Evolith agent and its ruleset',
+                    description: 'Remove an Evolith agent',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            name: { type: 'string', description: 'Name of the agent to remove' },
-                            dir: { type: 'string', description: 'Directory containing the agent (defaults to current working directory)' },
+                            name: { type: 'string' },
+                            dir: { type: 'string' },
                         },
                         required: ['name'],
                     },
                 },
                 {
                     name: 'evolith-architecture-validate',
-                    description: 'Validate repository architecture against F1/F2/F3 rules',
+                    description: 'Validate repository architecture against F1/F2/F3 rules. Use deep=true for import graph analysis, layer violations, and coupling metrics.',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            path: { type: 'string', description: 'Path to the repository to validate' },
-                            level: { type: 'string', description: 'Architecture level: F1 (modular), F2 (contracts), F3 (extraction)', default: 'F1' },
+                            path: { type: 'string' },
+                            level: { type: 'string', description: 'F1, F2, or F3' },
+                            deep: { type: 'boolean', description: 'Enable deep static analysis (import graph, layer violations, coupling metrics)', default: false },
                         },
                         required: ['path'],
                     },
@@ -259,20 +452,20 @@ class EvolithMcpServer {
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            path: { type: 'string', description: 'Path to the repository' },
-                            fromPhase: { type: 'string', description: 'Source phase: phase-0, phase-1, phase-2, phase-3, phase-4' },
-                            toPhase: { type: 'string', description: 'Target phase: phase-0, phase-1, phase-2, phase-3, phase-4' },
+                            path: { type: 'string' },
+                            fromPhase: { type: 'string' },
+                            toPhase: { type: 'string' },
                         },
                         required: ['path', 'fromPhase', 'toPhase'],
                     },
                 },
                 {
                     name: 'evolith-sdlc-status',
-                    description: 'Show current SDLC phase gate status for a repository',
+                    description: 'Show current SDLC phase gate status',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            path: { type: 'string', description: 'Path to the repository' },
+                            path: { type: 'string' },
                         },
                         required: ['path'],
                     },
@@ -283,8 +476,8 @@ class EvolithMcpServer {
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            key: { type: 'string', description: 'Configuration key to retrieve' },
-                            dir: { type: 'string', description: 'Directory containing evolith.yaml' },
+                            key: { type: 'string' },
+                            dir: { type: 'string' },
                         },
                         required: ['key'],
                     },
@@ -295,26 +488,114 @@ class EvolithMcpServer {
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            key: { type: 'string', description: 'Configuration key to set' },
-                            value: { type: 'string', description: 'Value to set' },
-                            dir: { type: 'string', description: 'Directory containing evolith.yaml' },
+                            key: { type: 'string' },
+                            value: { type: 'string' },
+                            dir: { type: 'string' },
                         },
                         required: ['key', 'value'],
                     },
                 },
                 {
                     name: 'evolith-metrics',
-                    description: 'Get MCP server metrics including tool usage statistics, latency, and error rates',
+                    description: 'Get MCP server metrics',
                     inputSchema: {
                         type: 'object',
                         properties: {},
                     },
                 },
+                {
+                    name: 'evolith-moscow-create',
+                    description: 'Create a new MoSCoW prioritization analysis for a phase',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            path: { type: 'string', description: 'Path to the repository' },
+                            phase: { type: 'string', description: 'Phase identifier (e.g., phase-0)', default: 'phase-0' },
+                            items: { type: 'array', description: 'Array of MoSCoW items with description, priority, category, rationale' },
+                        },
+                        required: ['path', 'items'],
+                    },
+                },
+                {
+                    name: 'evolith-moscow-load',
+                    description: 'Load an existing MoSCoW analysis for a phase',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            path: { type: 'string' },
+                            phase: { type: 'string', default: 'phase-0' },
+                        },
+                        required: ['path'],
+                    },
+                },
+                {
+                    name: 'evolith-moscow-update',
+                    description: 'Update an item in a MoSCoW analysis',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            path: { type: 'string' },
+                            phase: { type: 'string', default: 'phase-0' },
+                            itemId: { type: 'string' },
+                            updates: { type: 'object' },
+                        },
+                        required: ['path', 'itemId'],
+                    },
+                },
+                {
+                    name: 'evolith-moscow-remove',
+                    description: 'Remove an item from a MoSCoW analysis',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            path: { type: 'string' },
+                            phase: { type: 'string', default: 'phase-0' },
+                            itemId: { type: 'string' },
+                        },
+                        required: ['path', 'itemId'],
+                    },
+                },
+                {
+                    name: 'evolith-moscow-list',
+                    description: 'List all MoSCoW analyses for a repository',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            path: { type: 'string' },
+                        },
+                        required: ['path'],
+                    },
+                },
+                {
+                    name: 'evolith-moscow-validate',
+                    description: 'Validate a MoSCoW analysis for correctness',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            path: { type: 'string' },
+                            phase: { type: 'string', default: 'phase-0' },
+                        },
+                        required: ['path'],
+                    },
+                },
+                {
+                    name: 'evolith-moscow-report',
+                    description: 'Generate a markdown report from a MoSCoW analysis',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            path: { type: 'string' },
+                            phase: { type: 'string', default: 'phase-0' },
+                        },
+                        required: ['path'],
+                    },
+                },
             ],
         };
     }
-    async handleCallTool(name, args) {
-        this.logger.debug(`Tool call: ${name} with args: ${JSON.stringify(args)}`);
+    async handleCallTool(params) {
+        const name = params.name;
+        const args = params.arguments || {};
         const startTime = Date.now();
         try {
             let result;
@@ -331,11 +612,14 @@ class EvolithMcpServer {
                 result = await (0, sdlc_1.handleSdlcTools)(name, args);
             }
             else if (name === 'evolith-config-get' || name === 'evolith-config-set') {
-                result = await handleConfigTools(name, args);
+                result = await this.handleConfigTools(name, args);
             }
             else if (name === 'evolith-metrics') {
                 result = this.metricsService.getMetrics();
             }
+            else if (name.startsWith('evolith-moscow')) {
+                result = await (0, moscow_1.handleMoscowTools)(name, args);
+            }
             else {
                 throw new Error(`Unknown tool: ${name}`);
             }
@@ -353,7 +637,6 @@ class EvolithMcpServer {
         catch (error) {
             const latencyMs = Date.now() - startTime;
             const message = error instanceof Error ? error.message : String(error);
-            this.logger.error(`Tool ${name} failed: ${message}`);
             this.metricsService.recordToolCall(name, latencyMs, false);
             this.metricsService.recordError(message.substring(0, 50));
             return {
@@ -367,47 +650,70 @@ class EvolithMcpServer {
             };
         }
     }
-}
-exports.EvolithMcpServer = EvolithMcpServer;
-async function handleConfigTools(name, args) {
-    const fs = await Promise.resolve().then(() => __importStar(require('fs-extra')));
-    const path = await Promise.resolve().then(() => __importStar(require('path')));
-    const yaml = await Promise.resolve().then(() => __importStar(require('yaml')));
-    const dir = args.dir || process.cwd();
-    const configPath = path.join(dir, 'evolith.yaml');
-    if (!(await fs.pathExists(configPath))) {
-        throw new Error('evolith.yaml not found');
-    }
-    const config = yaml.parse(await fs.readFile(configPath, 'utf-8'));
-    if (name === 'evolith-config-get') {
-        const key = args.key;
-        const keys = key.split('.');
-        let value = config;
-        for (const k of keys) {
-            value = value?.[k];
+    async handleConfigTools(name, args) {
+        const fs = await Promise.resolve().then(() => __importStar(require('fs-extra')));
+        const path = await Promise.resolve().then(() => __importStar(require('path')));
+        const yaml = await Promise.resolve().then(() => __importStar(require('yaml')));
+        const dir = args.dir || process.cwd();
+        const configPath = path.join(dir, 'evolith.yaml');
+        if (!(await fs.pathExists(configPath))) {
+            throw new Error('evolith.yaml not found');
         }
-        return { key, value: value ?? null };
-    }
-    else {
-        const key = args.key;
-        const value = args.value;
-        const keys = key.split('.');
-        let target = config;
-        for (let i = 0; i < keys.length - 1; i++) {
-            if (!target[keys[i]]) {
-                target[keys[i]] = {};
+        const config = yaml.parse(await fs.readFile(configPath, 'utf-8'));
+        if (name === 'evolith-config-get') {
+            const key = args.key;
+            const keys = key.split('.');
+            let value = config;
+            for (const k of keys) {
+                value = value?.[k];
             }
-            target = target[keys[i]];
+            return { key, value: value ?? null };
         }
-        target[keys[keys.length - 1]] = value;
-        await fs.writeFile(configPath, yaml.stringify(config));
-        return { key, value, updated: true };
+        else {
+            const key = args.key;
+            const value = args.value;
+            const keys = key.split('.');
+            let target = config;
+            for (let i = 0; i < keys.length - 1; i++) {
+                if (!target[keys[i]]) {
+                    target[keys[i]] = {};
+                }
+                target = target[keys[i]];
+            }
+            target[keys[keys.length - 1]] = value;
+            await fs.writeFile(configPath, yaml.stringify(config));
+            return { key, value, updated: true };
+        }
+    }
+    async handleListResources() {
+        const { listResources } = await Promise.resolve().then(() => __importStar(require('./resources')));
+        return listResources();
+    }
+    async handleReadResource(params) {
+        const { readResource } = await Promise.resolve().then(() => __importStar(require('./resources')));
+        return readResource(params);
     }
+    async handleListPrompts() {
+        const { listPrompts } = await Promise.resolve().then(() => __importStar(require('./prompts')));
+        return listPrompts();
+    }
+    async handleGetPrompt(params) {
+        const { getPrompt } = await Promise.resolve().then(() => __importStar(require('./prompts')));
+        return getPrompt(params);
+    }
+}
+function validateApiKey(apiKey, validKey) {
+    if (!validKey)
+        return true;
+    if (!apiKey)
+        return false;
+    return apiKey === validKey;
 }
 async function startMcpServer(options = {}) {
-    const server = new EvolithMcpServer(options);
     const transport = options.transport || 'stdio';
-    await server.connect(transport);
+    const port = options.port || 49100;
+    const server = new DirectMcpServer(transport, port, options.apiKey, options.rulesetValidator, options.metricsService);
+    await server.start();
     return server;
 }
 //# sourceMappingURL=server.js.map