maven-indexer-mcp 1.0.7 → 1.0.8

package/build/db/index.js

@@ -1,13 +1,26 @@
 import Database from 'better-sqlite3';
 import path from 'path';
+import os from 'os';
+import fs from 'fs';
 export class DB {
     static instance;
     db;
     constructor() {
         // Check environment variable for DB path (useful for testing)
-        const dbName = process.env.DB_FILE || 'maven-index.sqlite';
-        const dbPath = path.join(process.cwd(), dbName);
-        this.db = new Database(dbPath);
+        if (process.env.DB_FILE) {
+            this.db = new Database(process.env.DB_FILE);
+        }
+        else {
+            // Use home directory for the database file
+            const homeDir = os.homedir();
+            const configDir = path.join(homeDir, '.maven-indexer-mcp');
+            // Ensure the directory exists
+            if (!fs.existsSync(configDir)) {
+                fs.mkdirSync(configDir, { recursive: true });
+            }
+            const dbPath = path.join(configDir, 'maven-index.sqlite');
+            this.db = new Database(dbPath);
+        }
         this.initSchema();
     }
     static getInstance() {

package/build/indexer.js

@@ -15,6 +15,7 @@ export class Indexer {
     isIndexing = false;
     watcher = null;
     debounceTimer = null;
+    pollingTimer = null;
     constructor() {
     }
     static getInstance() {
@@ -24,55 +25,95 @@ export class Indexer {
         return Indexer.instance;
     }
     /**
-     * Starts watching the local repository for changes.
-     * Debounces changes to trigger re-indexing.
+     * Starts watching the local repository for changes - ULTRA SIMPLE VERSION
+     * Just watch the root directories without recursion
      */
     async startWatch() {
         const config = await Config.getInstance();
-        const pathsToWatch = [];
+        const watchPaths = [];
+        // Simple: Just add the main repository paths
         if (config.localRepository && fsSync.existsSync(config.localRepository)) {
-            pathsToWatch.push(config.localRepository);
+            watchPaths.push(config.localRepository);
         }
         if (config.gradleRepository && fsSync.existsSync(config.gradleRepository)) {
-            pathsToWatch.push(config.gradleRepository);
+            watchPaths.push(config.gradleRepository);
         }
-        if (pathsToWatch.length === 0) {
+        if (watchPaths.length === 0) {
             console.error("No repository paths found, skipping watch mode.");
             return;
         }
-        if (this.watcher) {
+        if (this.watcher || this.pollingTimer) {
             return;
         }
-        console.error(`Starting file watcher on ${pathsToWatch.join(', ')}...`);
-        this.watcher = chokidar.watch(pathsToWatch, {
-            ignored: (p) => {
-                // Don't ignore the root paths themselves
-                if (pathsToWatch.includes(p))
-                    return false;
-                // Ignore dotfiles/dotdirs
-                return path.basename(p).startsWith('.');
-            },
-            persistent: true,
-            ignoreInitial: true,
-            depth: 10 // Limit depth to avoid too much overhead? Standard maven repo depth is around 3-5
-        });
-        const onChange = () => {
-            if (this.debounceTimer)
-                clearTimeout(this.debounceTimer);
-            this.debounceTimer = setTimeout(() => {
-                console.error("Repository change detected. Triggering re-index...");
-                this.index().catch(console.error);
-            }, 5000); // Debounce for 5 seconds
-        };
-        this.watcher
-            .on('add', (path) => {
-            if (path.endsWith('.jar') || path.endsWith('.pom'))
-                onChange();
-        })
-            .on('unlink', (path) => {
-            if (path.endsWith('.jar') || path.endsWith('.pom'))
-                onChange();
-        });
+        console.error(`🔍 Starting ultra-simple file watcher on: ${watchPaths.join(', ')}`);
+        try {
+            // ULTRA SIMPLE: Watch only root directories, no recursion
+            this.watcher = chokidar.watch(watchPaths, {
+                // Watch only the root directory itself, not subdirectories
+                depth: 0,
+                // Don't trigger for files that already exist
+                ignoreInitial: true,
+                // Wait for files to finish writing before triggering
+                awaitWriteFinish: {
+                    stabilityThreshold: 2000,
+                    pollInterval: 100
+                },
+                // Don't crash on permission errors
+                ignorePermissionErrors: true
+            });
+            // SIMPLE: Watch for any changes in the root directories
+            // This will catch when new directories are created (which means new artifacts)
+            this.watcher
+                .on('addDir', (dirPath) => {
+                console.error(`� New directory detected: ${path.basename(dirPath)}`);
+                this.triggerReindex();
+            })
+                .on('unlinkDir', (dirPath) => {
+                console.error(`🗑️  Directory removed: ${path.basename(dirPath)}`);
+                this.triggerReindex();
+            })
+                .on('error', (error) => {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                console.error(`❌ Watcher error: ${errorMessage}`);
+                this.fallbackToPolling();
+            });
+            console.error('✅ Ultra-simple file watcher started successfully');
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`❌ Failed to start watcher: ${errorMessage}`);
+            this.fallbackToPolling();
+        }
+    }
+    /**
+     * Falls back to polling mode if watcher fails.
+     * Polls the repository every 1 min
+     */
+    fallbackToPolling() {
+        if (this.pollingTimer) {
+            return;
+        }
+        console.error('⚠️ Falling back to polling mode (every 10s)...');
+        if (this.watcher) {
+            this.watcher.close().catch(err => console.error(`Error closing watcher: ${err}`));
+            this.watcher = null;
+        }
+        this.pollingTimer = setInterval(() => {
+            this.index().catch(console.error);
+        }, 60000);
+    }
+    /**
+     * Trigger reindexing with debouncing (wait a bit for multiple changes)
+     */
+    triggerReindex() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        // Wait 3 seconds after the last change before reindexing
+        this.debounceTimer = setTimeout(() => {
+            console.error('🔄 Changes detected - triggering reindex...');
+            this.index().catch(console.error);
+        }, 3000);
     }
     /**
      * Forces a full re-index of the repository.

package/build/simple_watcher.js

@@ -0,0 +1,121 @@
+/**
+ * SIMPLIFIED FILE WATCHER for Maven Indexer
+ *
+ * This is a cleaned-up version that's easier to understand.
+ * It watches for new JAR and POM files in your Maven/Gradle repositories.
+ */
+import fs from 'fs';
+import path from 'path';
+export class SimpleWatcher {
+    watcher = null;
+    onChangeCallback;
+    constructor(onChangeCallback) {
+        this.onChangeCallback = onChangeCallback;
+    }
+    /**
+     * Start watching - SIMPLE VERSION
+     * Just watch the main folders and filter for JAR/POM files
+     */
+    async startWatching(mavenRepoPath, gradleRepoPath) {
+        if (this.watcher) {
+            console.log('Watcher already running');
+            return;
+        }
+        const watchPaths = [];
+        // Add Maven repo if it exists
+        if (mavenRepoPath && fs.existsSync(mavenRepoPath)) {
+            watchPaths.push(mavenRepoPath);
+        }
+        // Add Gradle repo if it exists  
+        if (gradleRepoPath && fs.existsSync(gradleRepoPath)) {
+            watchPaths.push(gradleRepoPath);
+        }
+        if (watchPaths.length === 0) {
+            console.log('No repository paths to watch');
+            return;
+        }
+        console.log(`🔍 Watching for new JAR/POM files in: ${watchPaths.join(', ')}`);
+        // SIMPLE: Use chokidar with basic ignore patterns
+        const chokidar = await import('chokidar');
+        this.watcher = chokidar.watch(watchPaths, {
+            // Ignore common junk files (simple patterns)
+            ignored: [
+                '**/.*', // Hidden files
+                '**/*.tmp', // Temp files
+                '**/*.sha1', // Checksum files
+                '**/*.sha256', // Checksum files
+                '**/*.md5', // Checksum files
+            ],
+            // Don't watch too deep (Maven repos are usually 3-4 levels)
+            depth: 6,
+            // Don't trigger for files that already exist
+            ignoreInitial: true,
+            // Wait for files to finish writing before triggering
+            awaitWriteFinish: {
+                stabilityThreshold: 2000, // Wait 2 seconds after file stops changing
+                pollInterval: 100
+            }
+        });
+        // SIMPLE: Just watch for new files being added
+        this.watcher
+            .on('add', (filePath) => {
+            // Only care about JAR and POM files
+            if (filePath.endsWith('.jar') || filePath.endsWith('.pom')) {
+                console.log(`📦 New file detected: ${path.basename(filePath)}`);
+                this.triggerReindex();
+            }
+        })
+            .on('unlink', (filePath) => {
+            // Also watch for files being deleted
+            if (filePath.endsWith('.jar') || filePath.endsWith('.pom')) {
+                console.log(`🗑️  File removed: ${path.basename(filePath)}`);
+                this.triggerReindex();
+            }
+        })
+            .on('error', (error) => {
+            console.log(`❌ Watcher error: ${error.message}`);
+        });
+        console.log('✅ File watcher started successfully');
+    }
+    /**
+     * Stop watching
+     */
+    stopWatching() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+            console.log('🛑 File watcher stopped');
+        }
+    }
+    /**
+     * Trigger reindexing with debouncing (wait a bit for multiple changes)
+     */
+    debounceTimer = null;
+    triggerReindex() {
+        // Clear any existing timer
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        // Wait 3 seconds after the last change before reindexing
+        this.debounceTimer = setTimeout(() => {
+            console.log('🔄 Changes detected - triggering reindex...');
+            this.onChangeCallback();
+        }, 3000);
+    }
+}
+/**
+ * USAGE EXAMPLE:
+ *
+ * const watcher = new SimpleWatcher(() => {
+ *     console.log('Time to reindex the repository!');
+ *     // Put your reindexing code here
+ * });
+ *
+ * await watcher.startWatching(
+ *     '/Users/tangcent/.m2/repository',
+ *     '/Users/tangcent/.gradle/caches/modules-2/files-2.1'
+ * );
+ *
+ * // Later... when you want to stop
+ * watcher.stopWatching();
+ **/ 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maven-indexer-mcp",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "MCP server for indexing local Maven repository",
   "main": "build/index.js",
   "type": "module",