cf-memory-mcp 3.8.3 → 3.8.5

package/bin/cf-memory-mcp-indexer.js

@@ -302,49 +302,41 @@ class IncrementalIndexer {
     // Initial index
     await this.index();
     
-    // Watch for changes
-    const chokidar = await this.loadChokidar();
-    
-    const watcher = chokidar.watch(this.projectPath, {
-      ignored: this.exclude,
-      persistent: true,
-      ignoreInitial: true
-    });
-    
-    let debounceTimer = null;
-    
-    const handleChange = async () => {
-      if (debounceTimer) clearTimeout(debounceTimer);
-      debounceTimer = setTimeout(async () => {
-        console.log('\n🔄 Changes detected, re-indexing...');
-        await this.index();
-        console.log('');
-      }, 1000);
+    // Use Node's built-in fs.watch (no external deps needed)
+    const fs = require('fs');
+    const watchDir = (dir) => {
+      let watcher;
+      try {
+        watcher = fs.watch(dir, { recursive: true }, (eventType, filename) => {
+          if (filename) {
+            this.handleFileChange(dir, filename);
+          }
+        });
+      } catch (err) {
+        // Ignore errors for now
+      }
+      return watcher;
     };
     
-    watcher
-      .on('add', path => handleChange())
-      .on('change', path => handleChange())
-      .on('unlink', path => handleChange());
+    const watcher = watchDir(this.projectPath);
     
     // Keep process alive
     process.on('SIGINT', () => {
       console.log('\n👋 Stopping watcher...');
-      watcher.close();
+      if (watcher) watcher.close();
       process.exit(0);
     });
   }
 
-  async loadChokidar() {
-    try {
-      return require('chokidar');
-    } catch (err) {
-      console.log('Installing chokidar for file watching...');
-      const { execSync } = require('child_process');
-      execSync('npm install chokidar --save-dev', { cwd: __dirname, stdio: 'inherit' });
-      return require('chokidar');
-    }
+  handleFileChange(baseDir, filename) {
+    // Debounce rapid changes
+    if (this._debounceTimer) clearTimeout(this._debounceTimer);
+    this._debounceTimer = setTimeout(async () => {
+      console.log(`\n🔄 File changed: ${filename}`);
+      await this.index();
+    }, 1000);
   }
+
 }
 
 // CLI
@@ -355,8 +347,19 @@ async function main() {
   }
   
   const args = process.argv.slice(2);
-  const command = args[0];
-  const projectPath = args[1] || '.';
+  
+  // Detect command from how the script was called (cf-memory-index vs cf-memory-watch)
+  const scriptName = path.basename(process.argv[1]);
+  let command = args[0];
+  let projectPath = args[1] || '.';
+  
+  if (scriptName.includes('watch')) {
+    command = 'watch';
+    projectPath = args[0] || '.';
+  } else if (scriptName.includes('index')) {
+    command = 'index';
+    projectPath = args[0] || '.';
+  }
   
   const options = {
     dryRun: args.includes('--dry-run'),
@@ -388,7 +391,12 @@ Environment:
   }
 }
 
-main().catch(err => {
-  console.error('Error:', err.message);
-  process.exit(1);
-});
+// Export for programmatic use
+if (require.main === module) {
+  main().catch(err => {
+    console.error('Error:', err.message);
+    process.exit(1);
+  });
+}
+
+module.exports = { IncrementalIndexer };

package/bin/cf-memory-mcp.js

@@ -45,6 +45,7 @@ class CFMemoryMCP {
         this.legacyServerUrl = LEGACY_SERVER_URL;
         this.userAgent = `cf-memory-mcp/${PACKAGE_VERSION} (${os.platform()} ${os.arch()}; Node.js ${process.version})`;
         this.useStreamableHttp = true; // Try Streamable HTTP first
+        this.autoWatcher = null; // Background file watcher
 
         // Handle process termination gracefully
         process.on('SIGINT', () => this.shutdown('SIGINT'));
@@ -91,12 +92,46 @@ class CFMemoryMCP {
         try {
             // Skip connectivity test in MCP mode - it will be tested when first request is made
             this.logDebug('Starting MCP message processing...');
+            
+            // Start auto-watcher if CF_MEMORY_AUTO_WATCH is set
+            if (process.env.CF_MEMORY_AUTO_WATCH === '1' || process.env.CF_MEMORY_AUTO_WATCH === 'true') {
+                this.startAutoWatcher();
+            }
+            
             await this.processStdio();
         } catch (error) {
             this.logError('Failed to start MCP server:', error);
             process.exit(1);
         }
     }
+    
+    /**
+     * Start auto-watching files for changes
+     */
+    async startAutoWatcher() {
+        // Use CF_MEMORY_WATCH_PATH if set, otherwise use current working directory
+        const watchPath = process.env.CF_MEMORY_WATCH_PATH || process.cwd();
+        const projectName = process.env.CF_MEMORY_PROJECT_NAME || path.basename(watchPath);
+        
+        this.logDebug(`Starting auto-watch for: ${watchPath} (${projectName})`);
+        
+        try {
+            // Dynamically import the indexer
+            const { IncrementalIndexer } = require('./cf-memory-mcp-indexer.js');
+            this.autoWatcher = new IncrementalIndexer(watchPath, {
+                name: projectName
+            });
+            
+            // Start watching in background
+            this.autoWatcher.watch().catch(err => {
+                this.logError('Auto-watch error:', err);
+            });
+            
+            this.logDebug('Auto-watch started successfully');
+        } catch (err) {
+            this.logError('Failed to start auto-watch:', err);
+        }
+    }
 
     /**
      * Test connectivity to the Cloudflare Worker

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cf-memory-mcp",
-	"version": "3.8.3",
+	"version": "3.8.5",
 	"description": "Best-in-class MCP server with CONTEXTUAL CHUNKING (Anthropic-style, 35-67% better retrieval), Optimized LLM stack (Llama-3.1-8B), BGE-M3 embeddings, Query Expansion Caching, Hybrid Embedding Strategy, and Unified Project Intelligence",
 	"main": "bin/cf-memory-mcp.js",
 	"bin": {