cortex-mcp 2.7.5 → 2.8.0

package/README.md

@@ -64,7 +64,7 @@ Next conversation → Cortex injects relevant memories → AI already knows your
 
 ---
 
-## All 35 Tools (All Free)
+## All 30 Tools (All Free)
 
 ### Core Memory
 | Tool | What it does |
@@ -121,6 +121,9 @@ Next conversation → Cortex injects relevant memories → AI already knows your
 | Tool | What it does |
 |------|-------------|
 | `health_check` | Server health, embedding status, vector search status |
+| `repair_brain` | Rebuild FTS index, integrity check, VACUUM, fix orphaned data |
+| `detect_conflicts` | Find contradictory memories (e.g. "use X" vs "avoid X") |
+| `suggest_cleanup` | Identify stale low-value memories you should delete |
 
 ---
 

package/dist/server/mcp-handler.js

@@ -357,6 +357,32 @@ const MCP_TOOLS = [
             properties: {},
         },
     },
+    {
+        name: 'repair_brain',
+        description: 'Repair and optimize the memory database. Rebuilds the full-text search index, checks database integrity, removes orphaned vectors, and runs VACUUM. Use this if search stops working or the brain feels slow.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'detect_conflicts',
+        description: 'Scan all active memories for contradictions. Finds pairs of memories that say opposite things (e.g. "use PostgreSQL" vs "use MongoDB"). Returns conflicts so the user can resolve which is correct.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'suggest_cleanup',
+        description: 'Identify stale, low-value memories that should be deleted. Finds memories older than 30 days with low confidence, zero access count, and no pins. Returns a list the user can review and bulk-delete.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                olderThanDays: { type: 'number', description: 'Only suggest memories older than N days (default 30)' },
+            },
+        },
+    },
 ];
 // --- Dynamic Context via ContextBuilder ---
 let cachedContextBuilder = null;
@@ -580,6 +606,15 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                 else if (toolName === 'analytics') {
                     return handleAnalytics(id);
                 }
+                else if (toolName === 'repair_brain') {
+                    return handleRepairBrain(id);
+                }
+                else if (toolName === 'detect_conflicts') {
+                    return handleDetectConflicts(id);
+                }
+                else if (toolName === 'suggest_cleanup') {
+                    return handleSuggestCleanup(id, args);
+                }
                 else {
                     return {
                         jsonrpc: '2.0', id,
@@ -1134,6 +1169,28 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                 for (const s of sessions)
                     parts.push(s);
             }
+            // ─── BRAIN LAYER 3.5: What's New Since Last Session ──────────────
+            try {
+                const db = memoryStore.db || memoryStore.connection;
+                const oneDayAgo = Date.now() - 86400000;
+                const recentNew = db.prepare(
+                    'SELECT type, intent FROM memory_units WHERE is_active = 1 AND created_at > ? ORDER BY created_at DESC LIMIT 10'
+                ).all(oneDayAgo);
+                if (recentNew.length > 0) {
+                    const typeCounts = {};
+                    for (const m of recentNew) {
+                        typeCounts[m.type] = (typeCounts[m.type] || 0) + 1;
+                    }
+                    const summary = Object.entries(typeCounts).map(([t, c]) => `${c} ${t.toLowerCase()}${c > 1 ? 's' : ''}`).join(', ');
+                    parts.push(`\n## 🆕 Since Last Session\n_${recentNew.length} new memories (${summary})_`);
+                    for (const m of recentNew.slice(0, 5)) {
+                        parts.push(`- [${m.type}] ${m.intent}`);
+                    }
+                    if (recentNew.length > 5) {
+                        parts.push(`_...and ${recentNew.length - 5} more_`);
+                    }
+                }
+            } catch { /* non-fatal */ }
             // ─── BRAIN LAYER 4: Hot Corrections (learning rate) ──────────────
             const hotCorrections = (0, learning_rate_1.formatHotCorrections)(memoryStore);
             if (hotCorrections)
@@ -2025,6 +2082,162 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
             return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `analytics error: ${err.message}` }], isError: true } };
         }
     }
