maven-indexer-mcp 1.0.7 → 1.0.9

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/index.js

@@ -20,6 +20,7 @@ const indexer = Indexer.getInstance();
 // We trigger indexing but don't await it so server can start
 indexer.index().then(() => {
     // Start watching for changes after initial index
+    indexer.startSchedule();
     return indexer.startWatch();
 }).catch(err => console.error("Initial indexing failed:", err));
 server.registerTool("get_class_details", {
@@ -154,9 +155,9 @@ server.registerTool("get_class_details", {
     return { content: [{ type: "text", text: results.join("\n\n") }] };
 });
 server.registerTool("search_artifacts", {
-    description: "Search for internal company artifacts and libraries in the local Maven repository and Gradle caches by coordinate (groupId, artifactId) or keyword. Use this primarily for internal company packages or to find available versions of internal projects that are locally built. Also supports searching third-party libraries in the local cache. Supports batch queries.",
+    description: "Search for internal company artifacts and libraries in the local Maven repository and Gradle caches by coordinate (groupId, artifactId), keyword, or class name. Use this primarily for internal company packages or to find available versions of internal projects that are locally built. Also supports searching third-party libraries in the local cache. Supports batch queries.",
     inputSchema: z.object({
-        query: z.string().optional().describe("Search query (groupId, artifactId, or keyword)"),
+        query: z.string().optional().describe("Search query (groupId, artifactId, keyword, or class name)"),
         queries: z.array(z.string()).optional().describe("Batch search queries"),
     }),
 }, async ({ query, queries }) => {
@@ -169,13 +170,34 @@ server.registerTool("search_artifacts", {
         return { content: [{ type: "text", text: "No query provided." }] };
     }
     const results = allQueries.map(q => {
-        const matches = indexer.search(q);
+        let allMatches = [];
+        let searchType = "artifact";
+        // First try class search (for both simple and fully qualified class names)
+        const classSearchResults = indexer.searchClass(q);
+        if (classSearchResults.length > 0) {
+            // Extract unique artifacts from class search results
+            const artifactMap = new Map();
+            classSearchResults.forEach(result => {
+                result.artifacts.forEach(artifact => {
+                    const key = `${artifact.groupId}:${artifact.artifactId}:${artifact.version}`;
+                    if (!artifactMap.has(key)) {
+                        artifactMap.set(key, artifact);
+                    }
+                });
+            });
+            allMatches = Array.from(artifactMap.values());
+            searchType = "class";
+        }
+        else {
+            // Fallback to artifact search if class search finds nothing
+            allMatches = indexer.search(q);
+        }
         // Limit results to avoid overflow
-        const limitedMatches = matches.slice(0, 20);
+        const limitedMatches = allMatches.slice(0, 20);
         const text = limitedMatches.length > 0
             ? limitedMatches.map(a => `${a.groupId}:${a.artifactId}:${a.version} (Has Source: ${a.hasSource})`).join("\n")
             : "No artifacts found matching the query.";
-        return `### Results for "${q}" (Found ${matches.length}${matches.length > 20 ? ', showing first 20' : ''}):\n${text}`;
+        return `### Results for "${q}" (Found ${allMatches.length} via ${searchType} search${allMatches.length > 20 ? ', showing first 20' : ''}):\n${text}`;
     });
     return {
         content: [

package/build/indexer.js

@@ -15,6 +15,7 @@ export class Indexer {
     isIndexing = false;
     watcher = null;
     debounceTimer = null;
+    scheduleTimer = null;
     constructor() {
     }
     static getInstance() {
@@ -25,54 +26,101 @@ export class Indexer {
     }
     /**
      * Starts watching the local repository for changes.
-     * Debounces changes to trigger re-indexing.
      */
     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) {
             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 file watcher on: ${watchPaths.join(', ')}`);
+        try {
+            // Watch for .jar and .pom files changes deep in the repository
+            this.watcher = chokidar.watch(watchPaths, {
+                // Watch for jar and pom files
+                ignored: [
+                    /(^|[\/\\])\../, // ignore dotfiles
+                    /node_modules/,
+                    /target/,
+                    /build/,
+                ],
+                persistent: true,
+                ignoreInitial: true,
+                awaitWriteFinish: {
+                    stabilityThreshold: 2000,
+                    pollInterval: 100
+                },
+                ignorePermissionErrors: true
+            });
+            // Watch for file additions and changes
+            this.watcher
+                .on('add', (filePath) => {
+                if (filePath.endsWith('.jar') || filePath.endsWith('.pom')) {
+                    console.error(`📄 New file detected: ${path.basename(filePath)}`);
+                    this.triggerReindex();
+                }
+            })
+                .on('addDir', (dirPath) => {
+                console.error(`📁 New directory detected: ${path.basename(dirPath)}`);
+                this.triggerReindex();
+            })
+                .on('unlink', (filePath) => {
+                if (filePath.endsWith('.jar') || filePath.endsWith('.pom')) {
+                    console.error(`🗑️ File removed: ${path.basename(filePath)}`);
+                    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}`);
+            });
+            console.error('✅ File watcher started successfully');
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`❌ Failed to start watcher: ${errorMessage}`);
+        }
+    }
+    /**
+     * Starts a scheduled job to reindex every 1 hour.
+     */
+    startSchedule() {
+        if (this.scheduleTimer) {
+            return;
+        }
+        console.error('⏰ Starting scheduled reindex job (every 1 hour)...');
+        this.scheduleTimer = setInterval(() => {
+            console.error('⏰ Scheduled reindex triggered...');
+            this.index().catch(console.error);
+        }, 3600000); // 1 hour
+    }
+    /**
+     * 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.9",
   "description": "MCP server for indexing local Maven repository",
   "main": "build/index.js",
   "type": "module",