@mrxkun/mcfast-mcp 4.2.0 → 4.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "4.2.0",
+  "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/memory-engine.js

@@ -607,8 +607,8 @@ export class MemoryEngine {
           embedding = new Float32Array(cached.embedding.buffer, cached.embedding.byteOffset, cached.dimensions);
         } else {
           // Generate embedding
-          const result = this.embedder.embedCode(chunk.content);
-          embedding = result.vector;
+          const vector = await this.embedder.embedCode(chunk.content);
+          embedding = new Float32Array(vector);
 
           // Cache it
           this.memoryDb?.cacheEmbedding?.(

package/src/memory/stores/base-database.js

@@ -14,7 +14,7 @@ export class BaseDatabase {
     this.db = null;
     this.isInitialized = false;
     this.options = options;
-    
+
     // Logger (can be replaced with proper logger)
     this.logger = options.logger || console;
   }
@@ -23,13 +23,13 @@ export class BaseDatabase {
     if (this.isInitialized) return;
 
     await fs.mkdir(path.dirname(this.dbPath), { recursive: true });
-    
+
     this.db = new Database(this.dbPath);
     this.db.pragma('journal_mode = WAL');
-    
+
     this.createTables();
     this.isInitialized = true;
-    
+
     this._log(`Initialized at: ${this.dbPath}`);
   }
 
@@ -79,24 +79,24 @@ export class BaseDatabase {
    */
   searchFTS(query, limit = 20) {
     const startTime = performance.now();
-    
+
     const stmt = this.db.prepare(`
       SELECT 
         c.*,
         rank as bm25_score
       FROM chunks_fts fts
-      JOIN chunks c ON fts.rowid = c.id
+      JOIN chunks c ON fts.chunk_id = c.id
       WHERE chunks_fts MATCH ?
       ORDER BY rank
       LIMIT ?
     `);
-    
+
     const results = stmt.all(query, limit);
     const duration = performance.now() - startTime;
-    
+
     // Log search
     this.logSearch(query, 'fts', results.length, duration);
-    
+
     return {
       results: results.map(r => ({
         ...r,

package/src/memory/stores/codebase-database.js

@@ -19,13 +19,13 @@ export class CodebaseDatabase {
     if (this.isInitialized) return;
 
     await fs.mkdir(path.dirname(this.dbPath), { recursive: true });
-    
+
     this.db = new Database(this.dbPath);
     this.db.pragma('journal_mode = WAL');
-    
+
     this.createTables();
     this.isInitialized = true;
-    
+
     console.error(`[CodebaseDatabase] Initialized at: ${this.dbPath}`);
   }
 
@@ -88,26 +88,36 @@ export class CodebaseDatabase {
 
     // FTS5 for code search
     this.db.exec(`
-      CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+      DROP TABLE IF EXISTS chunks_fts;
+      CREATE VIRTUAL TABLE chunks_fts USING fts5(
+        chunk_id UNINDEXED,
         content,
-        content_rowid=id,
         tokenize='porter'
       );
     `);
 
+    // Backfill FTS5 index if chunks exist
+    this.db.exec(`
+      INSERT INTO chunks_fts(chunk_id, content) 
+      SELECT id, content FROM chunks;
+    `);
+
     // Triggers to sync FTS5
     this.db.exec(`
-      CREATE TRIGGER IF NOT EXISTS chunks_ai AFTER INSERT ON chunks BEGIN
-        INSERT INTO chunks_fts(rowid, content) VALUES (new.id, new.content);
+      DROP TRIGGER IF EXISTS chunks_ai;
+      CREATE TRIGGER chunks_ai AFTER INSERT ON chunks BEGIN
+        INSERT INTO chunks_fts(chunk_id, content) VALUES (new.id, new.content);
       END;
       
-      CREATE TRIGGER IF NOT EXISTS chunks_ad AFTER DELETE ON chunks BEGIN
-        INSERT INTO chunks_fts(chunks_fts, rowid, content) VALUES ('delete', old.id, old.content);
+      DROP TRIGGER IF EXISTS chunks_ad;
+      CREATE TRIGGER chunks_ad AFTER DELETE ON chunks BEGIN
+        DELETE FROM chunks_fts WHERE chunk_id = old.id;
       END;
       
-      CREATE TRIGGER IF NOT EXISTS chunks_au AFTER UPDATE ON chunks BEGIN
-        INSERT INTO chunks_fts(chunks_fts, rowid, content) VALUES ('delete', old.id, old.content);
-        INSERT INTO chunks_fts(rowid, content) VALUES (new.id, new.content);
+      DROP TRIGGER IF EXISTS chunks_au;
+      CREATE TRIGGER chunks_au AFTER UPDATE ON chunks BEGIN
+        DELETE FROM chunks_fts WHERE chunk_id = old.id;
+        INSERT INTO chunks_fts(chunk_id, content) VALUES (new.id, new.content);
       END;
     `);
 
@@ -202,7 +212,12 @@ export class CodebaseDatabase {
       (id, file_id, type, name, line_start, line_end, signature, exported, documentation)
       VALUES ($id, $file_id, $type, $name, $line_start, $line_end, $signature, $exported, $documentation)
     `);
-    return stmt.run(fact);
+    return stmt.run({
+      ...fact,
+      exported: fact.exported ? 1 : 0,
+      documentation: fact.documentation || null,
+      signature: fact.signature || null
+    });
   }
 
   deleteFactsByFile(fileId) {
@@ -300,23 +315,23 @@ export class CodebaseDatabase {
 
   searchFTS(query, limit = 20) {
     const startTime = performance.now();
-    
+
     const stmt = this.db.prepare(`
       SELECT 
         c.*,
         f.path as file_path,
         rank as bm25_score
       FROM chunks_fts fts
-      JOIN chunks c ON fts.rowid = c.id
+      JOIN chunks c ON fts.chunk_id = c.id
       JOIN files f ON c.file_id = f.id
       WHERE chunks_fts MATCH ?
       ORDER BY rank
       LIMIT ?
     `);
-    
+
     const results = stmt.all(query, limit);
     const duration = performance.now() - startTime;
-    
+
     return {
       results: results.map(r => ({
         chunk_id: r.id,
@@ -390,7 +405,7 @@ export class CodebaseDatabase {
     const chunks = this.db.prepare('SELECT COUNT(*) as count FROM chunks').get();
     const embeddings = this.db.prepare('SELECT COUNT(*) as count FROM embeddings').get();
     const edits = this.db.prepare('SELECT COUNT(*) as count FROM edit_history').get();
-    
+
     return {
       files: files.count,
       facts: facts.count,

package/src/memory/stores/memory-database.js

@@ -21,13 +21,13 @@ export class MemoryDatabase {
 
     // Create directory if not exists
     await fs.mkdir(path.dirname(this.dbPath), { recursive: true });
-    
+
     this.db = new Database(this.dbPath);
     this.db.pragma('journal_mode = WAL');
-    
+
     this.createTables();
     this.isInitialized = true;
-    
+
     console.error(`[MemoryDatabase] Initialized at: ${this.dbPath}`);
   }
 
@@ -53,26 +53,36 @@ export class MemoryDatabase {
 
     // FTS5 virtual table for full-text search
     this.db.exec(`
-      CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+      DROP TABLE IF EXISTS chunks_fts;
+      CREATE VIRTUAL TABLE chunks_fts USING fts5(
+        chunk_id UNINDEXED,
         content,
-        content_rowid=id,
         tokenize='porter'
       );
     `);
 
+    // Backfill FTS5 index if chunks exist
+    this.db.exec(`
+      INSERT INTO chunks_fts(chunk_id, content) 
+      SELECT id, content FROM chunks;
+    `);
+
     // Triggers to keep FTS5 in sync
     this.db.exec(`
-      CREATE TRIGGER IF NOT EXISTS chunks_ai AFTER INSERT ON chunks BEGIN
-        INSERT INTO chunks_fts(rowid, content) VALUES (new.id, new.content);
+      DROP TRIGGER IF EXISTS chunks_ai;
+      CREATE TRIGGER chunks_ai AFTER INSERT ON chunks BEGIN
+        INSERT INTO chunks_fts(chunk_id, content) VALUES (new.id, new.content);
       END;
       
-      CREATE TRIGGER IF NOT EXISTS chunks_ad AFTER DELETE ON chunks BEGIN
-        INSERT INTO chunks_fts(chunks_fts, rowid, content) VALUES ('delete', old.id, old.content);
+      DROP TRIGGER IF EXISTS chunks_ad;
+      CREATE TRIGGER chunks_ad AFTER DELETE ON chunks BEGIN
+        DELETE FROM chunks_fts WHERE chunk_id = old.id;
       END;
       
-      CREATE TRIGGER IF NOT EXISTS chunks_au AFTER UPDATE ON chunks BEGIN
-        INSERT INTO chunks_fts(chunks_fts, rowid, content) VALUES ('delete', old.id, old.content);
-        INSERT INTO chunks_fts(rowid, content) VALUES (new.id, new.content);
+      DROP TRIGGER IF EXISTS chunks_au;
+      CREATE TRIGGER chunks_au AFTER UPDATE ON chunks BEGIN
+        DELETE FROM chunks_fts WHERE chunk_id = old.id;
+        INSERT INTO chunks_fts(chunk_id, content) VALUES (new.id, new.content);
       END;
     `);
 
@@ -138,7 +148,7 @@ export class MemoryDatabase {
       (id, file_path, start_line, end_line, content, content_hash, chunk_type, created_at, updated_at)
       VALUES ($id, $file_path, $start_line, $end_line, $content, $content_hash, $chunk_type, $created_at, $updated_at)
     `);
-    
+
     const now = Date.now();
     return stmt.run({
       ...chunk,
@@ -234,25 +244,25 @@ export class MemoryDatabase {
    */
   searchFTS(query, limit = 20) {
     const startTime = performance.now();
-    
+
     // Use FTS5 rank for scoring (BM25)
     const stmt = this.db.prepare(`
       SELECT 
         c.*,
         rank as bm25_score
       FROM chunks_fts fts
-      JOIN chunks c ON fts.rowid = c.id
+      JOIN chunks c ON fts.chunk_id = c.id
       WHERE chunks_fts MATCH ?
       ORDER BY rank
       LIMIT ?
     `);
-    
+
     const results = stmt.all(query, limit);
     const duration = performance.now() - startTime;
-    
+
     // Log search
     this.logSearch(query, 'fts', results.length, duration);
-    
+
     return {
       results: results.map(r => ({
         ...r,
@@ -275,25 +285,25 @@ export class MemoryDatabase {
     const startTime = performance.now();
     const candidateMultiplier = 4;
     const maxCandidates = limit * candidateMultiplier;
-    
+
     // Get FTS results
     const ftsResults = this.searchFTS(query, maxCandidates);
-    
+
     // Normalize FTS scores to 0-1
     const ftsMap = new Map();
     ftsResults.results.forEach(r => {
       ftsMap.set(r.id, r.score);
     });
-    
+
     // Normalize vector scores to 0-1
     let maxVectorScore = 0;
     vectorResults.forEach(r => {
       if (r.similarity > maxVectorScore) maxVectorScore = r.similarity;
     });
-    
+
     // Combine results
     const combined = new Map();
-    
+
     // Add vector results
     vectorResults.forEach(r => {
       const normalizedVectorScore = maxVectorScore > 0 ? r.similarity / maxVectorScore : 0;
@@ -308,7 +318,7 @@ export class MemoryDatabase {
         sources: ['vector']
       });
     });
-    
+
     // Add FTS results not in vector
     ftsResults.results.forEach(r => {
       if (combined.has(r.id)) {
@@ -327,20 +337,20 @@ export class MemoryDatabase {
         });
       }
     });
-    
+
     // Calculate final scores (0.7 vector + 0.3 text)
     const results = Array.from(combined.values()).map(r => ({
       ...r,
       finalScore: (0.7 * r.vectorScore) + (0.3 * r.textScore)
     }));
-    
+
     // Sort by final score and filter
     results.sort((a, b) => b.finalScore - a.finalScore);
     const filtered = results.filter(r => r.finalScore >= 0.35).slice(0, limit);
-    
+
     const duration = performance.now() - startTime;
     this.logSearch(query, 'hybrid', filtered.length, duration);
-    
+
     return {
       results: filtered,
       metadata: {
@@ -363,9 +373,9 @@ export class MemoryDatabase {
         INSERT INTO search_history (query, query_hash, method, results_count, duration_ms, timestamp)
         VALUES (?, ?, ?, ?, ?, ?)
       `);
-      
+
       const queryHash = crypto.createHash('md5').update(query).digest('hex');
-      
+
       stmt.run(query, queryHash, method, resultsCount, Math.round(durationMs), Date.now());
     } catch (error) {
       // Silent fail - don't break search for logging
@@ -393,7 +403,7 @@ export class MemoryDatabase {
     const chunks = this.db.prepare('SELECT COUNT(*) as count FROM chunks').get();
     const embeddings = this.db.prepare('SELECT COUNT(*) as count FROM embeddings').get();
     const cache = this.db.prepare('SELECT COUNT(*) as count FROM embedding_cache').get();
-    
+
     return {
       files: files.count,
       chunks: chunks.count,

package/src/memory/utils/dashboard-client.js

@@ -27,7 +27,7 @@ export class DashboardClient {
    */
   async fetch(path, options = {}) {
     const url = `${this.baseUrl}/api/v1${path}`;
-    
+
     try {
       const response = await fetch(url, {
         ...options,
@@ -36,12 +36,12 @@ export class DashboardClient {
           ...options.headers
         }
       });
-      
+
       if (!response.ok) {
         const error = await response.json().catch(() => ({ error: 'Unknown error' }));
         throw new Error(error.error || `HTTP ${response.status}`);
       }
-      
+
       return response.json();
     } catch (error) {
       console.error(`[DashboardClient] API error (${path}):`, error.message);
@@ -55,11 +55,11 @@ export class DashboardClient {
   async getSearchConfig() {
     const cacheKey = 'searchConfig';
     const cached = this.cache.get(cacheKey);
-    
+
     if (cached && Date.now() - cached.timestamp < this.cacheTTL) {
       return cached.data;
     }
-    
+
     try {
       const config = await this.fetch('/settings');
       this.cache.set(cacheKey, { data: config, timestamp: Date.now() });
@@ -70,6 +70,7 @@ export class DashboardClient {
       return {
         enable_mercury_rerank: false,
         smart_routing_mode: 'auto',
+        bootstrap_mode: 'hybrid',
         rerank_threshold: 0.7,
         monthly_budget: 20,
         usage_this_month: 0
@@ -93,7 +94,7 @@ export class DashboardClient {
           }
         })
       });
-      
+
       return result;
     } catch (error) {
       console.error('[DashboardClient] Mercury rerank failed:', error.message);

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
         `,
@@ -46,8 +45,8 @@ export const QUERIES = {
         definitions: `
             (function_declaration name: (identifier) @name) @function
             (class_declaration name: (identifier) @name) @class
-            (method_definition key: (property_identifier) @name) @method
-            (variable_declarator name: (identifier) @name init: (arrow_function)) @arrow_function
+            (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 

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 }
   ];