fivocell 1.0.4 → 2.0.0

package/dist/mcp-server.js

@@ -0,0 +1,1120 @@
+"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.RESOURCES = exports.TOOLS = void 0;
+exports.startMCPServer = startMCPServer;
+const http = __importStar(require("http"));
+const senior_features_1 = require("./senior-features");
+const prompt_builder_1 = require("./core/prompt-builder");
+const database_1 = require("./core/database");
+const session_memory_1 = require("./core/session-memory");
+const DAEMON_URL = 'http://localhost:9876';
+const MCP_PORT = 9877;
+let daemonEnsuredAt = 0;
+let daemonEnsuring = null;
+const DAEMON_RECHECK_MS = 30000;
+async function ensureDaemonForMCP() {
+    const now = Date.now();
+    if (daemonEnsuring)
+        return daemonEnsuring;
+    if (now - daemonEnsuredAt < DAEMON_RECHECK_MS)
+        return true;
+    const { ensureDaemon } = require('./daemon/lifecycle');
+    const p = ensureDaemon({ silent: true }).finally(() => {
+        daemonEnsuring = null;
+    });
+    daemonEnsuring = p;
+    const ok = await p;
+    if (ok)
+        daemonEnsuredAt = Date.now();
+    return ok;
+}
+function daemonRequest(method, path, body) {
+    return new Promise(async (resolve, reject) => {
+        if (path !== '/health') {
+            const ok = await ensureDaemonForMCP();
+            if (!ok) {
+                reject(new Error('Cell daemon is not running and could not be started. Run `cell start` or `cell daemon install-service`.'));
+                return;
+            }
+        }
+        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: 15000,
+        }, (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', (err) => {
+            daemonEnsuredAt = 0;
+            reject(err);
+        });
+        if (body)
+            req.write(JSON.stringify(body));
+        req.end();
+    });
+}
+exports.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' } },
+        },
+    },
+    {
+        name: 'cell_community_stats',
+        description: 'Get community intelligence stats — pattern count, developer count, total outcomes',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_community_rankings',
+        description: 'Get community-wide pattern rankings by category',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: { type: 'number', description: 'Max entries per category (default: 10)' },
+            },
+        },
+    },
+    {
+        name: 'cell_community_trends',
+        description: 'Get rising/declining pattern trends across the community',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: { type: 'number', description: 'Max trends (default: 20)' },
+            },
+        },
+    },
+    {
+        name: 'cell_community_insights',
+        description: 'Get actionable community insights — adoption, language-specific best patterns',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_community_playbooks',
+        description: 'Get community-generated playbooks for specific categories',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                category: { type: 'string', description: 'Filter by category (optional)' },
+            },
+        },
+    },
+    {
+        name: 'cell_community_reputation',
+        description: 'Get top community pattern entries by reputation score',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: { type: 'number', description: 'Max entries (default: 20)' },
+            },
+        },
+    },
+    {
+        name: 'cell_org_benchmarks',
+        description: 'Get organization-wide benchmarks — success rate, testing adoption, CI adoption per team',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orgId: { type: 'string', description: 'Organization ID' },
+            },
+            required: ['orgId'],
+        },
+    },
+    {
+        name: 'cell_org_silos',
+        description: 'Detect knowledge silos within an organization',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orgId: { type: 'string', description: 'Organization ID' },
+            },
+            required: ['orgId'],
+        },
+    },
+    {
+        name: 'cell_org_bus_factor',
+        description: 'Compute bus factor — identifies patterns owned by too few members',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orgId: { type: 'string', description: 'Organization ID' },
+            },
+            required: ['orgId'],
+        },
+    },
+    {
+        name: 'cell_org_risks',
+        description: 'Get team-level risk reports for an organization',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orgId: { type: 'string', description: 'Organization ID' },
+            },
+            required: ['orgId'],
+        },
+    },
+    {
+        name: 'cell_org_insights',
+        description: 'Get executive insights for an organization',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orgId: { type: 'string', description: 'Organization ID' },
+            },
+            required: ['orgId'],
+        },
+    },
+    {
+        name: 'cell_org_playbooks',
+        description: 'Get organization-specific playbooks',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orgId: { type: 'string', description: 'Organization ID' },
+            },
+            required: ['orgId'],
+        },
+    },
+    {
+        name: 'cell_intelligence_score',
+        description: 'Compute a developer\'s intelligence score across 7 dimensions (outcome, confidence, health, project, community, org, knowledge)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                developerId: { type: 'string', description: 'Developer ID' },
+                patterns: { type: 'array', description: 'Array of patterns' },
+                outcomesMap: { type: 'object', description: 'Pattern outcomes map', additionalProperties: true },
+                communityStats: { type: 'object', description: 'Community statistics', additionalProperties: true },
+                orgStats: { type: 'object', description: 'Organization statistics', additionalProperties: true },
+                projectDNA: { type: 'object', description: 'Project DNA profile', additionalProperties: true },
+                weights: { type: 'object', description: 'Optional dimension weights', additionalProperties: true },
+            },
+            required: ['developerId', 'patterns'],
+        },
+    },
+    {
+        name: 'cell_analyze_risks',
+        description: 'Analyze risks with root cause, probability, impact, and recommendations',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                developerId: { type: 'string' },
+                teamId: { type: 'string' },
+                orgId: { type: 'string' },
+                patterns: { type: 'array' },
+                outcomesMap: { type: 'object' },
+                teamProfiles: { type: 'array' },
+                orgBenchmarks: { type: 'array' },
+                knowledgeGaps: { type: 'array' },
+            },
+            required: ['developerId', 'patterns'],
+        },
+    },
+    {
+        name: 'cell_find_opportunities',
+        description: 'Find improvement opportunities — success, testing, CI, code review, community adoption',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                developerId: { type: 'string' },
+                patterns: { type: 'array' },
+                outcomesMap: { type: 'object' },
+                projectDNA: { type: 'object' },
+                communityStats: { type: 'object' },
+                orgBenchmarks: { type: 'array' },
+            },
+            required: ['developerId', 'patterns'],
+        },
+    },
+    {
+        name: 'cell_generate_decisions',
+        description: 'Generate priority-ranked decisions from risks, opportunities, and knowledge gaps',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                developerId: { type: 'string' },
+                patterns: { type: 'array' },
+                risks: { type: 'array' },
+                opportunities: { type: 'array' },
+                knowledgeGaps: { type: 'array' },
+                orgBenchmarks: { type: 'array' },
+            },
+            required: ['developerId'],
+        },
+    },
+    {
+        name: 'cell_intelligence_report',
+        description: 'Generate a full intelligence report with score, strengths, weaknesses, and recommended actions',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                developerId: { type: 'string' },
+                intelligenceScore: { type: 'object' },
+                risks: { type: 'array' },
+                opportunities: { type: 'array' },
+                decisions: { type: 'array' },
+                knowledgeGaps: { type: 'array' },
+                benchmarks: { type: 'array' },
+                lifecycles: { type: 'array' },
+            },
+            required: ['developerId', 'intelligenceScore'],
+        },
+    },
+    {
+        name: 'cell_get_recommendations',
+        description: 'Get personalized pattern recommendations based on developer profile and similar developers',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                developerId: { type: 'string', description: 'Developer ID' },
+                patterns: { type: 'array', description: 'All patterns' },
+                outcomesMap: { type: 'object', description: 'Pattern outcomes map' },
+                allProfiles: { type: 'object', description: 'All developer profiles map' },
+            },
+            required: ['developerId', 'patterns'],
+        },
+    },
+    {
+        name: 'cell_outcome_leaderboard',
+        description: 'Get pattern outcome leaderboard — top patterns by evidence-based confidence',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                minEvents: { type: 'number', description: 'Minimum events (default: 0)' },
+                limit: { type: 'number', description: 'Max entries (default: 20)' },
+            },
+        },
+    },
+    {
+        name: 'cell_project_dna',
+        description: 'Build or get Project DNA profile for a repository path',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectPath: { type: 'string', description: 'Absolute path to project' },
+            },
+            required: ['projectPath'],
+        },
+    },
+    {
+        name: 'cell_get_stack_summary',
+        description: 'Get detected stack: language, frameworks, libraries, tools, and confidence score',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_lint_style',
+        description: 'Lint a code snippet for style match against community best practices (returns match %, off-brand patterns, suggestions)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: { type: 'string', description: 'File path or name' },
+                code: { type: 'string', description: 'Code content to lint' },
+            },
+            required: ['file', 'code'],
+        },
+    },
+    {
+        name: 'cell_suggest_pattern',
+        description: 'Suggest community-validated pattern for a given file and context (returns suggestion, adoption %, top-dev usage)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: { type: 'string', description: 'File path or name' },
+                context: { type: 'string', description: 'Context tag: testing, async, validation, error, state, api, types, import' },
+            },
+            required: ['file', 'context'],
+        },
+    },
+    {
+        name: 'cell_predict_next_file',
+        description: 'Predict the next file the developer will likely create or edit, based on workflow history',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_daily_brief',
+        description: 'Get a daily brief: yesterday summary (patterns, files, signals), today predictions, weekly trend',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_inject_context',
+        description: 'Inject your complete developer context — style, patterns, blind spots, predictions. Use @cell in any AI tool.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectPath: { type: 'string', description: 'Optional — project path for specific context' },
+                toolName: { type: 'string', description: 'Optional — AI tool name (cursor, claude, windsurf, copilot, antigravity)' },
+                compact: { type: 'boolean', description: 'Compact format for prompt injection (default: false)' },
+            },
+        },
+    },
+    {
+        name: 'cell_session_start',
+        description: 'Start a new session with tool name and project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                toolName: { type: 'string', description: 'AI tool name (cursor, claude, windsurf, etc.)' },
+                project: { type: 'string', description: 'Project name or path' },
+            },
+            required: ['toolName', 'project'],
+        },
+    },
+    {
+        name: 'cell_session_end',
+        description: 'End a session with files touched and key decisions',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sessionId: { type: 'number', description: 'Session ID from cell_session_start' },
+                filesTouched: { type: 'array', items: { type: 'string' }, description: 'Files worked on' },
+                keyDecisions: { type: 'array', items: { type: 'string' }, description: 'Key decisions made' },
+                contextSnapshot: { type: 'string', description: 'Summary of what was done' },
+            },
+            required: ['sessionId'],
+        },
+    },
+    {
+        name: 'cell_get_sessions',
+        description: 'Get recent cross-tool session history with decisions and context chains',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: { type: 'number', description: 'Max sessions (default 10)' },
+                project: { type: 'string', description: 'Filter by project' },
+            },
+        },
+    },
+    {
+        name: 'cell_predict',
+        description: 'Get all predictive intelligence — pre-failures, decision regrets, scope creep, energy, stack warnings',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: { type: 'string', description: 'Filter by project' },
+                type: { type: 'string', description: 'Filter: pre_failure|decision_regret|complexity_trap|scope_creep|energy|stack' },
+            },
+        },
+    },
+    {
+        name: 'cell_predict_risk',
+        description: 'Calculate risk score for a specific file based on bug history, recurrence, and touch frequency',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: { type: 'string', description: 'File path to assess risk for' },
+            },
+            required: ['file'],
+        },
+    },
+    {
+        name: 'cell_predict_time',
+        description: 'Estimate completion time for a feature based on historical session data',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                feature: { type: 'string', description: 'Feature or task name to estimate' },
+            },
+            required: ['feature'],
+        },
+    },
+    {
+        name: 'cell_tool_compare',
+        description: 'Compare all AI tools — acceptance rate, best/worst tasks, recommendations',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_tool_suggest',
+        description: 'Suggest best AI tool for a specific task type',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                taskType: { type: 'string', description: 'Task type (e.g., debugging, architecture, boilerplate)' },
+            },
+            required: ['taskType'],
+        },
+    },
+    {
+        name: 'cell_model_history',
+        description: 'Per-model interaction history — sessions, files, decisions',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_tool_context',
+        description: 'Show tool-specific @cell context for an AI tool',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                toolName: { type: 'string', description: 'AI tool name (cursor, claude, antigravity, etc.)' },
+            },
+            required: ['toolName'],
+        },
+    },
+    {
+        name: 'cell_team_health',
+        description: 'Get team health score — bus factor, silos, skill gaps, strengths',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: { type: 'string', description: 'Filter by project' },
+            },
+        },
+    },
+    {
+        name: 'cell_team_silos',
+        description: 'Detect knowledge silos and single points of failure',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_team_style',
+        description: 'Show merged team coding style — stack, patterns, conventions',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: { type: 'string', description: 'Filter by project' },
+            },
+        },
+    },
+    {
+        name: 'cell_team_retro',
+        description: 'Auto-generate sprint retrospective from git + pattern data',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                days: { type: 'number', description: 'Lookback period in days (default 14)' },
+                project: { type: 'string', description: 'Filter by project' },
+            },
+        },
+    },
+    {
+        name: 'cell_team_onboard',
+        description: 'Generate onboarding package for a new team member',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                teamName: { type: 'string', description: 'Team name' },
+                project: { type: 'string', description: 'Filter by project' },
+            },
+            required: ['teamName'],
+        },
+    },
+    {
+        name: 'cell_handoff',
+        description: 'Generate context handoff for team member transition',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                from: { type: 'string', description: 'Person handing off' },
+                to: { type: 'string', description: 'Person receiving' },
+                project: { type: 'string', description: 'Project name' },
+            },
+            required: ['from', 'to', 'project'],
+        },
+    },
+    {
+        name: 'cell_community_compare',
+        description: 'Compare personal skills against community benchmarks',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_community_trends',
+        description: 'Show technology and pattern trends from community',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_community_insights',
+        description: 'Actionable community insights — benchmarks, blind spots, trends',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_community_stats',
+        description: 'Community overview — developers, patterns, languages',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_rhythm',
+        description: 'Show coding rhythm — best hours, best days, flow patterns',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_burnout',
+        description: 'Check for burnout signals — error rate, session length, reverts',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_mastery',
+        description: 'Technology mastery map — per-language progress and confidence',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_growth',
+        description: 'Career trajectory — current level, senior readiness, recommendations',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_insights_weekly',
+        description: 'Weekly digest — sessions, bugs, decisions, highlights',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_health',
+        description: 'System health — DB status, memory, uptime, platform',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_metrics',
+        description: 'System metrics — queries/sec, patterns, sessions, DB tables',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_security',
+        description: 'Security status — auth token, rate limits, encryption',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_backup',
+        description: 'Create backup of cell database',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_optimize',
+        description: 'Optimize database — VACUUM, ANALYZE, prune',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_debug_style',
+        description: 'Debugging style — console.log vs debugger, efficiency, recommendations',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_prompt_style',
+        description: 'Prompt style — length, structure, iteration patterns',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_focus',
+        description: 'Focus analysis — deep work, shallow work, tab switching',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_ide_insights',
+        description: 'Full IDE intelligence — debug, prompt, focus, copy-paste, refactor combined',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_cloud_status',
+        description: 'Cloud sync status — pending, sent, failed, device ID',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cell_cloud_validate',
+        description: 'Validate payload for cloud — forbidden fields + 300-byte limit',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                data: { type: 'object', description: 'Payload to validate' },
+            },
+            required: ['data'],
+        },
+    },
+    {
+        name: 'cell_cloud_queue',
+        description: 'Offline sync queue — pending, failed, retryable',
+        inputSchema: { type: 'object', properties: {} },
+    },
+];
+exports.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://community/v2/stats', name: 'Community Intelligence Stats', description: 'Full community intelligence statistics' },
+    { uri: 'cell://community/v2/insights', name: 'Community Insights', description: 'Actionable community insights' },
+    { uri: 'cell://team/composite', name: 'Team Composite', description: 'Team taste composite' },
+    { uri: 'cell://org/v2/benchmarks', name: 'Org Benchmarks', description: 'Organization-wide benchmarks' },
+    { uri: 'cell://intelligence/reports', name: 'Intelligence Reports', description: 'All generated intelligence reports' },
+    { uri: 'cell://health', name: 'Health', description: 'Daemon health status' },
+];
+function startMCPServer(port = MCP_PORT) {
+    const server = http.createServer(async (req, res) => {
+        if (req.method === 'GET' && req.url === '/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'ok', daemon: DAEMON_URL }));
+            return;
+        }
+        if (req.method !== 'POST' || req.url !== '/mcp') {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Not found. POST to /mcp for JSON-RPC.' }));
+            return;
+        }
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(chunk));
+        req.on('end', async () => {
+            const body = Buffer.concat(chunks).toString().replace(/^\uFEFF/, '');
+            let rpc;
+            try {
+                rpc = JSON.parse(body);
+            }
+            catch {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -1, message: 'Invalid JSON' } }));
+                return;
+            }
+            const { method, params, id } = rpc;
+            try {
+                let result;
+                switch (method) {
+                    case 'initialize':
+                        result = {
+                            protocolVersion: params?.protocolVersion || '2024-11-05',
+                            capabilities: {
+                                tools: { listChanged: false },
+                                resources: { subscribe: false, listChanged: false },
+                            },
+                            serverInfo: {
+                                name: 'fivo-cell',
+                                version: '1.0.5',
+                            },
+                        };
+                        break;
+                    case 'notifications/initialized':
+                        res.writeHead(204);
+                        res.end();
+                        return;
+                    case 'ping':
+                        result = {};
+                        break;
+                    case 'tools/list':
+                        result = { tools: exports.TOOLS };
+                        break;
+                    case 'tools/call':
+                        result = await handleToolCall(params);
+                        break;
+                    case 'resources/list':
+                        result = { resources: exports.RESOURCES };
+                        break;
+                    case 'resources/templates/list':
+                        result = { resourceTemplates: [] };
+                        break;
+                    case 'resources/read':
+                        result = await handleResourceRead(params);
+                        break;
+                    default:
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({
+                            jsonrpc: '2.0',
+                            id,
+                            error: { code: -32601, message: `Method not found: ${method}` },
+                        }));
+                        return;
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ jsonrpc: '2.0', id, result }));
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ jsonrpc: '2.0', id, error: { code: -1, message } }));
+            }
+        });
+    });
+    server.listen(port, () => {
+        console.log(`Cell MCP Server running on http://localhost:${port}`);
+        console.log(`MCP endpoint: http://localhost:${port}/mcp`);
+    });
+    return server;
+}
+async function handleToolCall(params) {
+    const name = params?.name;
+    const args = params?.arguments || {};
+    switch (name) {
+        case 'cell_get_taste_context': {
+            const q = new URLSearchParams();
+            if (args.language)
+                q.set('language', args.language);
+            if (args.framework)
+                q.set('framework', args.framework);
+            return daemonRequest('GET', `/taste/context?${q.toString()}`);
+        }
+        case 'cell_send_signal':
+            return daemonRequest('POST', '/signal', {
+                type: args.type,
+                originalCode: args.originalCode || '',
+                editedCode: args.editedCode || '',
+                context: {
+                    language: args.language || '',
+                    framework: args.framework || '',
+                    fileType: args.fileType || '',
+                    strictness: 'standard',
+                    projectId: 'mcp-session',
+                },
+            });
+        case 'cell_get_profile':
+            return daemonRequest('GET', '/taste/profile');
+        case 'cell_predict_next_action':
+            return daemonRequest('GET', `/predict/next-action?context=${encodeURIComponent(args.context || '')}`);
+        case 'cell_check_build':
+            return daemonRequest('GET', `/predict/build-failure?files=${encodeURIComponent(args.files || '')}`);
+        case 'cell_community_stats':
+            return daemonRequest('GET', '/community/v2/stats');
+        case 'cell_community_rankings':
+            return daemonRequest('GET', `/community/v2/rankings?limit=${args.limit || 10}`);
+        case 'cell_community_trends':
+            return daemonRequest('GET', `/community/v2/trends?limit=${args.limit || 20}`);
+        case 'cell_community_insights':
+            return daemonRequest('GET', '/community/v2/insights');
+        case 'cell_community_playbooks':
+            return daemonRequest('POST', '/community/v2/playbooks', { developerProfiles: args.developerProfiles || [] });
+        case 'cell_community_reputation':
+            return daemonRequest('GET', `/community/v2/reputation?limit=${args.limit || 20}`);
+        case 'cell_org_benchmarks':
+            return daemonRequest('POST', `/org/v2/${args.orgId}/benchmarks`, {});
+        case 'cell_org_silos':
+            return daemonRequest('GET', `/org/v2/${args.orgId}/silos`);
+        case 'cell_org_bus_factor':
+            return daemonRequest('GET', `/org/v2/${args.orgId}/bus-factor`);
+        case 'cell_org_risks':
+            return daemonRequest('GET', `/org/v2/${args.orgId}/risks`);
+        case 'cell_org_insights':
+            return daemonRequest('GET', `/org/v2/${args.orgId}/insights`);
+        case 'cell_org_playbooks':
+            return daemonRequest('GET', `/org/v2/${args.orgId}/playbooks`);
+        case 'cell_intelligence_score':
+            return daemonRequest('POST', '/intelligence/score', args);
+        case 'cell_analyze_risks':
+            return daemonRequest('POST', '/intelligence/risks', args);
+        case 'cell_find_opportunities':
+            return daemonRequest('POST', '/intelligence/opportunities', args);
+        case 'cell_generate_decisions':
+            return daemonRequest('POST', '/intelligence/decisions', args);
+        case 'cell_intelligence_report':
+            return daemonRequest('POST', '/intelligence/report', args);
+        case 'cell_get_recommendations':
+            return daemonRequest('POST', '/recommendations', {
+                developerId: args.developerId,
+                patterns: args.patterns || [],
+                outcomesMap: args.outcomesMap || {},
+                allProfiles: args.allProfiles || {},
+            });
+        case 'cell_outcome_leaderboard':
+            return daemonRequest('GET', `/outcomes/leaderboard?minEvents=${args.minEvents || 0}&limit=${args.limit || 20}`);
+        case 'cell_project_dna':
+            return daemonRequest('POST', '/project/dna-build', { projectPath: args.projectPath });
+        case 'cell_get_stack_summary':
+            return await (0, senior_features_1.getStackSummary)();
+        case 'cell_lint_style':
+            return await (0, senior_features_1.lintStyle)(args.file || 'unknown', args.code || '');
+        case 'cell_suggest_pattern':
+            return await (0, senior_features_1.suggestPattern)(args.file || 'unknown', args.context || '');
+        case 'cell_predict_next_file':
+            return await (0, senior_features_1.predictNextFile)();
+        case 'cell_daily_brief':
+            return await (0, senior_features_1.getDailyBrief)();
+        case 'cell_inject_context': {
+            (0, database_1.initializeDatabase)();
+            const ctx = (0, prompt_builder_1.buildContext)(args.projectPath, args.toolName);
+            const formatted = (0, prompt_builder_1.formatContextForInjection)(ctx, args.compact);
+            return {
+                content: [{ type: 'text', text: formatted }],
+                context: ctx,
+            };
+        }
+        case 'cell_session_start': {
+            (0, database_1.initializeDatabase)();
+            const sm = new session_memory_1.SessionMemory();
+            const sessionId = sm.startSession(args.toolName, args.project);
+            return { sessionId };
+        }
+        case 'cell_session_end': {
+            (0, database_1.initializeDatabase)();
+            const sm = new session_memory_1.SessionMemory();
+            sm.endSession(args.sessionId, {
+                filesTouched: args.filesTouched,
+                keyDecisions: args.keyDecisions,
+                contextSnapshot: args.contextSnapshot,
+            });
+            return { ended: true };
+        }
+        case 'cell_get_sessions': {
+            (0, database_1.initializeDatabase)();
+            const sm = new session_memory_1.SessionMemory();
+            const sessions = sm.getRecentSessions(args.limit || 10);
+            const stats = sm.getSessionStats();
+            const chain = sm.buildContextChain();
+            return { sessions, stats, contextChain: chain };
+        }
+        case 'cell_predict': {
+            const { getAllPredictions } = await Promise.resolve().then(() => __importStar(require('./predictive-intelligence')));
+            const predictions = getAllPredictions(args.project);
+            const filtered = args.type ? predictions.filter((p) => p.type === args.type) : predictions;
+            return { predictions: filtered, count: filtered.length };
+        }
+        case 'cell_predict_risk': {
+            const { calculateFileRisk } = await Promise.resolve().then(() => __importStar(require('./predictive-intelligence')));
+            return calculateFileRisk(args.file);
+        }
+        case 'cell_predict_time': {
+            const { estimateFeatureTime } = await Promise.resolve().then(() => __importStar(require('./predictive-intelligence')));
+            return estimateFeatureTime(args.feature);
+        }
+        case 'cell_tool_compare': {
+            const { compareTools } = await Promise.resolve().then(() => __importStar(require('./cross-model-memory')));
+            return { tools: compareTools() };
+        }
+        case 'cell_tool_suggest': {
+            const { suggestTool } = await Promise.resolve().then(() => __importStar(require('./cross-model-memory')));
+            return { suggestions: suggestTool(args.taskType) };
+        }
+        case 'cell_model_history': {
+            const { getModelHistory } = await Promise.resolve().then(() => __importStar(require('./cross-model-memory')));
+            return { history: getModelHistory() };
+        }
+        case 'cell_tool_context': {
+            const { buildToolSpecificContext } = await Promise.resolve().then(() => __importStar(require('./cross-model-memory')));
+            return { context: buildToolSpecificContext(args.toolName) };
+        }
+        case 'cell_team_health': {
+            const { getTeamHealth } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
+            return getTeamHealth(args.project);
+        }
+        case 'cell_team_silos': {
+            const { detectKnowledgeSilos, calculateBusFactor, suggestKnowledgeTransfer } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
+            return { silos: detectKnowledgeSilos(), busFactor: calculateBusFactor(), transfers: suggestKnowledgeTransfer() };
+        }
+        case 'cell_team_style': {
+            const { composeTeamStyle } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
+            return composeTeamStyle(args.project);
+        }
+        case 'cell_team_retro': {
+            const { generateSprintRetro } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
+            return generateSprintRetro(args.days || 14, args.project);
+        }
+        case 'cell_team_onboard': {
+            const { generateOnboardingDoc } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
+            return generateOnboardingDoc(args.teamName, args.project);
+        }
+        case 'cell_handoff': {
+            const { generateHandoff } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
+            return generateHandoff(args.from, args.to, args.project);
+        }
+        case 'cell_community_compare': {
+            const { benchmarkPersonal, benchmarkBlindSpots } = await Promise.resolve().then(() => __importStar(require('./community-v2')));
+            return { benchmarks: benchmarkPersonal(), blindSpots: benchmarkBlindSpots() };
+        }
+        case 'cell_community_trends': {
+            const { detectTrends, getCommunityStats } = await Promise.resolve().then(() => __importStar(require('./community-v2')));
+            return { trends: detectTrends(), stats: getCommunityStats() };
+        }
+        case 'cell_community_insights': {
+            const { generateInsights } = await Promise.resolve().then(() => __importStar(require('./community-v2')));
+            return { insights: generateInsights() };
+        }
+        case 'cell_community_stats': {
+            const { getCommunityStats } = await Promise.resolve().then(() => __importStar(require('./community-v2')));
+            return getCommunityStats();
+        }
+        case 'cell_rhythm': {
+            const { detectCodingRhythm } = await Promise.resolve().then(() => __importStar(require('./personal-intelligence')));
+            return detectCodingRhythm();
+        }
+        case 'cell_burnout': {
+            const { detectBurnout } = await Promise.resolve().then(() => __importStar(require('./personal-intelligence')));
+            return detectBurnout();
+        }
+        case 'cell_mastery': {
+            const { getTechMasteryMap } = await Promise.resolve().then(() => __importStar(require('./personal-intelligence')));
+            return { mastery: getTechMasteryMap() };
+        }
+        case 'cell_growth': {
+            const { getCareerTrajectory } = await Promise.resolve().then(() => __importStar(require('./personal-intelligence')));
+            return getCareerTrajectory();
+        }
+        case 'cell_insights_weekly': {
+            const { generateWeeklyDigest } = await Promise.resolve().then(() => __importStar(require('./personal-intelligence')));
+            return generateWeeklyDigest();
+        }
+        case 'cell_health': {
+            const { getHealthStatus } = await Promise.resolve().then(() => __importStar(require('./production')));
+            return getHealthStatus();
+        }
+        case 'cell_metrics': {
+            const { getMetrics } = await Promise.resolve().then(() => __importStar(require('./production')));
+            return getMetrics();
+        }
+        case 'cell_security': {
+            const { generateToken } = await Promise.resolve().then(() => __importStar(require('./production')));
+            const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+            const pathMod = await Promise.resolve().then(() => __importStar(require('path')));
+            const osMod = await Promise.resolve().then(() => __importStar(require('os')));
+            const secFile = pathMod.join(osMod.homedir(), '.fivo', 'cell', 'security.json');
+            if (fs.existsSync(secFile)) {
+                return JSON.parse(fs.readFileSync(secFile, 'utf-8'));
+            }
+            return { error: 'no security config found' };
+        }
+        case 'cell_backup': {
+            const { autoBackup } = await Promise.resolve().then(() => __importStar(require('./production')));
+            return autoBackup();
+        }
+        case 'cell_optimize': {
+            const { optimizeDatabase } = await Promise.resolve().then(() => __importStar(require('./production')));
+            return optimizeDatabase();
+        }
+        case 'cell_debug_style': {
+            const { initializeIDETables, getDebugStyle } = await Promise.resolve().then(() => __importStar(require('./ide-intelligence')));
+            initializeIDETables();
+            return getDebugStyle();
+        }
+        case 'cell_prompt_style': {
+            const { initializeIDETables, getPromptStyle } = await Promise.resolve().then(() => __importStar(require('./ide-intelligence')));
+            initializeIDETables();
+            return getPromptStyle();
+        }
+        case 'cell_focus': {
+            const { initializeIDETables, getFocusAnalysis } = await Promise.resolve().then(() => __importStar(require('./ide-intelligence')));
+            initializeIDETables();
+            return getFocusAnalysis();
+        }
+        case 'cell_ide_insights': {
+            const { initializeIDETables, getIDEInsights } = await Promise.resolve().then(() => __importStar(require('./ide-intelligence')));
+            initializeIDETables();
+            return getIDEInsights();
+        }
+        case 'cell_cloud_status': {
+            const { getSyncStatus } = await Promise.resolve().then(() => __importStar(require('./cloud-sync')));
+            return getSyncStatus();
+        }
+        case 'cell_cloud_validate': {
+            const { validatePayload } = await Promise.resolve().then(() => __importStar(require('./cloud-sync')));
+            const data = params?.arguments?.data;
+            return validatePayload(data || {});
+        }
+        case 'cell_cloud_queue': {
+            const { getPendingQueue, retryFailedEntries } = await Promise.resolve().then(() => __importStar(require('./cloud-sync')));
+            return { pending: getPendingQueue(), retryable: retryFailedEntries() };
+        }
+        default:
+            return { error: `unknown tool: ${name}` };
+    }
+}
+async function handleResourceRead(params) {
+    const uri = params?.uri;
+    switch (uri) {
+        case 'cell://taste/profile':
+            return daemonRequest('GET', '/taste/profile');
+        case 'cell://community/stats':
+            return daemonRequest('GET', '/community/prior');
+        case 'cell://community/v2/stats':
+            return daemonRequest('GET', '/community/v2/stats');
+        case 'cell://community/v2/insights':
+            return daemonRequest('GET', '/community/v2/insights');
+        case 'cell://team/composite':
+            return daemonRequest('GET', '/team/composite');
+        case 'cell://org/v2/benchmarks': {
+            const { orgId } = params?.arguments || {};
+            if (!orgId)
+                return { error: 'orgId argument required' };
+            return daemonRequest('POST', `/org/v2/${orgId}/benchmarks`, {});
+        }
+        case 'cell://intelligence/reports': {
+            const reports = await daemonRequest('GET', '/intelligence/reports');
+            const full = [];
+            for (const id of reports.reports || []) {
+                const report = await daemonRequest('GET', `/intelligence/report/${encodeURIComponent(id)}`);
+                full.push(report);
+            }
+            return { reports: full };
+        }
+        case 'cell://health':
+            return daemonRequest('GET', '/health');
+        default:
+            return { error: `unknown resource: ${uri}` };
+    }
+}
+//# sourceMappingURL=mcp-server.js.map