+    // ═══ NEW CORE TOOLS: repair_brain, detect_conflicts, suggest_cleanup ═══
+    function handleRepairBrain(id) {
+        try {
+            const db = memoryStore.db || memoryStore.connection;
+            const repairs = [];
+            // 1. Integrity check
+            const integrityResult = db.pragma('integrity_check');
+            const integrityOk = integrityResult && integrityResult[0] && integrityResult[0].integrity_check === 'ok';
+            repairs.push(integrityOk ? '✅ Database integrity: OK' : '⚠️ Database integrity issues detected');
+            // 2. Rebuild FTS index
+            try {
+                db.exec("INSERT INTO memory_fts(memory_fts) VALUES('rebuild')");
+                repairs.push('✅ Full-text search index: Rebuilt');
+            } catch (e) {
+                repairs.push('⚠️ FTS rebuild failed: ' + e.message);
+            }
+            // 3. Fix orphaned vectors (vectors for deleted memories)
+            try {
+                const orphaned = db.prepare(
+                    "DELETE FROM memory_vectors WHERE memory_id NOT IN (SELECT id FROM memory_units WHERE is_active = 1)"
+                ).run();
+                repairs.push(`✅ Orphaned vectors: Cleaned ${orphaned.changes} entries`);
+            } catch { repairs.push('✅ Orphaned vectors: None (table may not exist)'); }
+            // 4. Fix memories with missing created_at
+            try {
+                const fixed = db.prepare(
+                    "UPDATE memory_units SET created_at = timestamp WHERE created_at = 0 OR created_at IS NULL"
+                ).run();
+                if (fixed.changes > 0) {
+                    repairs.push(`✅ Fixed ${fixed.changes} memories with missing created_at`);
+                }
+            } catch { }
+            // 5. WAL checkpoint + VACUUM
+            try {
+                db.pragma('wal_checkpoint(TRUNCATE)');
+                db.exec('VACUUM');
+                repairs.push('✅ Database compacted (VACUUM)');
+            } catch (e) {
+                repairs.push('⚠️ VACUUM failed: ' + e.message);
+            }
+            // 6. Stats after repair
+            const activeCount = memoryStore.activeCount();
+            repairs.push(`\n📊 Active memories: ${activeCount}`);
+            (0, memory_cache_1.invalidateCache)();
+            return {
+                jsonrpc: '2.0', id,
+                result: { content: [{ type: 'text', text: `# 🔧 Brain Repair Complete\n\n${repairs.join('\n')}` }] },
+            };
+        } catch (err) {
+            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `Repair error: ${err.message}` }], isError: true } };
+        }
+    }
+    function handleDetectConflicts(id) {
+        try {
+            const memories = memoryStore.getActive(500);
+            // Only look at decisions and conventions — these are the ones that conflict
+            const candidates = memories.filter(m =>
+                ['DECISION', 'CONVENTION', 'CORRECTION'].includes(m.type)
+            );
+            const conflicts = [];
+            // Compare each pair for contradictions
+            const OPPOSITE_PAIRS = [
+                ['always', 'never'], ['use', 'avoid'], ['enable', 'disable'],
+                ['allow', 'block'], ['include', 'exclude'], ['add', 'remove'],
+                ['yes', 'no'], ['true', 'false'], ['must', 'must not'],
+                ['do', "don't"], ['do', 'do not'], ['can', 'cannot'],
+            ];
+            for (let i = 0; i < candidates.length; i++) {
+                for (let j = i + 1; j < candidates.length; j++) {
+                    const a = candidates[i];
+                    const b = candidates[j];
+                    const aText = (a.intent + ' ' + (a.action || '')).toLowerCase();
+                    const bText = (b.intent + ' ' + (b.action || '')).toLowerCase();
+                    // Check if they share a subject but have opposite verbs
+                    let isConflict = false;
+                    for (const [pos, neg] of OPPOSITE_PAIRS) {
+                        if ((aText.includes(pos) && bText.includes(neg)) ||
+                            (aText.includes(neg) && bText.includes(pos))) {
+                            // Check they share at least one significant word (3+ chars)
+                            const aWords = aText.split(/\s+/).filter(w => w.length > 3);
+                            const bWords = new Set(bText.split(/\s+/).filter(w => w.length > 3));
+                            const shared = aWords.filter(w => bWords.has(w));
+                            if (shared.length >= 1) {
+                                isConflict = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (isConflict) {
+                        conflicts.push({
+                            a: { id: a.id, type: a.type, intent: a.intent, age: Math.floor((Date.now() - a.createdAt) / 86400000) },
+                            b: { id: b.id, type: b.type, intent: b.intent, age: Math.floor((Date.now() - b.createdAt) / 86400000) },
+                        });
+                    }
+                }
+            }
+            if (conflicts.length === 0) {
+                return {
+                    jsonrpc: '2.0', id,
+                    result: { content: [{ type: 'text', text: '✅ No conflicts detected! All memories are consistent.' }] },
+                };
+            }
+            const lines = [`# ⚠️ ${conflicts.length} Potential Conflict(s) Detected\n`];
+            for (let i = 0; i < conflicts.length; i++) {
+                const c = conflicts[i];
+                lines.push(`### Conflict ${i + 1}`);
+                lines.push(`**A:** [${c.a.type}] ${c.a.intent} _(${c.a.age}d old, id: ${c.a.id})_`);
+                lines.push(`**B:** [${c.b.type}] ${c.b.intent} _(${c.b.age}d old, id: ${c.b.id})_`);
+                lines.push(`→ Use \`delete_memory\` to remove the outdated one.\n`);
+            }
+            return {
+                jsonrpc: '2.0', id,
+                result: { content: [{ type: 'text', text: lines.join('\n') }] },
+            };
+        } catch (err) {
+            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `conflict detection error: ${err.message}` }], isError: true } };
+        }
+    }
+    function handleSuggestCleanup(id, args) {
+        try {
+            const olderThanDays = args.olderThanDays || 30;
+            const cutoff = Date.now() - (olderThanDays * 86400000);
+            const db = memoryStore.db || memoryStore.connection;
+            // Find stale, low-value memories
+            const stale = db.prepare(`
+                SELECT * FROM memory_units 
+                WHERE is_active = 1 
+                AND created_at < ? 
+                AND confidence < 0.4 
+                AND access_count <= 1
+                AND (tags IS NULL OR tags NOT LIKE '%pinned%')
+                ORDER BY confidence ASC, access_count ASC
+                LIMIT 25
+            `).all(cutoff);
+            if (stale.length === 0) {
+                return {
+                    jsonrpc: '2.0', id,
+                    result: { content: [{ type: 'text', text: `✅ Brain is clean! No stale memories older than ${olderThanDays} days with low value found.` }] },
+                };
+            }
+            const lines = [`# 🧹 ${stale.length} Stale Memories (Cleanup Suggestions)\n`];
+            lines.push(`These memories are older than ${olderThanDays} days, have low confidence, and are rarely accessed:\n`);
+            for (const row of stale) {
+                const age = Math.floor((Date.now() - row.created_at) / 86400000);
+                lines.push(`- **[${row.type}]** ${row.intent}`);
+                lines.push(`  _Confidence: ${(row.confidence * 100).toFixed(0)}% · Accessed: ${row.access_count}x · Age: ${age}d · id: ${row.id}_`);
+            }
+            lines.push(`\n→ Use \`delete_memory\` with each id to remove, or \`clear_memories\` for bulk cleanup.`);
+            return {
+                jsonrpc: '2.0', id,
+                result: { content: [{ type: 'text', text: lines.join('\n') }] },
+            };
+        } catch (err) {
+            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `cleanup suggestion error: ${err.message}` }], isError: true } };
+        }
+    }
     return { handleMCPRequest };
 }
 // ─── NEW: Export/Import/Graph Handlers ─────────────────────────────────────

package/package.json

@@ -2,7 +2,7 @@
   "name": "cortex-mcp",
   "displayName": "Cortex MCP Server",
   "description": "Persistent memory for AI coding assistants. Injects context from past sessions into every LLM request.",
-  "version": "2.7.5",
+  "version": "2.8.0",
   "publisher": "cortex",
   "license": "MIT",
   "engines": {