@mrxkun/mcfast-mcp 4.1.10 → 4.1.11

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

@@ -0,0 +1,223 @@
+/**
+ * Base Database Class
+ * Common methods for MemoryDatabase and CodebaseDatabase
+ * Reduces code duplication between the two database classes
+ */
+
+import Database from 'better-sqlite3';
+import path from 'path';
+import fs from 'fs/promises';
+
+export class BaseDatabase {
+  constructor(dbPath = null, options = {}) {
+    this.dbPath = dbPath;
+    this.db = null;
+    this.isInitialized = false;
+    this.options = options;
+    
+    // Logger (can be replaced with proper logger)
+    this.logger = options.logger || console;
+  }
+
+  async initialize() {
+    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}`);
+  }
+
+  /**
+   * Override in subclass to create specific tables
+   */
+  createTables() {
+    throw new Error('createTables must be implemented in subclass');
+  }
+
+  /**
+   * Common chunk operations
+   */
+  insertChunk(chunk) {
+    throw new Error('insertChunk must be implemented in subclass');
+  }
+
+  deleteChunksByFile(filePath) {
+    throw new Error('deleteChunksByFile must be implemented in subclass');
+  }
+
+  getChunksByFile(filePath, limit = 100) {
+    throw new Error('getChunksByFile must be implemented in subclass');
+  }
+
+  getRecentChunks(limit = 100) {
+    throw new Error('getRecentChunks must be implemented in subclass');
+  }
+
+  /**
+   * Common embedding operations
+   */
+  insertEmbedding(embedding) {
+    throw new Error('insertEmbedding must be implemented in subclass');
+  }
+
+  getEmbedding(chunkId) {
+    throw new Error('getEmbedding must be implemented in subclass');
+  }
+
+  getAllEmbeddings() {
+    throw new Error('getAllEmbeddings must be implemented in subclass');
+  }
+
+  /**
+   * Common search operations (FTS5)
+   */
+  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
+      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,
+        score: 1 / (1 + Math.max(0, r.bm25_score))
+      })),
+      metadata: {
+        method: 'fts5',
+        duration: duration.toFixed(2) + 'ms',
+        candidates: results.length
+      }
+    };
+  }
+
+  /**
+   * Common search history logging
+   */
+  logSearch(query, method, resultsCount, durationMs) {
+    try {
+      const stmt = this.db.prepare(`
+        INSERT INTO search_history (query, method, results_count, duration_ms, timestamp)
+        VALUES (?, ?, ?, ?, ?)
+      `);
+      stmt.run(query, method, resultsCount, Math.round(durationMs), Date.now());
+    } catch (error) {
+      // Silent fail - don't break search for logging
+    }
+  }
+
+  getSearchStats(days = 7) {
+    const since = Date.now() - (days * 24 * 60 * 60 * 1000);
+    return this.db.prepare(`
+      SELECT 
+        method,
+        COUNT(*) as count,
+        AVG(duration_ms) as avg_duration,
+        AVG(results_count) as avg_results
+      FROM search_history
+      WHERE timestamp > ?
+      GROUP BY method
+    `).all(since);
+  }
+
+  /**
+   * Common file tracking operations
+   */
+  upsertFile(file) {
+    throw new Error('upsertFile must be implemented in subclass');
+  }
+
+  getFile(filePath) {
+    throw new Error('getFile must be implemented in subclass');
+  }
+
+  isFileIndexed(filePath, contentHash) {
+    const file = this.getFile(filePath);
+    return file && file.content_hash === contentHash;
+  }
+
+  deleteFile(filePath) {
+    throw new Error('deleteFile must be implemented in subclass');
+  }
+
+  /**
+   * Common stats
+   */
+  getStats() {
+    throw new Error('getStats must be implemented in subclass');
+  }
+
+  /**
+   * Maintenance
+   */
+  vacuum() {
+    this.db.exec('VACUUM');
+    this.db.exec('ANALYZE');
+  }
+
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.isInitialized = false;
+    }
+  }
+
+  /**
+   * Internal logger
+   */
+  _log(message, level = 'info') {
+    const prefix = `[${this.constructor.name}]`;
+    if (level === 'error') {
+      console.error(`${prefix} ${message}`);
+    } else if (level === 'warn') {
+      console.warn(`${prefix} ${message}`);
+    } else {
+      console.error(`${prefix} ${message}`);
+    }
+  }
+
+  /**
+   * Safe execute with error handling
+   */
+  safeExecute(fn, errorMessage = 'Operation failed') {
+    try {
+      return fn();
+    } catch (error) {
+      this._log(`${errorMessage}: ${error.message}`, 'error');
+      return null;
+    }
+  }
+
+  /**
+   * Safe async execute with error handling
+   */
+  async safeExecuteAsync(fn, errorMessage = 'Operation failed') {
+    try {
+      return await fn();
+    } catch (error) {
+      this._log(`${errorMessage}: ${error.message}`, 'error');
+      return null;
+    }
+  }
+}
+
+export default BaseDatabase;

package/src/memory/utils/chunker.js

@@ -77,6 +77,7 @@ export class Chunker {
       id: this.generateChunkId(filePath, startLine),
       file_id: this.generateFileId(filePath),
       content: content,
+      content_hash: crypto.createHash('md5').update(content).digest('hex'),
       start_line: startLine,
       end_line: endLine,
       token_count: tokens

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;