@mrxkun/mcfast-mcp 4.1.10 → 4.1.12

package/src/memory/utils/indexer.js

@@ -59,12 +59,12 @@ export class CodeIndexer {
     const fileId = this.generateFileId(filePath);
 
     try {
-      // Use getQuery to compile the query properly
+      // Try tree-sitter query first (for functions)
       const query = await getQuery(language, 'definitions');
-      
-      if (query) {
+
+      if (query && ast?.rootNode) {
         const captures = query.captures(ast.rootNode);
-        
+
         for (const capture of captures) {
           if (capture.name === 'name' || capture.name === 'function') {
             facts.push({
@@ -81,6 +81,95 @@ export class CodeIndexer {
           }
         }
       }
+
+      // Fallback/enhancement: Extract more facts using regex patterns
+      // This works across languages and captures additional symbols
+      const content = ast?.text || '';
+
+      // Extract classes
+      const classMatches = content.matchAll(/class\s+(\w+)(?:\s+extends\s+(\w+))?/g);
+      for (const match of classMatches) {
+        if (!facts.find(f => f.type === 'class' && f.name === match[1])) {
+          facts.push({
+            id: this.generateFactId(fileId, match[1], 'class'),
+            file_id: fileId,
+            type: 'class',
+            name: match[1],
+            line_start: this.findLineNumber(content, match[0]) || 0,
+            line_end: 0,
+            signature: match[2] ? `extends ${match[2]}` : '',
+            exported: this.isExported(content, match[1]),
+            confidence: 0.9
+          });
+        }
+      }
+
+      // Extract interfaces (TypeScript)
+      if (language === 'typescript') {
+        const interfaceMatches = content.matchAll(/interface\s+(\w+)(?:\s+extends\s+([^{]+))?/g);
+        for (const match of interfaceMatches) {
+          if (!facts.find(f => f.type === 'interface' && f.name === match[1])) {
+            facts.push({
+              id: this.generateFactId(fileId, match[1], 'interface'),
+              file_id: fileId,
+              type: 'interface',
+              name: match[1],
+              line_start: this.findLineNumber(content, match[0]) || 0,
+              line_end: 0,
+              signature: match[2] ? `extends ${match[2].trim()}` : '',
+              exported: this.isExported(content, match[1]),
+              confidence: 0.9
+            });
+          }
+        }
+      }
+
+      // Extract imports
+      const importMatches = content.matchAll(/import\s+(?:(\w+)|\{\s*([^}]+)\s*\}|\*\s+as\s+(\w+))\s+from\s+['"]([^'"]+)['"]/g);
+      for (const match of importMatches) {
+        const imported = match[1] || match[2]?.split(',').map(s => s.trim().split(' ')[0]).join(', ') || match[3];
+        facts.push({
+          id: this.generateFactId(fileId, imported, 'import'),
+          file_id: fileId,
+          type: 'import',
+          name: imported,
+          line_start: this.findLineNumber(content, match[0]) || 0,
+          line_end: 0,
+          signature: match[4],
+          exported: false,
+          confidence: 1.0
+        });
+      }
+
+      // Extract exports
+      const exportMatches = content.matchAll(/export\s+(?:default\s+)?(?:const|let|var|function|class|interface|type)\s+(\w+)/g);
+      for (const match of exportMatches) {
+        if (!facts.find(f => f.name === match[1] && f.exported)) {
+          const existing = facts.find(f => f.name === match[1]);
+          if (existing) {
+            existing.exported = true;
+          }
+        }
+      }
+
+      // Extract type definitions (TypeScript)
+      if (language === 'typescript') {
+        const typeMatches = content.matchAll(/type\s+(\w+)\s*=/g);
+        for (const match of typeMatches) {
+          facts.push({
+            id: this.generateFactId(fileId, match[1], 'type'),
+            file_id: fileId,
+            type: 'type',
+            name: match[1],
+            line_start: this.findLineNumber(content, match[0]) || 0,
+            line_end: 0,
+            signature: 'type alias',
+            exported: this.isExported(content, match[1]),
+            confidence: 0.8
+          });
+        }
+      }
+
     } catch (error) {
       console.warn(`[Indexer] Failed to extract facts:`, error.message);
     }
@@ -88,6 +177,23 @@ export class CodeIndexer {
     return facts;
   }
 
+  // Helper to find line number of a string in content
+  findLineNumber(content, searchStr) {
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes(searchStr)) {
+        return i + 1;
+      }
+    }
+    return 0;
+  }
+
+  // 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);
+  }
+
   async generateEmbeddings(chunks, language = 'javascript') {
     const embeddings = [];
     

package/src/memory/utils/logger.js

@@ -0,0 +1,162 @@
+/**
+ * Logger Utility for Memory System
+ * Provides structured logging with different levels
+ * 
+ * Features:
+ * - Log levels: debug, info, warn, error
+ * - Timestamp formatting
+ * - Module context
+ * - Configurable output
+ */
+
+const LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+
+class Logger {
+  constructor(options = {}) {
+    this.module = options.module || 'Memory';
+    this.level = options.level || 'info';
+    this.prefix = options.prefix || '';
+    
+    // Set minimum level
+    this.minLevel = LOG_LEVELS[options.minLevel?.toLowerCase()] ?? LOG_LEVELS.info;
+  }
+
+  /**
+   * Set log level
+   */
+  setLevel(level) {
+    this.minLevel = LOG_LEVELS[level?.toLowerCase()] ?? LOG_LEVELS.info;
+  }
+
+  /**
+   * Format timestamp
+   */
+  _formatTime() {
+    return new Date().toISOString();
+  }
+
+  /**
+   * Format log message
+   */
+  _format(level, message, data = null) {
+    const timestamp = this._formatTime();
+    const context = this.prefix ? `[${this.prefix}]` : `[${this.module}]`;
+    
+    let formatted = `${timestamp} ${context} ${level.toUpperCase()}: ${message}`;
+    
+    if (data) {
+      if (data instanceof Error) {
+        formatted += `\n  Stack: ${data.stack}`;
+      } else if (typeof data === 'object') {
+        formatted += `\n  Data: ${JSON.stringify(data, null, 2)}`;
+      } else {
+        formatted += `\n  ${data}`;
+      }
+    }
+    
+    return formatted;
+  }
+
+  /**
+   * Debug level logging
+   */
+  debug(message, data = null) {
+    if (this.minLevel > LOG_LEVELS.debug) return;
+    console.error(this._format('debug', message, data));
+  }
+
+  /**
+   * Info level logging
+   */
+  info(message, data = null) {
+    if (this.minLevel > LOG_LEVELS.info) return;
+    console.error(this._format('info', message, data));
+  }
+
+  /**
+   * Warn level logging  
+   */
+  warn(message, data = null) {
+    if (this.minLevel > LOG_LEVELS.warn) return;
+    console.error(this._format('warn', message, data));
+  }
+
+  /**
+   * Error level logging
+   */
+  error(message, data = null) {
+    if (this.minLevel > LOG_LEVELS.error) return;
+    console.error(this._format('error', message, data));
+  }
+
+  /**
+   * Create child logger with additional context
+   */
+  child(options = {}) {
+    return new Logger({
+      ...options,
+      module: this.module,
+      minLevel: Object.keys(LOG_LEVELS).find(key => LOG_LEVELS[key] === this.minLevel)
+    });
+  }
+
+  /**
+   * Timer for performance tracking
+   */
+  timer(label = 'operation') {
+    return new Timer(this, label);
+  }
+}
+
+/**
+ * Timer class for performance tracking
+ */
+class Timer {
+  constructor(logger, label) {
+    this.logger = logger;
+    this.label = label;
+    this.start = performance.now();
+  }
+
+  end() {
+    const duration = performance.now() - this.start;
+    this.logger.debug(`${this.label} completed in ${duration.toFixed(2)}ms`);
+    return duration;
+  }
+}
+
+// Pre-configured loggers for common modules
+export const loggers = {
+  memory: new Logger({ module: 'MemoryEngine', minLevel: 'info' }),
+  watcher: new Logger({ module: 'FileWatcher', minLevel: 'info' }),
+  indexer: new Logger({ module: 'Indexer', minLevel: 'info' }),
+  database: new Logger({ module: 'Database', minLevel: 'info' }),
+  embedder: new Logger({ module: 'Embedder', minLevel: 'info' }),
+  intelligence: new Logger({ module: 'Intelligence', minLevel: 'info' })
+};
+
+/**
+ * Get logger for specific module
+ */
+export function getLogger(module, options = {}) {
+  if (loggers[module]) {
+    return loggers[module].child(options);
+  }
+  return new Logger({ module, ...options });
+}
+
+/**
+ * Set global log level
+ */
+export function setGlobalLevel(level) {
+  Object.values(loggers).forEach(logger => {
+    logger.setLevel(level);
+  });
+}
+
+export default Logger;

package/src/memory/utils/vector-index.js

@@ -0,0 +1,241 @@
+/**
+ * Vector Index for fast similarity search
+ * Implements HNSW-like in-memory index for embeddings
+ * 
+ * This provides O(log n) search instead of O(n) linear scan
+ */
+
+export class VectorIndex {
+  constructor(options = {}) {
+    this.dimension = options.dimension || 1024;
+    this.maxElements = options.maxElements || 10000;
+    this.efConstruction = options.efConstruction || 200;
+    this.M = options.M || 16;
+    
+    // In-memory storage
+    this.vectors = new Map();  // id -> Float32Array
+    this.metadata = new Map(); // id -> metadata
+    
+    // Simple HNSW-like structure (layer 0 only for simplicity)
+    this.connections = new Map(); // id -> [neighbor_ids]
+    
+    // Entry point for search
+    this.entryPoint = null;
+    
+    // Stats
+    this.stats = {
+      searches: 0,
+      totalDuration: 0,
+      avgDuration: 0
+    };
+  }
+
+  /**
+   * Add vector to index
+   */
+  add(id, vector, metadata = {}) {
+    if (vector.length !== this.dimension) {
+      throw new Error(`Vector dimension ${vector.length} != expected ${this.dimension}`);
+    }
+    
+    const vec = vector instanceof Float32Array ? vector : new Float32Array(vector);
+    this.vectors.set(id, vec);
+    this.metadata.set(id, metadata);
+    
+    // Initialize empty connections
+    if (!this.connections.has(id)) {
+      this.connections.set(id, []);
+    }
+    
+    // Set entry point if first element
+    if (!this.entryPoint) {
+      this.entryPoint = id;
+    }
+    
+    // Build connections (simplified - just connect to nearest)
+    this._buildConnections(id, vec);
+    
+    return this;
+  }
+
+  /**
+   * Build connections to nearest neighbors
+   */
+  _buildConnections(id, vector) {
+    // Find nearest neighbors
+    const neighbors = [];
+    
+    for (const [otherId, otherVec] of this.vectors) {
+      if (otherId === id) continue;
+      
+      const dist = this._cosineDistance(vector, otherVec);
+      neighbors.push({ id: otherId, dist });
+    }
+    
+    // Sort by distance and take M nearest
+    neighbors.sort((a, b) => a.dist - b.dist);
+    const nearest = neighbors.slice(0, this.M);
+    
+    // Update connections
+    const connections = this.connections.get(id) || [];
+    nearest.forEach(n => connections.push(n.id));
+    this.connections.set(id, connections);
+    
+    // Add reverse connections
+    nearest.forEach(n => {
+      const reverseConns = this.connections.get(n.id) || [];
+      if (!reverseConns.includes(id)) {
+        reverseConns.push(id);
+        this.connections.set(n.id, reverseConns);
+      }
+    });
+  }
+
+  /**
+   * Search for nearest neighbors
+   */
+  search(queryVector, k = 5, ef = 10) {
+    const startTime = performance.now();
+    
+    if (!this.entryPoint || this.vectors.size === 0) {
+      return [];
+    }
+    
+    const query = queryVector instanceof Float32Array 
+      ? queryVector 
+      : new Float32Array(queryVector);
+    
+    // Greedy search from entry point
+    let current = this.entryPoint;
+    let bestDist = this._cosineDistance(query, this.vectors.get(current));
+    let visited = new Set([current]);
+    
+    // Explore neighbors
+    let candidates = [current];
+    let results = [{ id: current, dist: bestDist }];
+    
+    while (candidates.length > 0) {
+      const candidate = candidates.shift();
+      const candidateVec = this.vectors.get(candidate);
+      const candidateDist = this._cosineDistance(query, candidateVec);
+      
+      // Update results
+      if (results.length < k || candidateDist < results[results.length - 1].dist) {
+        results.push({ id: candidate, dist: candidateDist });
+        results.sort((a, b) => a.dist - b.dist);
+        results = results.slice(0, k);
+      }
+      
+      // Get neighbors
+      const neighbors = this.connections.get(candidate) || [];
+      for (const neighbor of neighbors) {
+        if (visited.has(neighbor)) continue;
+        visited.add(neighbor);
+        
+        const neighborDist = this._cosineDistance(query, this.vectors.get(neighbor));
+        
+        // Add to candidates if promising
+        if (results.length < k || neighborDist < results[results.length - 1].dist) {
+          candidates.push(neighbor);
+        }
+      }
+    }
+    
+    // Sort final results
+    results.sort((a, b) => a.dist - b.dist);
+    
+    // Convert distance to similarity
+    const searchResults = results.slice(0, k).map(r => ({
+      id: r.id,
+      similarity: 1 - r.dist,
+      distance: r.dist,
+      metadata: this.metadata.get(r.id)
+    }));
+    
+    // Update stats
+    const duration = performance.now() - startTime;
+    this.stats.searches++;
+    this.stats.totalDuration += duration;
+    this.stats.avgDuration = this.stats.totalDuration / this.stats.searches;
+    
+    return searchResults;
+  }
+
+  /**
+   * Cosine distance (1 - cosine similarity)
+   */
+  _cosineDistance(a, b) {
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    
+    const similarity = dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+    return 1 - similarity;
+  }
+
+  /**
+   * Bulk add vectors
+   */
+  bulkAdd(items) {
+    for (const item of items) {
+      this.add(item.id, item.vector, item.metadata);
+    }
+    return this;
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      size: this.vectors.size,
+      dimension: this.dimension,
+      maxElements: this.maxElements
+    };
+  }
+
+  /**
+   * Clear index
+   */
+  clear() {
+    this.vectors.clear();
+    this.metadata.clear();
+    this.connections.clear();
+    this.entryPoint = null;
+    this.stats = { searches: 0, totalDuration: 0, avgDuration: 0 };
+  }
+
+  /**
+   * Serialize to JSON
+   */
+  toJSON() {
+    const data = {};
+    for (const [id, vec] of this.vectors) {
+      data[id] = {
+        vector: Array.from(vec),
+        metadata: this.metadata.get(id)
+      };
+    }
+    return data;
+  }
+
+  /**
+   * Load from JSON
+   */
+  static fromJSON(json, options = {}) {
+    const index = new VectorIndex(options);
+    for (const [id, item] of Object.entries(json)) {
+      index.add(id, item.vector, item.metadata);
+    }
+    return index;
+  }
+}
+
+export default VectorIndex;