@mrxkun/mcfast-mcp 4.0.3 → 4.0.4

package/README.md

@@ -14,8 +14,8 @@
 </p>
 
 <p align="center">
-  <strong>🧠 NEW in v4.0.1: Daily Logs & Sync Engine</strong><br>
-  Auto-generated markdown notes | Optional cloud sync | Phase 2 Complete
+  <strong>🧠 NEW in v4.0.4: Intelligence Layer</strong><br>
+  ML-powered pattern detection | Adaptive strategy selection | Predictive suggestions
 </p>
 
 ---
@@ -623,7 +623,14 @@ Read API (Total: 6ms)
 
 ## 📝 Changelog
 
-### v4.0.3 (2026-02-16) 🎉 Phase 4 Complete - Intelligence Layer
+### v4.0.4 (2026-02-16) 🎉 Phase 4 Complete - MCP Tools Added
+
+- 🔧 **MCP Tools Registration**
+  - `memory_search` - Semantic code search with 90-95% accuracy
+  - `memory_get` - Retrieve stored memories and intelligence stats
+  - `detect_patterns` - Detect code patterns from edit history
+  - `get_suggestions` - Get intelligent code suggestions
+  - `select_strategy` - ML-based strategy selection
 
 - 🧠 **Pattern Recognition**
   - Detect frequent renames (naming inconsistencies)
@@ -660,6 +667,11 @@ Read API (Total: 6ms)
   - Pattern detection: >90% accuracy
   - Auto-apply success: >90%
 
+### v4.0.3 (2026-02-16) 🎉 Phase 4 Core Implementation
+- Initial Phase 4 implementation (PatternDetector, SuggestionEngine, StrategySelector)
+- Dashboard analytics endpoints
+- SQL migration for Phase 4 tables
+
 ### v4.0.2 (2026-02-16) 🎉 Phase 3 Complete
 - ✨ **Enhanced Edit Tool** with Memory Context
   - Automatic context retrieval from codebase memory

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "4.0.3",
+  "version": "4.0.4",
   "description": "Ultra-fast code editing with WASM acceleration, fuzzy patching, multi-layer caching, and 8 unified tools. Optimized for AI code assistants with 80-98% latency reduction. Phase 4: ML Intelligence Layer.",
   "type": "module",
   "bin": {
@@ -47,7 +47,7 @@
     "@babel/types": "^7.29.0",
     "@modelcontextprotocol/sdk": "^0.6.0",
     "better-sqlite3": "^11.10.0",
-    "chokidar": "^4.0.3",
+    "chokidar": "^4.0.4",
     "fast-glob": "^3.3.3",
     "ignore": "^7.0.5",
     "tree-sitter-c-sharp": "^0.23.1",

package/src/index.js

@@ -432,6 +432,69 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     },
                     required: ["instruction", "files"]
                 }
+            },
+            // MEMORY TOOL 1: memory_search
+            {
+                name: "memory_search",
+                description: "🧠 Semantic code search using local embeddings (90-95% accuracy). Finds code by meaning, not just keywords. Returns relevant code chunks from your codebase.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string", description: "Natural language search query (e.g., 'find authentication code', 'error handling patterns')" },
+                        type: { type: "string", enum: ["all", "facts", "history", "code"], description: "Filter by type (default: all)" },
+                        maxResults: { type: "number", description: "Maximum results to return (default: 6)" },
+                        minScore: { type: "number", description: "Minimum relevance score 0-1 (default: 0.35)" }
+                    },
+                    required: ["query"]
+                }
+            },
+            // MEMORY TOOL 2: memory_get
+            {
+                name: "memory_get",
+                description: "📚 Get stored memories: today's log, curated memories, or intelligence stats. Use to review recent changes or long-term knowledge.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        type: { type: "string", enum: ["today_log", "curated", "stats", "intelligence"], description: "Type of memory to retrieve" }
+                    },
+                    required: ["type"]
+                }
+            },
+            // INTELLIGENCE TOOL 1: detect_patterns
+            {
+                name: "detect_patterns",
+                description: "🔍 Detect code patterns from edit history: naming inconsistencies, recurring bugs, hot files, frequent sequences. Returns actionable insights.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                    required: []
+                }
+            },
+            // INTELLIGENCE TOOL 2: get_suggestions
+            {
+                name: "get_suggestions",
+                description: "💡 Get intelligent code suggestions based on current context: naming fixes, long functions, missing tests, unused imports, duplicate code.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        currentFile: { type: "string", description: "Current file being edited" },
+                        currentLine: { type: "number", description: "Current line number" }
+                    },
+                    required: []
+                }
+            },
+            // INTELLIGENCE TOOL 3: select_strategy
+            {
+                name: "select_strategy",
+                description: "🎯 ML-based strategy selection for optimal edit performance. Analyzes instruction and context to choose best strategy (deterministic/cached/llm).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        instruction: { type: "string", description: "Edit instruction to analyze" },
+                        files: { type: "array", items: { type: "string" }, description: "Files involved in the edit" }
+                    },
+                    required: ["instruction"]
+                }
             }
         ],
     };
