@evolith/smart-cli 0.0.3-beta → 1.0.0

package/dist/core/mcp/server.js

@@ -1,719 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-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 moscow_1 = require("./tools/moscow");
-const metrics_service_1 = require("./metrics.service");
-class MinimalStdioTransport {
-    constructor(stdin, stdout) {
-        this.readBuffer = '';
-        this.stdin = stdin || process.stdin;
-        this.stdout = stdout || process.stdout;
-        this.readBuffer = '';
-        this.started = false;
-    }
-    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();
-            });
-        });
-    }
-}
-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 start() {
-        if (this.started)
-            return;
-        this.started = true;
-        this.server = http.createServer((req, res) => {
-            this.handleRequest(req, res);
-        });
-        this.server.on('error', (error) => {
-            this.logger.error(`HTTP server error: ${error.message}`);
-            if (this.onerror) {
-                this.onerror(error);
-            }
-        });
-        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);
-            }
-        }
-        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();
-        });
-        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' }));
-            }
-        });
-        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' }));
-            }
-        });
-    }
-    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': '*',
-        });
-        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.debug(`SSE client connected: ${clientId}`);
-    }
-}
-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 {
-            this.transport = new MinimalStdioTransport();
-        }
-    }
-    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}`);
-        }
-    }
-    handleListTools() {
-        return {
-            tools: [
-                {
-                    name: 'evolith-validate',
-                    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' },
-                            corePath: { type: 'string', description: 'Path to Evolith Core' },
-                        },
-                        required: ['path'],
-                    },
-                },
-                {
-                    name: 'evolith-agent-install',
-                    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: 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',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            dir: { type: 'string', description: 'Directory to search' },
-                        },
-                    },
-                },
-                {
-                    name: 'evolith-agent-validate',
-                    description: 'Validate a specific agent ruleset',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string' },
-                            dir: { type: 'string' },
-                        },
-                        required: ['name'],
-                    },
-                },
-                {
-                    name: 'evolith-agent-upgrade',
-                    description: 'Upgrade an existing Evolith agent',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string' },
-                            dir: { type: 'string' },
-                        },
-                        required: ['name'],
-                    },
-                },
-                {
-                    name: 'evolith-agent-remove',
-                    description: 'Remove an Evolith agent',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string' },
-                            dir: { type: 'string' },
-                        },
-                        required: ['name'],
-                    },
-                },
-                {
-                    name: 'evolith-architecture-validate',
-                    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' },
-                            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'],
-                    },
-                },
-                {
-                    name: 'evolith-sdlc-handoff',
-                    description: 'Generate SDLC phase handoff artifact manifest',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            path: { type: 'string' },
-                            fromPhase: { type: 'string' },
-                            toPhase: { type: 'string' },
-                        },
-                        required: ['path', 'fromPhase', 'toPhase'],
-                    },
-                },
-                {
-                    name: 'evolith-sdlc-status',
-                    description: 'Show current SDLC phase gate status',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            path: { type: 'string' },
-                        },
-                        required: ['path'],
-                    },
-                },
-                {
-                    name: 'evolith-config-get',
-                    description: 'Get Evolith configuration value',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            key: { type: 'string' },
-                            dir: { type: 'string' },
-                        },
-                        required: ['key'],
-                    },
-                },
-                {
-                    name: 'evolith-config-set',
-                    description: 'Set Evolith configuration value',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            key: { type: 'string' },
-                            value: { type: 'string' },
-                            dir: { type: 'string' },
-                        },
-                        required: ['key', 'value'],
-                    },
-                },
-                {
-                    name: 'evolith-metrics',
-                    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(params) {
-        const name = params.name;
-        const args = params.arguments || {};
-        const startTime = Date.now();
-        try {
-            let result;
-            if (name === 'evolith-validate') {
-                result = await (0, validate_1.handleValidateTool)(args, this.rulesetValidator);
-            }
-            else if (name.startsWith('evolith-agent')) {
-                result = await (0, agent_1.handleAgentTools)(name, args);
-            }
-            else if (name === 'evolith-architecture-validate') {
-                result = await (0, architecture_1.handleArchitectureTools)(args);
-            }
-            else if (name.startsWith('evolith-sdlc')) {
-                result = await (0, sdlc_1.handleSdlcTools)(name, args);
-            }
-            else if (name === 'evolith-config-get' || name === 'evolith-config-set') {
-                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}`);
-            }
-            const latencyMs = Date.now() - startTime;
-            this.metricsService.recordToolCall(name, latencyMs, true);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: typeof result === 'string' ? result : JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            const latencyMs = Date.now() - startTime;
-            const message = error instanceof Error ? error.message : String(error);
-            this.metricsService.recordToolCall(name, latencyMs, false);
-            this.metricsService.recordError(message.substring(0, 50));
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ error: true, message }),
-                    },
-                ],
-                isError: true,
-            };
-        }
-    }
-    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');
-        }
-        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];
-            }
-            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]] = {};
-                }
-                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 transport = options.transport || 'stdio';
-    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