@mrxkun/mcfast-mcp 4.0.14 → 4.1.0

package/src/tools/memory_search.js

@@ -1,35 +1,39 @@
 /**
- * memory_search Tool v2.0
- * Hybrid search tool using MemoryEngine
- * Version: 2.0.0
+ * memory_search Tool v3.0
+ * Hybrid search using MemoryEngine v4.1.0
+ * Supports: Vector 70% + BM25 30% hybrid search
  */
 
 import { MemoryEngine } from '../memory/index.js';
 
 // Memory engine instance (initialized lazily)
 let memoryEngine = null;
+let enginePromise = null;
 
 async function getMemoryEngine() {
-    if (!memoryEngine) {
+    if (memoryEngine) return memoryEngine;
+    if (enginePromise) return enginePromise;
+    
+    enginePromise = (async () => {
         memoryEngine = new MemoryEngine({
             apiKey: process.env.MCFAST_TOKEN,
             enableSync: true
         });
         await memoryEngine.initialize(process.cwd());
-    }
-    return memoryEngine;
+        return memoryEngine;
+    })();
+    
+    return enginePromise;
 }
 
 /**
- * Execute memory search using intelligent hybrid search
+ * Execute memory search using hybrid search (Vector 70% + BM25 30%)
  * @param {Object} args - Tool arguments
  * @param {string} args.query - Search query
- * @param {string} [args.type='all'] - Filter by type: 'all', 'facts', 'history', 'code'
+ * @param {string} [args.type='all'] - Filter by type: 'all', 'memory', 'codebase', 'facts'
  * @param {number} [args.maxResults=6] - Maximum results to return
  * @param {number} [args.minScore=0.35] - Minimum score threshold
- * @param {Object} [args.context] - Context information
- * @param {string} [args.context.currentFile] - Current file being edited
- * @param {number} [args.context.currentLine] - Current line number
+ * @param {boolean} [args.useHybrid=true] - Use hybrid search (Vector + BM25)
  * @returns {Promise<Object>} Search results
  */
 export async function execute(args) {
@@ -38,74 +42,72 @@ export async function execute(args) {
         type = 'all',
         maxResults = 6,
         minScore = 0.35,
-        context: contextInfo = {}
+        useHybrid = true
     } = args;
 
+    if (!query || query.trim().length === 0) {
+        return {
+            content: [{
+                type: "text",
+                text: "❌ Error: 'query' parameter is required"
+            }],
+            isError: true
+        };
+    }
+
     const startTime = Date.now();
 
     try {
         const engine = await getMemoryEngine();
         let results = [];
+        let searchMetadata = {};
+
+        if (type === 'memory' || type === 'all') {
+            // Search memory notes (daily logs + curated)
+            const memoryResult = await engine.searchMemory(query, {
+                limit: maxResults * 2,
+                useHybrid,
+                minScore
+            });
+            
+            results.push(...memoryResult.results.map(r => ({
+                type: 'memory',
+                content: r.content,
+                file: r.file_path || r.filePath,
+                lines: [r.start_line || r.startLine, r.end_line || r.endLine],
+                score: r.finalScore || r.score || r.similarity,
+                vectorScore: r.vectorScore,
+                textScore: r.textScore,
+                source: r.sources?.join('+') || 'vector'
+            })));
+            
+            searchMetadata.memory = memoryResult.metadata;
+        }
+
+        if (type === 'codebase' || type === 'all') {
+            // Search codebase
+            const codebaseResult = await engine.searchCodebase(query, maxResults * 2);
+            
+            results.push(...codebaseResult.results.map(r => ({
+                type: 'code',
+                content: r.content || r.code,
+                file: r.file_path || r.filePath || r.path,
+                lines: [r.start_line || r.startLine, r.end_line || r.endLine],
+                score: r.similarity || r.score,
+                source: r.source || 'vector'
+            })));
+            
+            searchMetadata.codebase = codebaseResult.metadata;
+        }
 
         if (type === 'facts') {
             // Search facts only
             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,
-                source: 'facts'
-            }));
-        } else if (type === 'history') {
-            // Search edit history via database
-            const history = engine.db.getRecentEdits(maxResults * 2);
-            const filtered = history.filter(edit =>
-                edit.instruction.toLowerCase().includes(query.toLowerCase()) ||
-                (edit.files && edit.files.some(f => f.toLowerCase().includes(query.toLowerCase())))
-            );
-            results = filtered.slice(0, maxResults).map(edit => ({
-                type: 'history',
-                content: edit.instruction,
-                files: edit.files,
-                strategy: edit.strategy,
-                success: edit.success,
-                timestamp: edit.timestamp,
-                score: edit.success ? 0.8 : 0.5,
-                source: 'history'
-            }));
-        } else if (type === 'code') {
-            // Use ultra search for 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,
-                lines: [result.startLine, result.endLine],
-                score: result.finalScore || result.score,
-                source: 'ultra-hybrid'
-            }));
-        } else {
-            // Use intelligent search (all types)
-            const searchResult = await engine.intelligentSearch(query, { 
-                limit: maxResults,
-                currentFile: contextInfo.currentFile
-            });
-            
-            results = searchResult.results.map(result => ({
-                type: 'chunk',
-                content: result.code || result.content,
-                file: result.filePath || result.path,
-                score: result.finalScore || result.score,
-                source: searchResult.metadata?.method || 'intelligent'
-            }));
-
-            // Add facts if available
-            const facts = await engine.searchFacts(query, Math.floor(maxResults / 2));
             results.push(...facts.map(fact => ({
                 type: 'fact',
-                content: `${fact.type}: ${fact.name}`,
-                file: fact.file_id,
+                content: `${fact.type}: ${fact.name}${fact.signature ? ` (${fact.signature})` : ''}`,
+                file: fact.file_path || fact.file_id,
+                lines: [fact.line_start, fact.line_end],
                 score: fact.confidence || 0.8,
                 source: 'facts'
             })));
@@ -118,7 +120,7 @@ export async function execute(args) {
             .slice(0, maxResults);
 
         // Format output
-        const formattedResults = formatResults(results, type);
+        const formattedResults = formatResults(results, query);
         const latency = Date.now() - startTime;
 
         return {
@@ -131,6 +133,8 @@ export async function execute(args) {
                 type,
                 resultCount: results.length,
                 latency,
+                minScore,
+                searchMetadata,
                 sources: [...new Set(results.map(r => r.source || 'unknown'))]
             }
         };
@@ -149,13 +153,15 @@ export async function execute(args) {
 /**
  * Format results for display
  */
-function formatResults(results, type) {
+function formatResults(results, query) {
     if (!results || results.length === 0) {
-        return `🔍 Memory Search: No results found for query`;
+        return `🔍 Memory Search: No results found for "${query}"\n\nTip: Try a different search term or check if memory is indexed.`;
     }
 
     let output = `🔍 Memory Search Results\n`;
-    output += `Found: ${results.length} results\n\n`;
+    output += `Query: "${query}"\n`;
+    output += `Found: ${results.length} result(s)\n`;
+    output += '─'.repeat(50) + '\n\n';
 
     // Group by type
     const byType = {};
@@ -164,13 +170,21 @@ function formatResults(results, type) {
         byType[result.type].push(result);
     }
 
-    for (const [resultType, items] of Object.entries(byType)) {
-        output += `${getTypeIcon(resultType)} ${resultType.toUpperCase()} (${items.length})\n`;
-        output += '─'.repeat(40) + '\n';
-
-        for (const item of items.slice(0, 5)) {
-            output += `  ${formatItem(item)}\n\n`;
+    // Display by type
+    const typeOrder = ['memory', 'code', 'fact'];
+    for (const resultType of typeOrder) {
+        if (!byType[resultType]) continue;
+        
+        const items = byType[resultType];
+        output += `${getTypeIcon(resultType)} ${getTypeLabel(resultType)} (${items.length})\n`;
+        output += '─'.repeat(50) + '\n';
+
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            output += `[${i + 1}] ${formatItem(item)}\n\n`;
         }
+        
+        output += '\n';
     }
 
     return output;
@@ -178,18 +192,28 @@ function formatResults(results, type) {
 
 function getTypeIcon(type) {
     const icons = {
-        fact: '📌',
-        chunk: '📝',
-        history: '📜'
+        memory: '📝',
+        code: '💻',
+        fact: '📌'
     };
     return icons[type] || '•';
 }
 
+function getTypeLabel(type) {
+    const labels = {
+        memory: 'Memory Notes',
+        code: 'Code',
+        fact: 'Facts'
+    };
+    return labels[type] || type;
+}
+
 function formatItem(item) {
     let text = '';
 
+    // File path with line numbers
     if (item.file) {
-        text += `${item.file}`;
+        text += `📄 ${item.file}`;
         if (item.lines && item.lines[0]) {
             text += `:${item.lines[0]}`;
             if (item.lines[1] && item.lines[1] !== item.lines[0]) {
@@ -199,12 +223,20 @@ function formatItem(item) {
         text += '\n';
     }
 
-    // Truncate content
-    const content = item.content?.substring(0, 150) || '';
-    text += `  ${content}${content.length >= 150 ? '...' : ''}`;
-
-    text += `\n  Score: ${(item.score * 100).toFixed(0)}%`;
-
+    // Content preview (truncate)
+    const content = item.content?.substring(0, 200)?.replace(/\n/g, ' ') || '';
+    text += `   ${content}${content.length >= 200 ? '...' : ''}\n`;
+
+    // Score with breakdown
+    const scorePct = (item.score * 100).toFixed(1);
+    text += `   Score: ${scorePct}%`;
+    
+    if (item.vectorScore !== undefined && item.textScore !== undefined) {
+        const vPct = (item.vectorScore * 100).toFixed(0);
+        const tPct = (item.textScore * 100).toFixed(0);
+        text += ` (vector: ${vPct}%, text: ${tPct}%)`;
+    }
+    
     if (item.source) {
         text += ` • ${item.source}`;
     }