@mrxkun/mcfast-mcp 4.2.1 → 4.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "4.2.1",
+  "version": "4.2.2",
   "description": "Ultra-fast code editing with WASM acceleration, fuzzy patching, multi-layer caching, and 8 unified tools. v4.1.12: Implement proper MCP stdio transport lifecycle and cleanup to prevent zombie processes.",
   "type": "module",
   "bin": {
@@ -61,4 +61,4 @@
     "tree-sitter-rust": "^0.24.0",
     "web-tree-sitter": "^0.26.5"
   }
-}
+}

package/src/memory/utils/indexer.js

@@ -18,17 +18,17 @@ export class CodeIndexer {
 
   async indexFile(filePath, content) {
     const startTime = Date.now();
-    
+
     const language = detectLanguage(filePath);
     const contentHash = crypto.createHash('md5').update(content).digest('hex');
-    
+
     const ast = await this.parseAST(content, filePath, language);
     const facts = ast ? await this.extractFacts(ast, filePath, language) : [];
     const chunks = this.chunker.chunk(content, { filePath, language });
     const embeddings = await this.generateEmbeddings(chunks, language);
-    
+
     const duration = Date.now() - startTime;
-    
+
     return {
       file: {
         id: this.generateFileId(filePath),
@@ -191,19 +191,20 @@ export class CodeIndexer {
   // Check if a symbol is exported
   isExported(content, symbolName) {
     return new RegExp(`export\\s+.*\\b${symbolName}\\b`).test(content) ||
-           new RegExp(`export\\s+default`).test(content);
+      new RegExp(`export\\s+default`).test(content);
   }
 
   async generateEmbeddings(chunks, language = 'javascript') {
     const embeddings = [];
-    
+
     try {
       for (const chunk of chunks) {
         const vector = await this.embedder.embedCode(chunk.content, language);
         embeddings.push({
           chunk_id: chunk.id,
           embedding: Buffer.from(new Float32Array(vector).buffer),
-          model: 'simple-embedder'
+          model: 'simple-embedder',
+          dimensions: vector.length
         });
       }
     } catch (error) {

package/src/strategies/tree-sitter/queries.js

@@ -6,20 +6,19 @@ export const QUERIES = {
     typescript: {
         definitions: `
             (function_declaration name: (identifier) @name) @function
-            (class_declaration name: (type_identifier) @name) @class
-            (method_definition key: (property_identifier) @name) @method
-            (interface_declaration name: (type_identifier) @name) @interface
+            (class_declaration name: (identifier) @name) @class
+            (method_definition name: (property_identifier) @name) @method
+            (variable_declarator name: (identifier) @name value: (arrow_function)) @arrow_function
             (export_statement 
               (function_declaration name: (identifier) @name)) @export_function
             (export_statement 
-              (class_declaration name: (type_identifier) @name)) @export_class
+              (class_declaration name: (identifier) @name)) @export_class
             (export_statement
               (lexical_declaration
                 (variable_declarator name: (identifier) @name))) @export_const
         `,
         references: `
             (identifier) @ref
-            (type_identifier) @ref
             (property_identifier) @ref
             (shorthand_property_identifier_pattern) @ref
         `,

package/src/utils/parallel-search.js

@@ -13,12 +13,12 @@ export class ParallelSearch {
    * Returns results as soon as all complete (or timeout)
    */
   async searchAll(searchFns, query, limit) {
-    const searchPromises = searchFns.map(fn => 
+    const searchPromises = searchFns.map(fn =>
       this.executeWithTimeout(fn, query, limit)
     );
 
     const results = await Promise.allSettled(searchPromises);
-    
+
     return results.map((result, index) => ({
       strategy: searchFns[index].name || `search-${index}`,
       status: result.status,
@@ -33,7 +33,7 @@ export class ParallelSearch {
   async executeWithTimeout(fn, query, limit) {
     return Promise.race([
       fn(query, limit),
-      new Promise((_, reject) => 
+      new Promise((_, reject) =>
         setTimeout(() => reject(new Error('Search timeout')), this.timeout)
       )
     ]);
@@ -44,14 +44,22 @@ export class ParallelSearch {
    */
   mergeResults(results, maxResults = 10) {
     const allItems = [];
-    
+
     for (const result of results) {
       if (result.status === 'fulfilled' && result.data) {
-        const items = Array.isArray(result.data) ? result.data : [result.data];
+        let items = [];
+        if (Array.isArray(result.data)) {
+          items = result.data;
+        } else if (result.data.results && Array.isArray(result.data.results)) {
+          items = result.data.results;
+        } else {
+          items = [result.data];
+        }
+
         allItems.push(...items.map(item => ({
           ...item,
           _source: result.strategy,
-          _score: item.score || item.similarity || item.confidence || 0.5
+          _score: item.score || item.similarity || item.confidence || item.bm25_score || 0.5
         })));
       }
     }
@@ -96,7 +104,7 @@ export class ParallelSearch {
         query,
         limit
       );
-      
+
       results = [...results, ...slowResults];
       return this.mergeResults(results, limit);
     }
@@ -108,10 +116,10 @@ export class ParallelSearch {
 // Helper for MemoryEngine parallel search
 export async function parallelMemorySearch(engine, query, limit) {
   const parallel = new ParallelSearch();
-  
+
   const strategies = [
     { fn: (q, l) => engine.searchFacts(q, l), name: 'facts', fast: true },
-    { fn: (q, l) => engine.searchFTS(q, l), name: 'fts', fast: true },
+    { fn: (q, l) => engine.codebaseDb?.searchFTS?.(q, l) || { results: [] }, name: 'fts', fast: true },
     { fn: (q, l) => engine.searchVector(q, l), name: 'vector', fast: false }
   ];