maven-indexer-mcp 1.0.0 → 1.0.2

package/README.md

@@ -33,6 +33,7 @@ If the auto-detection fails, or if you want to filter which packages are indexed
 
 *   **`MAVEN_REPO`**: Absolute path to your local Maven repository (e.g., `/Users/yourname/.m2/repository`). Use this if your repository is in a non-standard location.
 *   **`INCLUDED_PACKAGES`**: Comma-separated list of package patterns to index (e.g., `com.mycompany.*,org.example.*`). Default is `*` (index everything).
+*   **`MAVEN_INDEXER_CFR_PATH`**: (Optional) Absolute path to a specific CFR decompiler JAR. If not provided, the server will attempt to use its bundled CFR version.
 
 Example with optional configuration:
 
@@ -44,7 +45,8 @@ Example with optional configuration:
       "args": ["-y", "maven-indexer-mcp@latest"],
       "env": {
         "MAVEN_REPO": "/Users/yourname/.m2/repository",
-        "INCLUDED_PACKAGES": "com.mycompany.*"
+        "INCLUDED_PACKAGES": "com.mycompany.*",
+        "MAVEN_INDEXER_CFR_PATH": "/path/to/cfr-0.152.jar"
       }
     }
   }

package/build/config.js

@@ -7,6 +7,7 @@ export class Config {
     localRepository = "";
     javaBinary = "java";
     includedPackages = ["*"];
+    cfrPath = null;
     constructor() { }
     static async getInstance() {
         if (!Config.instance) {
@@ -62,10 +63,24 @@ export class Config {
                 .map(p => p.trim())
                 .filter(p => p.length > 0);
         }
+        // Load CFR Path
+        if (process.env.MAVEN_INDEXER_CFR_PATH) {
+            this.cfrPath = process.env.MAVEN_INDEXER_CFR_PATH;
+        }
+        else {
+            // Fallback to default bundled lib
+            this.cfrPath = path.resolve(process.cwd(), 'lib/cfr-0.152.jar');
+        }
         // Log to stderr so it doesn't interfere with MCP protocol on stdout
         console.error(`Using local repository: ${this.localRepository}`);
         console.error(`Using Java binary: ${this.javaBinary}`);
         console.error(`Included packages: ${JSON.stringify(this.includedPackages)}`);
+        if (this.cfrPath) {
+            console.error(`Using CFR jar: ${this.cfrPath}`);
+        }
+    }
+    getCfrJarPath() {
+        return this.cfrPath;
     }
     getJavapPath() {
         if (this.javaBinary === 'java')

package/build/db/index.js

@@ -25,6 +25,7 @@ export class DB {
         version TEXT NOT NULL,
         abspath TEXT NOT NULL,
         has_source INTEGER DEFAULT 0,
+        is_indexed INTEGER DEFAULT 0,
         UNIQUE(group_id, artifact_id, version)
       );
 
@@ -35,11 +36,15 @@ export class DB {
         tokenize="trigram" 
       );
       
-      -- Helper table to track indexed artifacts to avoid re-indexing unchanged ones (simplification: just track ID)
-      CREATE TABLE IF NOT EXISTS indexed_artifacts (
-          artifact_id INTEGER PRIMARY KEY
-      );
+      -- Cleanup old table if exists
+      DROP TABLE IF EXISTS indexed_artifacts;
     `);
+        try {
+            this.db.exec('ALTER TABLE artifacts ADD COLUMN is_indexed INTEGER DEFAULT 0');
+        }
+        catch (e) {
+            // Column likely already exists
+        }
     }
     getDb() {
         return this.db;

package/build/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import path from 'path';
+import { z } from "zod";
 import { Indexer } from "./indexer.js";
 import { SourceParser } from "./source_parser.js";
-const server = new Server({
+const server = new McpServer({
     name: "maven-indexer",
     version: "1.0.0",
 }, {
@@ -20,155 +20,124 @@ indexer.index().then(() => {
     // Start watching for changes after initial index
     return indexer.startWatch();
 }).catch(err => console.error("Initial indexing failed:", err));
-server.setRequestHandler(ListToolsRequestSchema, async () => {
+server.registerTool("search_artifacts", {
+    description: "Search for artifacts in the local Maven repository",
+    inputSchema: z.object({
+        query: z.string().describe("Search query (groupId, artifactId, or keyword)"),
+    }),
+}, async ({ query }) => {
+    const matches = indexer.search(query);
+    // Limit results to avoid overflow
+    const limitedMatches = matches.slice(0, 20);
+    const text = limitedMatches.length > 0
+        ? limitedMatches.map(a => `[ID: ${a.id}] ${a.groupId}:${a.artifactId}:${a.version} (Has Source: ${a.hasSource})`).join("\n")
+        : "No artifacts found matching the query.";
     return {
-        tools: [
+        content: [
             {
-                name: "search_artifacts",
-                description: "Search for artifacts in the local Maven repository",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        query: {
-                            type: "string",
-                            description: "Search query (groupId, artifactId, or keyword)",
-                        },
-                    },
-                    required: ["query"],
-                },
+                type: "text",
+                text: `Found ${matches.length} matches${matches.length > 20 ? ' (showing first 20)' : ''}:\n${text}`,
             },
-            {
-                name: "search_classes",
-                description: "Search for Java classes. Can be used to find classes by name or to find classes for a specific purpose (by searching keywords in class names).",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        className: {
-                            type: "string",
-                            description: "Fully qualified class name, partial name, or keywords describing the class purpose (e.g. 'JsonToXml').",
-                        },
-                    },
-                    required: ["className"],
-                },
-            },
-            {
-                name: "get_class_details",
-                description: "Get details about a specific class from an artifact, including method signatures and javadocs (if source is available).",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        className: {
-                            type: "string",
-                            description: "Fully qualified class name",
-                        },
-                        artifactId: {
-                            type: "number",
-                            description: "The internal ID of the artifact (returned by search_classes)",
-                        },
-                        type: {
-                            type: "string",
-                            enum: ["signatures", "docs", "source"],
-                            description: "Type of detail to retrieve: 'signatures' (methods), 'docs' (javadocs + methods), 'source' (full source code).",
-                        }
-                    },
-                    required: ["className", "artifactId", "type"],
-                },
-            },
-            {
-                name: "refresh_index",
-                description: "Trigger a re-scan of the Maven repository",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
-                },
-            }
         ],
     };
 });
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    if (request.params.name === "search_artifacts") {
-        const query = String(request.params.arguments?.query);
-        const matches = indexer.search(query);
-        // Limit results to avoid overflow
-        const limitedMatches = matches.slice(0, 20);
-        const text = limitedMatches.length > 0
-            ? limitedMatches.map(a => `[ID: ${a.id}] ${a.groupId}:${a.artifactId}:${a.version} (Has Source: ${a.hasSource})`).join("\n")
-            : "No artifacts found matching the query.";
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Found ${matches.length} matches${matches.length > 20 ? ' (showing first 20)' : ''}:\n${text}`,
-                },
-            ],
-        };
+server.registerTool("search_classes", {
+    description: "Search for Java classes. Can be used to find classes by name or to find classes for a specific purpose (by searching keywords in class names).",
+    inputSchema: z.object({
+        className: z.string().describe("Fully qualified class name, partial name, or keywords describing the class purpose (e.g. 'JsonToXml')."),
+    }),
+}, async ({ className }) => {
+    const matches = indexer.searchClass(className);
+    const text = matches.length > 0
+        ? matches.map(m => {
+            // Group by artifact ID to allow easy selection
+            const artifacts = m.artifacts.slice(0, 5).map(a => `[ID: ${a.id}] ${a.groupId}:${a.artifactId}:${a.version}${a.hasSource ? ' (Has Source)' : ''}`).join("\n    ");
+            const more = m.artifacts.length > 5 ? `\n    ... (${m.artifacts.length - 5} more versions)` : '';
+            return `Class: ${m.className}\n    ${artifacts}${more}`;
+        }).join("\n\n")
+        : "No classes found matching the query. Try different keywords.";
+    return {
+        content: [{ type: "text", text }]
+    };
+});
+server.registerTool("get_class_details", {
+    description: "Get details about a specific class from an artifact, including method signatures and javadocs (if source is available).",
+    inputSchema: z.object({
+        className: z.string().describe("Fully qualified class name"),
+        artifactId: z.number().describe("The internal ID of the artifact (returned by search_classes)"),
+        type: z.enum(["signatures", "docs", "source"]).describe("Type of detail to retrieve: 'signatures' (methods), 'docs' (javadocs + methods), 'source' (full source code)."),
+    }),
+}, async ({ className, artifactId, type }) => {
+    const artifact = indexer.getArtifactById(artifactId);
+    if (!artifact) {
+        return { content: [{ type: "text", text: "Artifact not found." }] };
     }
-    if (request.params.name === "search_classes") {
-        const className = String(request.params.arguments?.className);
-        const matches = indexer.searchClass(className);
-        const text = matches.length > 0
-            ? matches.map(m => {
-                // Group by artifact ID to allow easy selection
-                const artifacts = m.artifacts.slice(0, 5).map(a => `[ID: ${a.id}] ${a.groupId}:${a.artifactId}:${a.version}${a.hasSource ? ' (Has Source)' : ''}`).join("\n    ");
-                const more = m.artifacts.length > 5 ? `\n    ... (${m.artifacts.length - 5} more versions)` : '';
-                return `Class: ${m.className}\n    ${artifacts}${more}`;
-            }).join("\n\n")
-            : "No classes found matching the query. Try different keywords.";
-        return {
-            content: [{ type: "text", text }]
-        };
+    let detail = null;
+    let usedDecompilation = false;
+    // 1. If requesting source/docs, try Source JAR first
+    if (type === 'source' || type === 'docs') {
+        if (artifact.hasSource) {
+            const sourceJarPath = path.join(artifact.abspath, `${artifact.artifactId}-${artifact.version}-sources.jar`);
+            try {
+                detail = await SourceParser.getClassDetail(sourceJarPath, className, type);
+            }
+            catch (e) {
+                // Ignore error and fallthrough to main jar (decompilation)
+            }
+        }
+        // If not found in source jar (or no source jar), try main jar (decompilation)
+        if (!detail) {
+            const mainJarPath = path.join(artifact.abspath, `${artifact.artifactId}-${artifact.version}.jar`);
+            try {
+                // SourceParser will try to decompile if source file not found in jar
+                detail = await SourceParser.getClassDetail(mainJarPath, className, type);
+                if (detail && detail.source) {
+                    usedDecompilation = true;
+                }
+            }
+            catch (e) {
+                // Ignore
+            }
+        }
     }
-    if (request.params.name === "get_class_details") {
-        const className = String(request.params.arguments?.className);
-        const artifactId = Number(request.params.arguments?.artifactId);
-        const type = String(request.params.arguments?.type);
-        const artifact = indexer.getArtifactById(artifactId);
-        if (!artifact) {
-            return { content: [{ type: "text", text: "Artifact not found." }] };
+    else {
+        // Signatures -> Use Main JAR
+        const mainJarPath = path.join(artifact.abspath, `${artifact.artifactId}-${artifact.version}.jar`);
+        detail = await SourceParser.getClassDetail(mainJarPath, className, type);
+    }
+    try {
+        if (!detail) {
+            return { content: [{ type: "text", text: `Class ${className} not found in artifact ${artifact.artifactId}.` }] };
         }
-        let jarPath;
-        if (type === 'signatures') {
-            // Use Main JAR for signatures (javap)
-            jarPath = path.join(artifact.abspath, `${artifact.artifactId}-${artifact.version}.jar`);
+        let resultText = `Class: ${detail.className}\n\n`;
+        if (usedDecompilation) {
+            resultText += "*Source code decompiled from binary class file.*\n\n";
         }
-        else {
-            // Use Source JAR for docs and full source
-            if (!artifact.hasSource) {
-                return { content: [{ type: "text", text: `Artifact ${artifact.groupId}:${artifact.artifactId}:${artifact.version} does not have a sources jar available locally.` }] };
-            }
-            jarPath = path.join(artifact.abspath, `${artifact.artifactId}-${artifact.version}-sources.jar`);
+        if (type === 'source') {
+            resultText += "```java\n" + detail.source + "\n```";
         }
-        try {
-            const detail = await SourceParser.getClassDetail(jarPath, className, type);
-            if (!detail) {
-                return { content: [{ type: "text", text: `Class ${className} not found in ${type === 'signatures' ? 'artifact' : 'sources'} of ${artifact.artifactId}.` }] };
+        else {
+            if (detail.doc) {
+                resultText += "Documentation:\n" + detail.doc + "\n\n";
             }
-            let resultText = `Class: ${detail.className}\n\n`;
-            if (type === 'source') {
-                resultText += "```java\n" + detail.source + "\n```";
+            if (detail.signatures) {
+                resultText += "Methods:\n" + detail.signatures.join("\n") + "\n";
             }
-            else {
-                if (detail.doc) {
-                    resultText += "Documentation:\n" + detail.doc + "\n\n";
-                }
-                if (detail.signatures) {
-                    resultText += "Methods:\n" + detail.signatures.join("\n") + "\n";
-                }
-            }
-            return { content: [{ type: "text", text: resultText }] };
-        }
-        catch (e) {
-            return { content: [{ type: "text", text: `Error reading source: ${e.message}` }] };
         }
+        return { content: [{ type: "text", text: resultText }] };
     }
-    if (request.params.name === "refresh_index") {
-        // Re-run index
-        indexer.index().catch(console.error);
-        return {
-            content: [{ type: "text", text: "Index refresh started." }]
-        };
+    catch (e) {
+        return { content: [{ type: "text", text: `Error reading source: ${e.message}` }] };
     }
-    throw new Error("Tool not found");
+});
+server.registerTool("refresh_index", {
+    description: "Trigger a re-scan of the Maven repository",
+}, async () => {
+    // Re-run index
+    indexer.index().catch(console.error);
+    return {
+        content: [{ type: "text", text: "Index refresh started." }]
+    };
 });
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/build/indexer.js

@@ -5,6 +5,10 @@ import yauzl from 'yauzl';
 import chokidar from 'chokidar';
 import { Config } from './config.js';
 import { DB } from './db/index.js';
+/**
+ * Singleton class responsible for indexing Maven artifacts.
+ * It scans the local repository, watches for changes, and indexes Java classes.
+ */
 export class Indexer {
     static instance;
     isIndexing = false;
@@ -17,6 +21,10 @@ export class Indexer {
         }
         return Indexer.instance;
     }
+    /**
+     * Starts watching the local repository for changes.
+     * Debounces changes to trigger re-indexing.
+     */
     async startWatch() {
         const config = await Config.getInstance();
         const repoPath = config.localRepository;
@@ -52,6 +60,12 @@ export class Indexer {
                 onChange();
         });
     }
+    /**
+     * Main indexing process.
+     * 1. Scans the file system for Maven artifacts.
+     * 2. Synchronizes the database with found artifacts.
+     * 3. Indexes classes for artifacts that haven't been indexed yet.
+     */
     async index() {
         if (this.isIndexing)
             return;
@@ -71,40 +85,28 @@ export class Indexer {
             const artifacts = await this.scanRepository(repoPath);
             console.error(`Found ${artifacts.length} artifacts on disk.`);
             // 2. Persist artifacts and determine what needs indexing
-            const artifactsToIndex = [];
+            // We use is_indexed = 0 for new artifacts.
+            const insertArtifact = db.prepare(`
+            INSERT OR IGNORE INTO artifacts (group_id, artifact_id, version, abspath, has_source, is_indexed)
+            VALUES (@groupId, @artifactId, @version, @abspath, @hasSource, 0)
+        `);
+            // Use a transaction only for the batch insert of artifacts
             db.transaction(() => {
-                const insertArtifact = db.prepare(`
-                INSERT OR IGNORE INTO artifacts (group_id, artifact_id, version, abspath, has_source)
-                VALUES (@groupId, @artifactId, @version, @abspath, @hasSource)
-            `);
-                const selectId = db.prepare(`
-                SELECT id FROM artifacts 
-                WHERE group_id = @groupId AND artifact_id = @artifactId AND version = @version
-            `);
-                const checkIndexed = db.prepare(`
-                SELECT 1 FROM indexed_artifacts WHERE artifact_id = ?
-            `);
                 for (const art of artifacts) {
                     insertArtifact.run({
                         ...art,
                         hasSource: art.hasSource ? 1 : 0
                     });
-                    const row = selectId.get({
-                        groupId: art.groupId,
-                        artifactId: art.artifactId,
-                        version: art.version
-                    });
-                    if (row) {
-                        art.id = row.id;
-                        const isIndexed = checkIndexed.get(art.id);
-                        if (!isIndexed) {
-                            artifactsToIndex.push(art);
-                        }
-                    }
                 }
             });
+            // 3. Find artifacts that need indexing (is_indexed = 0)
+            const artifactsToIndex = db.prepare(`
+            SELECT id, group_id as groupId, artifact_id as artifactId, version, abspath, has_source as hasSource
+            FROM artifacts 
+            WHERE is_indexed = 0
+        `).all();
             console.error(`${artifactsToIndex.length} artifacts need indexing.`);
-            // 3. Scan JARs for classes and update DB
+            // 4. Scan JARs for classes and update DB
             const CHUNK_SIZE = 50;
             let processedCount = 0;
             for (let i = 0; i < artifactsToIndex.length; i += CHUNK_SIZE) {
@@ -124,6 +126,9 @@ export class Indexer {
             this.isIndexing = false;
         }
     }
+    /**
+     * Recursively scans a directory for Maven artifacts (POM files).
+     */
     async scanRepository(rootDir) {
         const results = [];
         const scanDir = async (dir) => {
@@ -168,6 +173,10 @@ export class Indexer {
         await scanDir(rootDir);
         return results;
     }
+    /**
+     * Extracts classes from the artifact's JAR and indexes them.
+     * Updates the 'is_indexed' flag upon completion.
+     */
     async indexArtifactClasses(artifact) {
         const jarPath = path.join(artifact.abspath, `${artifact.artifactId}-${artifact.version}.jar`);
         const db = DB.getInstance();
@@ -178,12 +187,13 @@ export class Indexer {
         catch {
             // If jar missing, mark as indexed so we don't retry endlessly? 
             // Or maybe it's a pom-only artifact.
-            db.prepare('INSERT OR IGNORE INTO indexed_artifacts (artifact_id) VALUES (?)').run(artifact.id);
+            db.prepare('UPDATE artifacts SET is_indexed = 1 WHERE id = ?').run(artifact.id);
             return;
         }
         return new Promise((resolve) => {
             yauzl.open(jarPath, { lazyEntries: true, autoClose: true }, (err, zipfile) => {
                 if (err || !zipfile) {
+                    // If we can't open it, maybe it's corrupt. Skip for now.
                     resolve();
                     return;
                 }
@@ -215,7 +225,8 @@ export class Indexer {
                                 const simpleName = cls.split('.').pop() || cls;
                                 insertClass.run(artifact.id, cls, simpleName);
                             }
-                            db.prepare('INSERT OR IGNORE INTO indexed_artifacts (artifact_id) VALUES (?)').run(artifact.id);
+                            // Mark as indexed
+                            db.prepare('UPDATE artifacts SET is_indexed = 1 WHERE id = ?').run(artifact.id);
                         });
                     }
                     catch (e) {
@@ -229,6 +240,9 @@ export class Indexer {
             });
         });
     }
+    /**
+     * Checks if a class package is included in the configuration patterns.
+     */
     isPackageIncluded(className, patterns) {
         if (patterns.length === 0 || (patterns.length === 1 && patterns[0] === '*'))
             return true;
@@ -249,6 +263,9 @@ export class Indexer {
         }
         return false;
     }
+    /**
+     * Searches for artifacts by group ID or artifact ID.
+     */
     search(query) {
         // Artifact coordinates search
         const db = DB.getInstance();
@@ -260,12 +277,20 @@ export class Indexer {
       `).all(`%${query}%`, `%${query}%`);
         return rows;
     }
+    /**
+     * Searches for classes matching the pattern.
+     * Uses Full-Text Search (FTS) for efficient matching.
+     */
     searchClass(classNamePattern) {
         const db = DB.getInstance();
         // Use FTS for smart matching
         // If pattern has no spaces, we assume it's a prefix or exact match query
         // "String" -> match "String" in simple_name or class_name
-        const query = `"${classNamePattern}"* OR ${classNamePattern}`;
+        const escapedPattern = classNamePattern.replace(/"/g, '""');
+        const safeQuery = classNamePattern.replace(/[^a-zA-Z0-9]/g, ' ').trim();
+        const query = safeQuery.length > 0
+            ? `"${escapedPattern}"* OR ${safeQuery}`
+            : `"${escapedPattern}"*`;
         try {
             const rows = db.prepare(`
               SELECT c.class_name, c.simple_name, a.id, a.group_id, a.artifact_id, a.version, a.abspath, a.has_source
@@ -301,6 +326,9 @@ export class Indexer {
             return [];
         }
     }
+    /**
+     * Retrieves an artifact by its database ID.
+     */
     getArtifactById(id) {
         const db = DB.getInstance();
         const row = db.prepare(`

package/build/source_parser.js

@@ -1,3 +1,5 @@
+import fs from 'fs';
+import path from 'path';
 import yauzl from 'yauzl';
 import { exec } from 'child_process';
 import { promisify } from 'util';
@@ -10,8 +12,12 @@ export class SourceParser {
         }
         // className: com.example.MyClass
         // internalPath: com/example/MyClass.java
-        const internalPath = className.replace(/\./g, '/') + '.java';
-        return new Promise((resolve, reject) => {
+        const basePath = className.replace(/\./g, '/');
+        const candidates = [
+            basePath + '.java',
+            basePath + '.kt'
+        ];
+        const result = await new Promise((resolve, reject) => {
             yauzl.open(jarPath, { lazyEntries: true, autoClose: true }, (err, zipfile) => {
                 if (err || !zipfile) {
                     resolve(null);
@@ -20,7 +26,7 @@ export class SourceParser {
                 let found = false;
                 zipfile.readEntry();
                 zipfile.on('entry', (entry) => {
-                    if (entry.fileName === internalPath) {
+                    if (candidates.includes(entry.fileName)) {
                         found = true;
                         zipfile.openReadStream(entry, (err, readStream) => {
                             if (err || !readStream) {
@@ -45,6 +51,38 @@ export class SourceParser {
                 });
             });
         });
+        if (result) {
+            return result;
+        }
+        // Fallback to decompilation if source not found in this JAR
+        // Note: This works best if the provided jarPath is the MAIN jar.
+        // If it is the sources jar, decompilation will fail (as it doesn't contain .class files),
+        // returning null.
+        if (type === 'source' || type === 'docs') {
+            return this.decompileClass(jarPath, className);
+        }
+        return null;
+    }
+    static async decompileClass(jarPath, className) {
+        try {
+            const config = await Config.getInstance();
+            const cfrPath = config.getCfrJarPath();
+            if (!cfrPath || !fs.existsSync(cfrPath)) {
+                // If we can't find CFR, we can't decompile.
+                return null;
+            }
+            // Use java -cp cfr.jar:target.jar org.benf.cfr.reader.Main className
+            const classpath = `${cfrPath}${path.delimiter}${jarPath}`;
+            const { stdout } = await execAsync(`java -cp "${classpath}" org.benf.cfr.reader.Main "${className}"`);
+            return {
+                className,
+                source: stdout // Return as source
+            };
+        }
+        catch (e) {
+            // console.error(`CFR failed for ${className} in ${jarPath}:`, e);
+            return null;
+        }
     }
     static async getSignaturesWithJavap(jarPath, className) {
         try {

package/package.json

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