@@ -609,6 +672,31 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             result = await handleReapply(args);
             summary = 'Retry edit applied';
         }
+        // MEMORY TOOL 1: memory_search
+        else if (name === "memory_search") {
+            result = await handleMemorySearch(args);
+            summary = 'Memory search completed';
+        }
+        // MEMORY TOOL 2: memory_get
+        else if (name === "memory_get") {
+            result = await handleMemoryGet(args);
+            summary = 'Memory retrieved';
+        }
+        // INTELLIGENCE TOOL 1: detect_patterns
+        else if (name === "detect_patterns") {
+            result = await handleDetectPatterns(args);
+            summary = 'Patterns detected';
+        }
+        // INTELLIGENCE TOOL 2: get_suggestions
+        else if (name === "get_suggestions") {
+            result = await handleGetSuggestions(args);
+            summary = 'Suggestions generated';
+        }
+        // INTELLIGENCE TOOL 3: select_strategy
+        else if (name === "select_strategy") {
+            result = await handleSelectStrategy(args);
+            summary = 'Strategy selected';
+        }
         else {
             throw new Error(`Tool not found: ${name}`);
         }
@@ -2625,6 +2713,297 @@ async function handleReferencesInDirectory({ path: dirPath, symbol }) {
     }
 }
 
+// ============================================
+// PHASE 4: INTELLIGENCE LAYER HANDLERS
+// ============================================
+
+/**
+ * INTELLIGENCE HANDLER 1: handleMemorySearch
+ * Semantic code search using MemoryEngine
+ */
+async function handleMemorySearch({ query, type = 'all', maxResults = 6, minScore = 0.35 }) {
+    const start = Date.now();
+    try {
+        const engine = await getMemoryEngine();
+        let results = [];
+
+        if (type === 'facts') {
+            const facts = await engine.searchFacts(query, maxResults);
+            results = facts.map(fact => ({
+                type: 'fact',
+                content: `${fact.type}: ${fact.name}${fact.signature ? ` (${fact.signature})` : ''}`,
+                file: fact.file_id,
+                score: fact.confidence || 0.8
+            }));
+        } else if (type === 'code') {
+            const searchResult = await engine.ultraSearch(query, { limit: maxResults });
+            results = searchResult.results.map(result => ({
+                type: 'chunk',
+                content: result.code || result.content,
+                file: result.filePath || result.path,
+                score: result.finalScore || result.score
+            }));
+        } else {
+            const searchResult = await engine.intelligentSearch(query, { limit: maxResults });
+            results = searchResult.results.map(result => ({
+                type: 'chunk',
+                content: result.code || result.content,
+                file: result.filePath || result.path,
+                score: result.finalScore || result.score,
+                method: searchResult.metadata?.method
+            }));
+        }
+
+        results = results.filter(r => r.score >= minScore).slice(0, maxResults);
+
+        let output = `🧠 Memory Search Results\n`;
+        output += `Query: "${query}"\n`;
+        output += `Found: ${results.length} results (${Date.now() - start}ms)\n\n`;
+
+        for (const result of results) {
+            output += `📁 ${result.file}\n`;
+            output += `   Score: ${(result.score * 100).toFixed(0)}%`;
+            if (result.method) output += ` • ${result.method}`;
+            output += `\n   ${result.content?.substring(0, 100)}${result.content?.length > 100 ? '...' : ''}\n\n`;
+        }
+
+        reportAudit({
+            tool: 'memory_search',
+            instruction: query,
+            status: 'success',
+            latency_ms: Date.now() - start,
+            files_count: results.length
+        });
+
+        return { content: [{ type: "text", text: output }] };
+
+    } catch (error) {
+        reportAudit({
+            tool: 'memory_search',
+            instruction: query,
+            status: 'error',
+            error_message: error.message,
+            latency_ms: Date.now() - start
+        });
+
+        return {
+            content: [{ type: "text", text: `❌ Memory search error: ${error.message}` }],
+            isError: true
+        };
+    }
+}
+
+/**
+ * INTELLIGENCE HANDLER 2: handleMemoryGet
+ * Get stored memories and intelligence stats
+ */
+async function handleMemoryGet({ type }) {
+    const start = Date.now();
+    try {
+        const engine = await getMemoryEngine();
+        let output = '';
+
+        if (type === 'today_log') {
+            const log = await engine.getTodayLog();
+            output = `📚 Today's Log\n`;
+            output += `Date: ${new Date().toISOString().split('T')[0]}\n\n`;
+            output += log || 'No entries yet today.';
+        } else if (type === 'curated') {
+            const memories = await engine.getCuratedMemories();
+            output = `📚 Curated Memories\n\n`;
+            output += memories || 'No curated memories yet.';
+        } else if (type === 'stats') {
+            const stats = await engine.getStats();
+            output = `📊 Memory Stats\n\n`;
+            output += `Total chunks: ${stats.totalChunks || 0}\n`;
+            output += `Total facts: ${stats.totalFacts || 0}\n`;
+            output += `Index size: ${stats.indexSize || 0}\n`;
+            output += `Last indexed: ${stats.lastIndexed || 'Never'}`;
+        } else if (type === 'intelligence') {
+            const intelStats = engine.getIntelligenceStats();
+            output = `🧠 Intelligence Stats\n\n`;
+            output += `Enabled: ${intelStats.enabled}\n`;
+            if (intelStats.enabled) {
+                output += `\nPattern Detector:\n`;
+                output += `  Total patterns: ${intelStats.patternDetector?.totalPatterns || 0}\n`;
+                output += `\nSuggestion Engine:\n`;
+                output += `  Min confidence: ${intelStats.suggestionEngine?.minConfidence || 0.7}\n`;
+                output += `\nStrategy Selector:\n`;
+                output += `  Learning rate: ${intelStats.strategySelector?.learningRate || 0.1}\n`;
+            }
+        }
+
+        reportAudit({
+            tool: 'memory_get',
+            instruction: type,
+            status: 'success',
+            latency_ms: Date.now() - start
+        });
+
+        return { content: [{ type: "text", text: output }] };
+
+    } catch (error) {
+        reportAudit({
+            tool: 'memory_get',
+            instruction: type,
+            status: 'error',
+            error_message: error.message,
+            latency_ms: Date.now() - start
+        });
+
+        return {
+            content: [{ type: "text", text: `❌ Memory get error: ${error.message}` }],
+            isError: true
+        };
+    }
+}
+
+/**
+ * INTELLIGENCE HANDLER 3: handleDetectPatterns
+ * Detect code patterns from edit history
+ */
+async function handleDetectPatterns() {
+    const start = Date.now();
+    try {
+        const engine = await getMemoryEngine();
+        const patterns = await engine.detectPatterns();
+
+        let output = `🔍 Detected Patterns\n`;
+        output += `Found: ${patterns.length} patterns\n\n`;
+
+        for (const pattern of patterns) {
+            output += `📌 ${pattern.type.toUpperCase()}\n`;
+            output += `   Confidence: ${(pattern.confidence * 100).toFixed(0)}%\n`;
+            output += `   Severity: ${pattern.severity || 'medium'}\n`;
+            output += `   Occurrences: ${pattern.occurrences || 'N/A'}\n`;
+            output += `   Suggestion: ${pattern.suggestion}\n\n`;
+        }
+
+        reportAudit({
+            tool: 'detect_patterns',
+            instruction: '',
+            status: 'success',
+            latency_ms: Date.now() - start,
+            files_count: patterns.length
+        });
+
+        return { content: [{ type: "text", text: output }] };
+
+    } catch (error) {
+        reportAudit({
+            tool: 'detect_patterns',
+            instruction: '',
+            status: 'error',
+            error_message: error.message,
+            latency_ms: Date.now() - start
+        });
+
+        return {
+            content: [{ type: "text", text: `❌ Pattern detection error: ${error.message}` }],
+            isError: true
+        };
+    }
+}
+
+/**
+ * INTELLIGENCE HANDLER 4: handleGetSuggestions
+ * Get intelligent code suggestions
+ */
+async function handleGetSuggestions({ currentFile, currentLine }) {
+    const start = Date.now();
+    try {
+        const engine = await getMemoryEngine();
+        const suggestions = await engine.getSuggestions({
+            currentFile,
+            currentLine
+        });
+
+        let output = `💡 Intelligent Suggestions\n`;
+        output += `Found: ${suggestions.length} suggestions\n\n`;
+
+        for (const suggestion of suggestions) {
+            output += `🎯 ${suggestion.type.toUpperCase()}\n`;
+            output += `   Category: ${suggestion.category || 'general'}\n`;
+            output += `   Confidence: ${(suggestion.confidence * 100).toFixed(0)}%\n`;
+            output += `   Description: ${suggestion.description}\n`;
+            if (suggestion.autoApply) {
+                output += `   ✅ Auto-apply available\n`;
+            }
+            output += `\n`;
+        }
+
+        reportAudit({
+            tool: 'get_suggestions',
+            instruction: currentFile || '',
+            status: 'success',
+            latency_ms: Date.now() - start,
+            files_count: suggestions.length
+        });
+
+        return { content: [{ type: "text", text: output }] };
+
+    } catch (error) {
+        reportAudit({
+            tool: 'get_suggestions',
+            instruction: currentFile || '',
+            status: 'error',
+            error_message: error.message,
+            latency_ms: Date.now() - start
+        });
+
+        return {
+            content: [{ type: "text", text: `❌ Suggestion error: ${error.message}` }],
+            isError: true
+        };
+    }
+}
+
+/**
+ * INTELLIGENCE HANDLER 5: handleSelectStrategy
+ * ML-based strategy selection
+ */
+async function handleSelectStrategy({ instruction, files = [] }) {
+    const start = Date.now();
+    try {
+        const engine = await getMemoryEngine();
+        const result = await engine.selectStrategy(instruction, { files });
+
+        let output = `🎯 Strategy Selection\n\n`;
+        output += `Instruction: "${instruction.substring(0, 100)}${instruction.length > 100 ? '...' : ''}"\n\n`;
+        output += `Selected Strategy: ${result.strategy.toUpperCase()}\n`;
+        output += `Confidence: ${(result.confidence * 100).toFixed(0)}%\n`;
+        output += `Reason: ${result.reason}\n\n`;
+        output += `Scores:\n`;
+        for (const [strat, score] of Object.entries(result.scores || {})) {
+            output += `  ${strat}: ${(score * 100).toFixed(0)}%\n`;
+        }
+
+        reportAudit({
+            tool: 'select_strategy',
+            instruction: instruction,
+            status: 'success',
+            latency_ms: Date.now() - start,
+            strategy: result.strategy
+        });
+
+        return { content: [{ type: "text", text: output }] };
+
+    } catch (error) {
+        reportAudit({
+            tool: 'select_strategy',
+            instruction: instruction,
+            status: 'error',
+            error_message: error.message,
+            latency_ms: Date.now() - start
+        });
+
+        return {
+            content: [{ type: "text", text: `❌ Strategy selection error: ${error.message}` }],
+            isError: true
+        };
+    }
+}
+
 /**
  * Start Server
  */