fivocell 1.0.0

package/packages/mcp-server/dist/server.js

@@ -0,0 +1,213 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.app = void 0;
+const express_1 = __importDefault(require("express"));
+const http = __importStar(require("http"));
+const DAEMON_URL = 'http://localhost:9876';
+const MCP_PORT = 9877;
+const app = (0, express_1.default)();
+exports.app = app;
+app.use(express_1.default.json());
+async function daemonRequest(method, path, body) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(path, DAEMON_URL);
+        const req = http.request({
+            method,
+            hostname: url.hostname,
+            port: url.port,
+            path: url.pathname + url.search,
+            headers: { 'Content-Type': 'application/json' },
+            timeout: 5000,
+        }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => (data += chunk));
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(data));
+                }
+                catch {
+                    reject(new Error('Invalid JSON'));
+                }
+            });
+        });
+        req.on('error', reject);
+        if (body)
+            req.write(JSON.stringify(body));
+        req.end();
+    });
+}
+// MCP JSON-RPC endpoint
+app.post('/mcp', async (req, res) => {
+    const { method, params, id } = req.body;
+    try {
+        let result;
+        switch (method) {
+            case 'tools/list':
+                result = {
+                    tools: [
+                        {
+                            name: 'cell_get_taste_context',
+                            description: 'Get user coding taste for prompt injection. Returns compressed taste string.',
+                            inputSchema: {
+                                type: 'object',
+                                properties: {
+                                    language: { type: 'string', description: 'Programming language' },
+                                    framework: { type: 'string', description: 'Framework (optional)' },
+                                },
+                            },
+                        },
+                        {
+                            name: 'cell_send_signal',
+                            description: 'Send learning signal when user edits/rejects AI output',
+                            inputSchema: {
+                                type: 'object',
+                                properties: {
+                                    type: { type: 'string', enum: ['edit_diff', 'accept', 'reject', 'retry'] },
+                                    originalCode: { type: 'string' },
+                                    editedCode: { type: 'string' },
+                                    language: { type: 'string' },
+                                    framework: { type: 'string' },
+                                    fileType: { type: 'string' },
+                                },
+                                required: ['type', 'language'],
+                            },
+                        },
+                        {
+                            name: 'cell_get_profile',
+                            description: 'Get full taste profile with patterns and confidence scores',
+                            inputSchema: { type: 'object', properties: {} },
+                        },
+                        {
+                            name: 'cell_predict_next_action',
+                            description: 'Predict next action based on context',
+                            inputSchema: {
+                                type: 'object',
+                                properties: { context: { type: 'string' } },
+                            },
+                        },
+                        {
+                            name: 'cell_check_build',
+                            description: 'Check for potential build failures',
+                            inputSchema: {
+                                type: 'object',
+                                properties: { files: { type: 'string' } },
+                            },
+                        },
+                    ],
+                };
+                break;
+            case 'tools/call':
+                switch (params?.name) {
+                    case 'cell_get_taste_context': {
+                        const q = new URLSearchParams();
+                        if (params.arguments?.language)
+                            q.set('language', params.arguments.language);
+                        if (params.arguments?.framework)
+                            q.set('framework', params.arguments.framework);
+                        result = await daemonRequest('GET', `/taste/context?${q}`);
+                        break;
+                    }
+                    case 'cell_send_signal':
+                        result = await daemonRequest('POST', '/signal', {
+                            type: params.arguments?.type,
+                            originalCode: params.arguments?.originalCode || '',
+                            editedCode: params.arguments?.editedCode || '',
+                            context: {
+                                language: params.arguments?.language || '',
+                                framework: params.arguments?.framework || '',
+                                fileType: params.arguments?.fileType || '',
+                                strictness: 'standard',
+                                projectId: 'mcp-session',
+                            },
+                        });
+                        break;
+                    case 'cell_get_profile':
+                        result = await daemonRequest('GET', '/taste/profile');
+                        break;
+                    case 'cell_predict_next_action':
+                        result = await daemonRequest('GET', `/predict/next-action?context=${encodeURIComponent(params.arguments?.context || '')}`);
+                        break;
+                    case 'cell_check_build':
+                        result = await daemonRequest('GET', `/predict/build-failure?files=${encodeURIComponent(params.arguments?.files || '')}`);
+                        break;
+                    default:
+                        result = { error: `unknown tool: ${params?.name}` };
+                }
+                break;
+            case 'resources/list':
+                result = {
+                    resources: [
+                        { uri: 'cell://taste/profile', name: 'Taste Profile', description: 'Full taste profile' },
+                        { uri: 'cell://community/stats', name: 'Community Stats', description: 'Aggregate community patterns' },
+                        { uri: 'cell://team/composite', name: 'Team Composite', description: 'Team taste composite' },
+                        { uri: 'cell://health', name: 'Health', description: 'Daemon health status' },
+                    ],
+                };
+                break;
+            case 'resources/read':
+                switch (params?.uri) {
+                    case 'cell://taste/profile':
+                        result = await daemonRequest('GET', '/taste/profile');
+                        break;
+                    case 'cell://community/stats':
+                        result = await daemonRequest('GET', '/community/prior');
+                        break;
+                    case 'cell://team/composite':
+                        result = await daemonRequest('GET', '/team/composite');
+                        break;
+                    case 'cell://health':
+                        result = await daemonRequest('GET', '/health');
+                        break;
+                    default: result = { error: `unknown resource: ${params?.uri}` };
+                }
+                break;
+            default:
+                result = { error: `unknown method: ${method}` };
+        }
+        res.json({ jsonrpc: '2.0', id, result });
+    }
+    catch (err) {
+        res.json({ jsonrpc: '2.0', id, error: { code: -1, message: err.message } });
+    }
+});
+app.get('/health', (_req, res) => { res.json({ status: 'ok', daemon: DAEMON_URL }); });
+app.listen(MCP_PORT, () => {
+    console.log(`Cell MCP Server running on http://localhost:${MCP_PORT}`);
+    console.log(`MCP endpoint: http://localhost:${MCP_PORT}/mcp`);
+});