fivocell 2.0.0 → 3.1.0

package/dist/daemon/server.js

@@ -204,16 +204,121 @@ app.get('/health', (_req, res) => {
     });
 });
 app.post('/signal', (req, res) => {
-    const { type, originalCode, editedCode, context } = req.body;
-    if (!type || !context) {
-        res.status(400).json({ error: 'type and context required' });
+    const { type, originalCode, editedCode, context, file, fromFile, costMs, durationMs, switchCount, language, errorMessage, errorType, line, fixApplied, fixWorked, timeToFixMs, decision, approach, result, worked, task, files, description, stuckId, resolution, project } = req.body;
+    if (!type) {
+        res.status(400).json({ error: 'type required' });
         return;
     }
+    // ─── Behavioral Signals ───────────────────────────────────────
+    if (type === 'error') {
+        const { logError, getErrorPatterns } = require('../behavioral-tracker');
+        const r = logError({ project, file, errorType, errorMessage, line });
+        // Check if repeat mistake — send warning
+        let warning = null;
+        try {
+            const patterns = getErrorPatterns(project);
+            const match = patterns.find((p) => p.error_type === errorType);
+            if (match && match.count >= 2) {
+                warning = `⚠ Repeat mistake! "${errorType}" has occurred ${match.count}x before. Fix the root cause.`;
+            }
+        }
+        catch { }
+        res.json({ recorded: true, id: r.id, warning });
+        return;
+    }
+    if (type === 'error_fix') {
+        const { logErrorFix } = require('../behavioral-tracker');
+        logErrorFix({ errorId: stuckId || 0, fixApplied: fixApplied || '', worked: fixWorked || false, timeToFixMs: timeToFixMs || 0 });
+        res.json({ recorded: true });
+        return;
+    }
+    if (type === 'decision') {
+        const { logDecision } = require('../behavioral-tracker');
+        const r = logDecision({ project, file, decision, approach, result, worked, context: req.body.context || '' });
+        // Auto-track in session memory
+        try {
+            const { SessionMemory } = require('../core/session-memory');
+            const mem = new SessionMemory();
+            const lastSess = mem.getLastSessionForProject(project || '');
+            if (lastSess && !lastSess.endTime) {
+                const decs = JSON.parse(String(lastSess.keyDecisions || '[]'));
+                decs.push(`${decision}: ${approach || result || ''}`);
+                mem.endSession(lastSess.id, { keyDecisions: decs, contextSnapshot: req.body.context || decision });
+            }
+        }
+        catch { }
+        res.json({ recorded: true, id: r.id });
+        return;
+    }
+    if (type === 'context') {
+        const { logContext } = require('../behavioral-tracker');
+        const r = logContext({ project, task, files });
+        // Auto-start session if none exists
+        try {
+            const { SessionMemory } = require('../core/session-memory');
+            const mem = new SessionMemory();
+            const lastSess = mem.getLastSessionForProject(project || '');
+            if (!lastSess || lastSess.endTime) {
+                const tool = req.body.tool || 'cli';
+                mem.startSession(tool, project || '');
+                if (files && files.length > 0) {
+                    const newSess = mem.getLastSessionForProject(project || '');
+                    if (newSess)
+                        mem.endSession(newSess.id, { filesTouched: files, contextSnapshot: task });
+                }
+            }
+        }
+        catch { }
+        res.json({ recorded: true, id: r.id });
+        return;
+    }
+    if (type === 'stuck') {
+        const { logStuck } = require('../behavioral-tracker');
+        const r = logStuck({ project, file, description });
+        res.json({ recorded: true, id: r.id });
+        return;
+    }
+    if (type === 'stuck_resolved') {
+        const { logStuckResolved } = require('../behavioral-tracker');
+        logStuckResolved(stuckId || 0, resolution || '');
+        res.json({ recorded: true });
+        return;
+    }
+    // ─── IDE Signals ──────────────────────────────────────────────
+    if (type === 'model_use') {
+        // Track AI model interaction
+        try {
+            const { recordModelInteraction } = require('../cross-model-engine');
+            recordModelInteraction({
+                modelName: req.body.modelName || 'unknown',
+                taskType: req.body.taskType || req.body.type || 'general',
+                accepted: req.body.accepted !== false,
+                responseTimeMs: req.body.responseTimeMs,
+                project,
+                suggestion: req.body.suggestion,
+            });
+        }
+        catch { }
+        res.json({ recorded: true });
+        return;
+    }
+    if (type === 'tab_switch' || type === 'focus_block' || type === 'file_save') {
+        try {
+            const db = (0, database_1.getDb)();
+            db.prepare('INSERT INTO behavior_events (event_type, project, file_path, description, severity, evidence) VALUES (?, ?, ?, ?, ?, ?)')
+                .run(type, '', file || '', JSON.stringify({ fromFile, costMs, durationMs, switchCount, language }), 'low', JSON.stringify(req.body));
+        }
+        catch { }
+        res.json({ recorded: true, type });
+        return;
+    }
+    // ─── Legacy Signals ──────────────────────────────────────────
+    const ctx = context || {};
     let signal;
     let patternsExtracted = 0;
     switch (type) {
         case 'edit_diff': {
-            signal = engines.signalCapture.captureEditDiff(originalCode || '', editedCode || '', context);
+            signal = engines.signalCapture.captureEditDiff(originalCode || '', editedCode || '', ctx);
             try {
                 const result = engines.extractionCascade.extract(originalCode || '', editedCode || '');
                 patternsExtracted = engines.learningLayer.process(result, true);
@@ -226,35 +331,28 @@ app.post('/signal', (req, res) => {
             break;
         }
         case 'accept': {
-            signal = engines.signalCapture.captureAccept(originalCode || '', context);
+            signal = engines.signalCapture.captureAccept(originalCode || '', ctx);
             const dummy = engines.patternStore.getAllPatterns().slice(0, 1);
             for (const p of dummy) {
                 const step = (0, workflow_tracker_1.recordStep)(p, 'accept');
                 (0, outcome_recorder_1.recordOutcome)(p, 'accept', step.sessionId, true, 0);
-                (0, failure_memory_1.recordFailure)(p, false, context?.language || 'unknown');
-                (0, time_saved_1.recordTimeSaved)({
-                    patternId: p.patternId,
-                    category: p.category,
-                    description: p.description,
-                    from: p.from,
-                    to: p.to,
-                    language: context?.language || 'unknown',
-                });
+                (0, failure_memory_1.recordFailure)(p, false, ctx.language || 'unknown');
+                (0, time_saved_1.recordTimeSaved)({ patternId: p.patternId, category: p.category, description: p.description, from: p.from, to: p.to, language: ctx.language || 'unknown' });
             }
             break;
         }
         case 'reject': {
-            signal = engines.signalCapture.captureReject(originalCode || '', context);
+            signal = engines.signalCapture.captureReject(originalCode || '', ctx);
             const dummyR = engines.patternStore.getAllPatterns().slice(0, 1);
             for (const p of dummyR) {
                 const step = (0, workflow_tracker_1.recordStep)(p, 'reject');
                 (0, outcome_recorder_1.recordOutcome)(p, 'reject', step.sessionId, false, 0);
-                (0, failure_memory_1.recordFailure)(p, true, context?.language || 'unknown');
+                (0, failure_memory_1.recordFailure)(p, true, ctx.language || 'unknown');
             }
             break;
         }
         case 'retry': {
-            signal = engines.signalCapture.captureRetry(originalCode || '', context);
+            signal = engines.signalCapture.captureRetry(originalCode || '', ctx);
             const dummyRt = engines.patternStore.getAllPatterns().slice(0, 1);
             for (const p of dummyRt) {
                 const step = (0, workflow_tracker_1.recordStep)(p, 'retry');
@@ -1562,20 +1660,306 @@ app.post('/cloud/push', (req, res) => {
         pushToCloud(req.body?.data || {}, req.body?.type || 'pattern').then(r => res.json(r));
     }).catch(e => res.status(500).json({ error: String(e) }));
 });
+// ─── CODE SCANNER (Deep Learning) ──────────────────────
+app.post('/scan/codebase', (req, res) => {
+    const { dir, project } = req.body;
+    if (!dir) {
+        res.status(400).json({ error: 'dir required' });
+        return;
+    }
+    Promise.resolve().then(() => __importStar(require('../code-scanner'))).then(({ scanCodebase }) => {
+        const result = scanCodebase(dir, project || require('path').basename(dir));
+        res.json(result);
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/scan/profile/:project', (req, res) => {
+    Promise.resolve().then(() => __importStar(require('../code-scanner'))).then(({ getDeveloperProfile }) => {
+        const profile = getDeveloperProfile(req.params.project);
+        if (!profile) {
+            res.status(404).json({ error: 'no profile — run scan first' });
+            return;
+        }
+        res.json(profile);
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/scan/patterns/:project', (req, res) => {
+    const category = req.query.category;
+    Promise.resolve().then(() => __importStar(require('../code-scanner'))).then(({ getCodePatterns }) => {
+        res.json({ patterns: getCodePatterns(req.params.project, category) });
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/scan/report/:project', (req, res) => {
+    Promise.resolve().then(() => __importStar(require('../code-scanner'))).then(({ getDeveloperProfile, getCodePatterns }) => {
+        const profile = getDeveloperProfile(req.params.project);
+        const patterns = getCodePatterns(req.params.project);
+        res.json({ project: req.params.project, profile, patterns, patternCount: patterns.length });
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+// ─── BEHAVIORAL TRACKING ──────────────────────────────────────
+app.get('/behavior/summary', (req, res) => {
+    const { getBehaviorSummary } = require('../behavioral-tracker');
+    res.json(getBehaviorSummary(String(req.query.project || undefined)));
+});
+app.get('/behavior/errors', (req, res) => {
+    const { getErrorPatterns, getRecentErrors } = require('../behavioral-tracker');
+    res.json({ patterns: getErrorPatterns(String(req.query.project || undefined)), recent: getRecentErrors(10, String(req.query.project || undefined)) });
+});
+app.get('/behavior/decisions', (req, res) => {
+    const { getDecisions } = require('../behavioral-tracker');
+    res.json({ decisions: getDecisions(String(req.query.project || undefined), 20) });
+});
+app.get('/behavior/context', (req, res) => {
+    const { getCurrentContext } = require('../behavioral-tracker');
+    res.json(getCurrentContext(String(req.query.project || undefined)) || { task: 'none', files: [] });
+});
+app.get('/behavior/stuck', (req, res) => {
+    const { getStuckPatterns } = require('../behavioral-tracker');
+    res.json({ stuck: getStuckPatterns(String(req.query.project || undefined)) });
+});
+// ─── Session Bridge Helper ────────────────────────────────────────────────
+function formatSessionBridge(fromTool, toTool, context, decisions) {
+    const lines = [];
+    lines.push(`═══ CROSS-SESSION BRIDGE ═══`);
+    lines.push(`From: ${fromTool} → To: ${toTool}`);
+    if (context)
+        lines.push(`Last context: ${context}`);
+    if (decisions && decisions !== 'none' && decisions !== '[]') {
+        lines.push(`Decisions made: ${decisions}`);
+    }
+    lines.push(`Cell remembers. No need to re-explain.`);
+    return lines.join('\n');
+}
+// ─── MCP ENDPOINTS (merged from mcp-server.ts) ─────────────────────────────
+const MCP_TOOLS = [
+    { name: 'cell_get_dev_profile', description: 'Developer profile — naming, style, errors, architecture', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_get_code_patterns', description: 'Code patterns by category', inputSchema: { type: 'object', properties: { project: { type: 'string' }, category: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_deep_scan', description: 'Deep scan codebase', inputSchema: { type: 'object', properties: { dir: { type: 'string' }, project: { type: 'string' } }, required: ['dir'] } },
+    { name: 'cell_scan_report', description: 'Full scan report', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_send_signal', description: 'Send learning signal', inputSchema: { type: 'object', properties: { type: { type: 'string' }, originalCode: { type: 'string' }, editedCode: { type: 'string' }, file: { type: 'string' }, language: { type: 'string' } }, required: ['type'] } },
+    { name: 'cell_get_context', description: 'Full context injection', inputSchema: { type: 'object', properties: { project: { type: 'string' }, tool: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_scan_full_pc', description: 'Scan entire PC for all code projects', inputSchema: { type: 'object', properties: {} } },
+    { name: 'cell_behavior_summary', description: 'Behavioral summary', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_log_error', description: 'Log an error encounter', inputSchema: { type: 'object', properties: { project: { type: 'string' }, file: { type: 'string' }, errorType: { type: 'string' }, errorMessage: { type: 'string' }, line: { type: 'number' } }, required: ['errorType', 'errorMessage'] } },
+    { name: 'cell_log_fix', description: 'Log how an error was fixed', inputSchema: { type: 'object', properties: { errorId: { type: 'number' }, fixApplied: { type: 'string' }, worked: { type: 'boolean' }, timeToFixMs: { type: 'number' } }, required: ['errorId', 'fixApplied', 'worked'] } },
+    { name: 'cell_log_decision', description: 'Log a coding decision', inputSchema: { type: 'object', properties: { project: { type: 'string' }, file: { type: 'string' }, decision: { type: 'string' }, approach: { type: 'string' }, worked: { type: 'boolean' } }, required: ['decision'] } },
+    { name: 'cell_log_context', description: 'Log current context', inputSchema: { type: 'object', properties: { project: { type: 'string' }, task: { type: 'string' }, files: { type: 'array', items: { type: 'string' } } }, required: ['task'] } },
+    { name: 'cell_log_stuck', description: 'Log when stuck', inputSchema: { type: 'object', properties: { project: { type: 'string' }, file: { type: 'string' }, description: { type: 'string' } }, required: ['description'] } },
+    { name: 'cell_session_bridge', description: 'Cross-session memory bridge — get last session context when switching tools', inputSchema: { type: 'object', properties: { project: { type: 'string' }, tool: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_predict', description: 'Predictive intelligence — repeat mistakes, decision regret, energy warnings, complexity traps', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: [] } },
+    { name: 'cell_model_track', description: 'Track AI model interaction — which tool was used, what task, accepted/rejected', inputSchema: { type: 'object', properties: { modelName: { type: 'string' }, taskType: { type: 'string' }, accepted: { type: 'boolean' }, responseTimeMs: { type: 'number' }, project: { type: 'string' }, suggestion: { type: 'string' } }, required: ['modelName', 'taskType', 'accepted'] } },
+    { name: 'cell_model_recommend', description: 'Get AI model recommendations — which tool works best for which task', inputSchema: { type: 'object', properties: {} } },
+];
+async function handleMCPToolCall(name, args) {
+    switch (name) {
+        case 'cell_get_dev_profile': {
+            const { getDeveloperProfile } = require('../code-scanner');
+            const profile = getDeveloperProfile(args.project);
+            if (!profile)
+                return { error: 'no profile — run cell scan first' };
+            return { project: args.project, profile };
+        }
+        case 'cell_get_code_patterns': {
+            const { getCodePatterns } = require('../code-scanner');
+            return { project: args.project, patterns: getCodePatterns(args.project, args.category) };
+        }
+        case 'cell_deep_scan': {
+            const { scanCodebase } = require('../code-scanner');
+            const result = scanCodebase(args.dir, args.project || path.basename(args.dir));
+            return { project: result.project, filesScanned: result.filesScanned, totalLines: result.totalLines, profile: result.profile, strengths: result.profile.strengths, improvements: result.profile.improvements };
+        }
+        case 'cell_scan_report': {
+            const { getDeveloperProfile, getCodePatterns } = require('../code-scanner');
+            const profile = getDeveloperProfile(args.project);
+            const patterns = getCodePatterns(args.project);
+            return { project: args.project, profile, patterns, patternCount: patterns.length };
+        }
+        case 'cell_send_signal': {
+            const { logError, logDecision, logContext, logStuck } = require('../behavioral-tracker');
+            const type = args.type;
+            if (type === 'error')
+                return logError({ project: args.project, file: args.file, errorType: 'manual', errorMessage: String(args.editedCode || ''), line: 0 });
+            if (type === 'decision')
+                return logDecision({ project: args.project, file: args.file, decision: String(args.originalCode || ''), approach: String(args.editedCode || ''), worked: true });
+            if (type === 'context')
+                return logContext({ project: args.project, task: String(args.originalCode || ''), files: [] });
+            if (type === 'stuck')
+                return logStuck({ project: args.project, file: args.file, description: String(args.originalCode || '') });
+            return { recorded: true };
+        }
+        case 'cell_get_context': {
+            const { buildContext, formatContextForInjection } = require('../core/prompt-builder');
+            const ctx = buildContext(args.project, args.tool);
+            return { content: [{ type: 'text', text: formatContextForInjection(ctx, false) }], context: ctx };
+        }
+        case 'cell_scan_full_pc': {
+            const { scanFullPC } = require('../pc-scanner');
+            const result = scanFullPC();
+            return { totalProjects: result.totalProjects, totalFiles: result.totalFiles, totalLines: result.totalLines, profile: result.aggregatedProfile };
+        }
+        case 'cell_behavior_summary': {
+            const { getBehaviorSummary } = require('../behavioral-tracker');
+            return getBehaviorSummary(args.project);
+        }
+        case 'cell_log_error': {
+            const { logError } = require('../behavioral-tracker');
+            return logError({ project: args.project, file: args.file, errorType: args.errorType, errorMessage: args.errorMessage, line: args.line });
+        }
+        case 'cell_log_fix': {
+            const { logErrorFix } = require('../behavioral-tracker');
+            logErrorFix({ errorId: args.errorId, fixApplied: args.fixApplied, worked: args.worked, timeToFixMs: args.timeToFixMs });
+            return { recorded: true };
+        }
+        case 'cell_log_decision': {
+            const { logDecision } = require('../behavioral-tracker');
+            return logDecision({ project: args.project, file: args.file, decision: args.decision, approach: args.approach, worked: args.worked });
+        }
+        case 'cell_log_context': {
+            const { logContext } = require('../behavioral-tracker');
+            return logContext({ project: args.project, task: args.task, files: args.files });
+        }
+        case 'cell_log_stuck': {
+            const { logStuck } = require('../behavioral-tracker');
+            return logStuck({ project: args.project, file: args.file, description: args.description });
+        }
+        case 'cell_session_bridge': {
+            const { SessionMemory } = require('../core/session-memory');
+            const memory = new SessionMemory();
+            const project = args.project;
+            const tool = args.tool || 'unknown';
+            try {
+                // Get last session for this project
+                const lastSession = memory.getLastSessionForProject(project);
+                // Start new session for current tool
+                const newSessionId = memory.startSession(tool, project);
+                // If there was a previous session with a different tool, bridge it
+                let bridgeContext = '';
+                if (lastSession && lastSession.toolName !== tool) {
+                    const decisions = lastSession.keyDecisions ? JSON.stringify(lastSession.keyDecisions) : 'none';
+                    bridgeContext = formatSessionBridge(lastSession.toolName, tool, lastSession.contextSnapshot, decisions);
+                }
+                // Get recent sessions for context chain
+                const recentSessions = memory.getRecentSessions(3).filter((s) => s.project === project);
+                const sessionHistory = recentSessions.map((s) => ({
+                    tool: s.toolName,
+                    when: s.startTime,
+                    files: JSON.parse(String(s.filesTouched || '[]')),
+                    decisions: JSON.parse(String(s.keyDecisions || '[]')),
+                }));
+                return {
+                    newSessionId,
+                    lastSession: lastSession ? {
+                        tool: lastSession.toolName,
+                        startedAt: lastSession.startTime,
+                        context: lastSession.contextSnapshot,
+                    } : null,
+                    bridgeContext,
+                    sessionHistory,
+                    message: bridgeContext || 'No previous session to bridge. Start a new session!',
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Session bridge failed: ${msg}`, crossedSession: false };
+            }
+        }
+        case 'cell_predict': {
+            const { generatePredictions } = require('../predictive-engine');
+            return generatePredictions(args.project);
+        }
+        case 'cell_model_track': {
+            const { recordModelInteraction } = require('../cross-model-engine');
+            recordModelInteraction({
+                modelName: args.modelName,
+                taskType: args.taskType,
+                accepted: args.accepted,
+                responseTimeMs: args.responseTimeMs,
+                project: args.project,
+                suggestion: args.suggestion,
+            });
+            return { recorded: true };
+        }
+        case 'cell_model_recommend': {
+            const { getModelRecommendations } = require('../cross-model-engine');
+            return { recommendations: getModelRecommendations() };
+        }
+        default:
+            return { error: `unknown tool: ${name}` };
+    }
+}
+app.post('/mcp', async (req, res) => {
+    const rpc = req.body;
+    const { method, params, id } = rpc;
+    try {
+        let result;
+        switch (method) {
+            case 'initialize':
+                result = { protocolVersion: params?.protocolVersion || '2024-11-05', capabilities: { tools: { listChanged: false } }, serverInfo: { name: 'fivo-cell', version: '3.0.0' } };
+                break;
+            case 'notifications/initialized':
+                res.status(204).end();
+                return;
+            case 'ping':
+                result = {};
+                break;
+            case 'tools/list':
+                result = { tools: MCP_TOOLS };
+                break;
+            case 'tools/call':
+                result = await handleMCPToolCall(params?.name || '', params?.arguments || {});
+                break;
+            default:
+                res.status(200).json({ jsonrpc: '2.0', id, error: { code: -32601, message: `Method not found: ${method}` } });
+                return;
+        }
+        res.status(200).json({ jsonrpc: '2.0', id, result });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        res.status(200).json({ jsonrpc: '2.0', id, error: { code: -1, message } });
+    }
+});
 app.use((_req, res) => { res.status(404).json({ error: 'not found' }); });
 app.use((err, _req, res, _next) => {
     console.error('Daemon error:', err.message);
     res.status(500).json({ error: 'internal server error' });
 });
+// ─── Self-Healing ──────────────────────────────────────────────────────
+process.on('uncaughtException', (err) => {
+    console.error('[cell] Uncaught:', err.message);
+    // Don't exit — keep serving
+});
+process.on('unhandledRejection', (reason) => {
+    console.error('[cell] Unhandled rejection:', String(reason));
+});
 try {
     (0, ai_memory_1.initializeMemory)();
 }
 catch (e) {
     console.error('AI memory init failed:', e);
 }
-app.listen(PORT, () => {
+// ─── Start with port conflict handling ─────────────────────────────────
+const server = app.listen(PORT, () => {
     console.log(`Cell Daemon running on http://localhost:${PORT}`);
-    console.log(`Modules loaded: ${Object.keys(engines).length}`);
+    console.log(`MCP endpoint: POST http://localhost:${PORT}/mcp`);
     console.log(`Health: http://localhost:${PORT}/health`);
 });
+server.on('error', (err) => {
+    if (err.code === 'EADDRINUSE') {
+        console.error(`[cell] Port ${PORT} in use. Kill existing daemon first: cell stop`);
+    }
+    else {
+        console.error(`[cell] Server error: ${err.message}`);
+    }
+});
+server.on('close', () => {
+    console.log('[cell] Daemon stopped.');
+});
+// Graceful shutdown
+const gracefulShutdown = () => {
+    console.log('[cell] Daemon shutting down...');
+    server.close();
+    process.exit(0);
+};
+process.on('SIGTERM', gracefulShutdown);
+process.on('SIGINT', gracefulShutdown);
 //# sourceMappingURL=server.js.map