maven-indexer-mcp 1.0.4 → 1.0.5

package/README.md

@@ -1,6 +1,6 @@
 # Maven Indexer MCP Server
 
-A Model Context Protocol (MCP) server that indexes your local Maven repository (`~/.m2/repository`) and provides AI agents with tools to search for Java classes, method signatures, and source code.
+A Model Context Protocol (MCP) server that indexes your local Maven repository (`~/.m2/repository`) and Gradle cache (`~/.gradle/caches/modules-2/files-2.1`) to provide AI agents with tools to search for Java classes, method signatures, and source code.
 
 ## Features
 
@@ -8,7 +8,7 @@ A Model Context Protocol (MCP) server that indexes your local Maven repository (
 *   **Inheritance Search**: Find all implementations of an interface or subclasses of a class.
 *   **On-Demand Analysis**: Extracts method signatures (`javap`) and Javadocs directly from JARs without extracting the entire archive.
 *   **Source Code Retrieval**: Provides full source code if `-sources.jar` is available.
-*   **Real-time Monitoring**: Watches the Maven repository for changes (e.g., new `mvn install`) and automatically updates the index.
+*   **Real-time Monitoring**: Watches the repositories for changes (e.g., new `mvn install`) and automatically updates the index.
 *   **Efficient Persistence**: Uses SQLite to store the index, handling large repositories with minimal memory footprint.
 
 ## Getting Started
@@ -26,13 +26,14 @@ Add the following config to your MCP client:
 }
 ```
 
-This will automatically download and run the latest version of the server. It will auto-detect your Maven repository location (usually `~/.m2/repository`).
+This will automatically download and run the latest version of the server. It will auto-detect your Maven repository location (usually `~/.m2/repository`) and Gradle cache.
 
 ### Configuration (Optional)
 
 If the auto-detection fails, or if you want to filter which packages are indexed, you can add environment variables to the configuration:
 
 *   **`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.
+*   **`GRADLE_REPO_PATH`**: Absolute path to your Gradle cache (e.g., `/Users/yourname/.gradle/caches/modules-2/files-2.1`).
 *   **`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.
 
@@ -46,6 +47,7 @@ Example with optional configuration:
       "args": ["-y", "maven-indexer-mcp@latest"],
       "env": {
         "MAVEN_REPO": "/Users/yourname/.m2/repository",
+        "GRADLE_REPO_PATH": "/Users/yourname/.gradle/caches/modules-2/files-2.1",
         "INCLUDED_PACKAGES": "com.mycompany.*",
         "MAVEN_INDEXER_CFR_PATH": "/path/to/cfr-0.152.jar"
       }
@@ -84,14 +86,22 @@ If you prefer to run from source:
 
 ## Available Tools
 
-*   **`search_classes`**: Search for Java classes.
+*   **`search_classes`**: Search for Java classes in the local Maven repository (dependencies).
+    *   **WHEN TO USE**:
+        1.  You cannot find a class definition in the current project source (it's likely a dependency).
+        2.  You need to read the source code, method signatures, or Javadocs of an external library class.
+        3.  You need to verify which version of a library class is being used.
+    *   **Examples**: "Show me the source of StringUtils", "What methods are available on DateTimeUtils?", "Where is this class imported from?".
     *   Input: `className` (e.g., "StringUtils", "Json parser")
     *   Output: List of matching classes with their artifacts.
-*   **`get_class_details`**: Get detailed information about a class.
-    *   Input: `className`, `artifactId`, `type` ("signatures", "docs", "source")
+*   **`get_class_details`**: Decompile and read the source code of external libraries/dependencies. **Use this instead of 'SearchCodebase' for classes that are imported but defined in JAR files.**
+    *   **Key Value**: "Don't guess what the library does—read the code."
+    *   **Tip**: When reviewing usages of an external class, use this to retrieve the class definition to understand the context fully.
+    *   Input: `className` (required), `artifactId` (optional), `type` ("signatures", "docs", "source")
     *   Output: Method signatures, Javadocs, or full source code.
+    *   **Note**: If `artifactId` is omitted, the tool automatically selects the best available artifact (preferring those with source code attached).
 *   **`search_artifacts`**: Search for artifacts by coordinate (groupId, artifactId).
-*   **`search_implementations`**: Search for classes that implement a specific interface or extend a specific class.
+*   **`search_implementations`**: Search for classes that implement a specific interface or extend a specific class. Useful for finding SPI implementations in external libraries.
     *   Input: `className` (e.g. "java.util.List")
     *   Output: List of implementation/subclass names and their artifacts.
 *   **`refresh_index`**: Trigger a re-scan of the Maven repository.

package/build/config.js

@@ -8,6 +8,7 @@ import { fileURLToPath } from 'url';
 export class Config {
     static instance;
     localRepository = "";
+    gradleRepository = "";
     javaBinary = "java";
     includedPackages = ["*"];
     cfrPath = null;
@@ -52,6 +53,18 @@ export class Config {
             repoPath = path.join(os.homedir(), '.m2', 'repository');
         }
         this.localRepository = repoPath;
+        // Load Gradle Repository
+        let gradleRepoPath = null;
+        if (process.env.GRADLE_REPO_PATH) {
+            gradleRepoPath = process.env.GRADLE_REPO_PATH;
+        }
+        else if (process.env.GRADLE_USER_HOME) {
+            gradleRepoPath = path.join(process.env.GRADLE_USER_HOME, 'caches', 'modules-2', 'files-2.1');
+        }
+        else {
+            gradleRepoPath = path.join(os.homedir(), '.gradle', 'caches', 'modules-2', 'files-2.1');
+        }
+        this.gradleRepository = gradleRepoPath;
         // Load Java Path
         if (process.env.JAVA_HOME) {
             this.javaBinary = path.join(process.env.JAVA_HOME, 'bin', 'java');

package/build/index.js

@@ -30,7 +30,7 @@ server.registerTool("search_artifacts", {
     // 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")
+        ? limitedMatches.map(a => `${a.groupId}:${a.artifactId}:${a.version} (Has Source: ${a.hasSource})`).join("\n")
         : "No artifacts found matching the query.";
     return {
         content: [
@@ -42,7 +42,7 @@ server.registerTool("search_artifacts", {
     };
 });
 server.registerTool("search_classes", {
-    description: "Search for Java classes in the local Maven repository. Use this to find classes from external dependencies/libraries when their source code is not available in the current workspace. You can search by class name (e.g. 'StringUtils') or keywords (e.g. 'Json').",
+    description: "Search for Java classes in the local Maven repository. WHEN TO USE: 1. You cannot find a class definition in the current project source (it's likely a dependency). 2. You need to read the source code, method signatures, or Javadocs of an external library class. 3. You need to verify which version of a library class is being used. Examples: 'Show me the source of StringUtils', 'What methods are available on DateTimeUtils?', 'Where is this class imported from?'.",
     inputSchema: z.object({
         className: z.string().describe("Fully qualified class name, partial name, or keywords describing the class purpose (e.g. 'JsonToXml')."),
     }),
@@ -51,7 +51,7 @@ server.registerTool("search_classes", {
     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 artifacts = m.artifacts.slice(0, 5).map(a => `${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")
@@ -61,7 +61,7 @@ server.registerTool("search_classes", {
     };
 });
 server.registerTool("search_implementations", {
-    description: "Search for classes that implement a specific interface or extend a specific class. This is useful for finding implementations of SPIs or base classes.",
+    description: "Search for classes that implement a specific interface or extend a specific class. This is useful for finding implementations of SPIs or base classes, especially in external libraries.",
     inputSchema: z.object({
         className: z.string().describe("Fully qualified class name of the interface or base class (e.g. 'java.util.List')"),
     }),
@@ -69,7 +69,7 @@ server.registerTool("search_implementations", {
     const matches = indexer.searchImplementations(className);
     const text = matches.length > 0
         ? matches.map(m => {
-            const artifacts = m.artifacts.slice(0, 5).map(a => `[ID: ${a.id}] ${a.groupId}:${a.artifactId}:${a.version}`).join("\n    ");
+            const artifacts = m.artifacts.slice(0, 5).map(a => `${a.groupId}:${a.artifactId}:${a.version}`).join("\n    ");
             const more = m.artifacts.length > 5 ? `\n    ... (${m.artifacts.length - 5} more versions)` : '';
             return `Implementation: ${m.className}\n    ${artifacts}${more}`;
         }).join("\n\n")
@@ -79,17 +79,54 @@ server.registerTool("search_implementations", {
     };
 });
 server.registerTool("get_class_details", {
-    description: "Get details about a specific class from a Maven artifact. Use this to inspect external classes where source code is missing. It can provide method signatures (using javap), Javadocs, or even decompiled source code if the original source jar is unavailable.",
+    description: "Decompile and read the source code of external libraries/dependencies. Use this instead of 'SearchCodebase' for classes that are imported but defined in JAR files. Returns method signatures, Javadocs, or full source. Essential for verifying implementation details during refactoring. Don't guess what the library does—read the code. When reviewing usages of an external class, use this to retrieve the class definition to understand the context fully.",
     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)"),
+        coordinate: z.string().optional().describe("The Maven coordinate of the artifact (groupId:artifactId:version). Optional: if not provided, the tool will automatically find the best match (preferring artifacts with source code)."),
         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." }] };
+}, async ({ className, coordinate, type }) => {
+    let targetArtifact;
+    if (coordinate) {
+        const parts = coordinate.split(':');
+        if (parts.length === 3) {
+            targetArtifact = indexer.getArtifactByCoordinate(parts[0], parts[1], parts[2]);
+        }
+        else {
+            return { content: [{ type: "text", text: "Invalid coordinate format. Expected groupId:artifactId:version" }] };
+        }
+        if (!targetArtifact) {
+            return { content: [{ type: "text", text: `Artifact ${coordinate} not found in index.` }] };
+        }
+    }
+    else {
+        // Auto-resolve artifact if coordinate is missing
+        const matches = indexer.searchClass(className);
+        // Find exact match for class name
+        const exactMatch = matches.find(m => m.className === className);
+        if (!exactMatch) {
+            // If no exact match, but we have some results, list them
+            if (matches.length > 0) {
+                const suggestions = matches.map(m => `- ${m.className}`).join("\n");
+                return { content: [{ type: "text", text: `Class '${className}' not found exactly. Did you mean:\n${suggestions}` }] };
+            }
+            return { content: [{ type: "text", text: `Class '${className}' not found in the index. Try 'search_classes' with a keyword if you are unsure of the full name.` }] };
+        }
+        // We have an exact match, choose the best artifact
+        // Strategy: 1. Prefer hasSource=true. 2. Prefer highest ID (likely newest).
+        const artifacts = exactMatch.artifacts.sort((a, b) => {
+            if (a.hasSource !== b.hasSource) {
+                return a.hasSource ? -1 : 1; // source comes first
+            }
+            return b.id - a.id; // higher ID comes first
+        });
+        if (artifacts.length === 0) {
+            return { content: [{ type: "text", text: `Class '${className}' found but no artifacts are associated with it (database inconsistency).` }] };
+        }
+        targetArtifact = artifacts[0];
+        // console.error(`Auto-resolved ${className} to artifact ${artifacts[0].groupId}:${artifacts[0].artifactId}:${artifacts[0].version} (ID: ${targetArtifact.id})`);
     }
+    const artifact = targetArtifact;
     let detail = null;
     let usedDecompilation = false;
     let lastError = "";
@@ -107,7 +144,10 @@ server.registerTool("get_class_details", {
         }
         // 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`);
+            let mainJarPath = artifact.abspath;
+            if (!mainJarPath.endsWith('.jar')) {
+                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);
@@ -123,7 +163,10 @@ server.registerTool("get_class_details", {
     }
     else {
         // Signatures -> Use Main JAR
-        const mainJarPath = path.join(artifact.abspath, `${artifact.artifactId}-${artifact.version}.jar`);
+        let mainJarPath = artifact.abspath;
+        if (!mainJarPath.endsWith('.jar')) {
+            mainJarPath = path.join(artifact.abspath, `${artifact.artifactId}-${artifact.version}.jar`);
+        }
         try {
             detail = await SourceParser.getClassDetail(mainJarPath, className, type);
         }
@@ -137,12 +180,14 @@ server.registerTool("get_class_details", {
             const errorMsg = lastError ? `\nLast error: ${lastError}` : "";
             return { content: [{ type: "text", text: `Class ${className} not found in artifact ${artifact.artifactId}. \nDebug info: ${debugInfo}${errorMsg}` }] };
         }
-        let resultText = `Class: ${detail.className}\n\n`;
+        let resultText = `Class: ${detail.className}\n`;
+        resultText += `Artifact: ${artifact.groupId}:${artifact.artifactId}:${artifact.version}\n\n`; // Inform user which artifact was used
         if (usedDecompilation) {
             resultText += "*Source code decompiled from binary class file.*\n\n";
         }
         if (type === 'source') {
-            resultText += "```java\n" + detail.source + "\n```";
+            const lang = detail.language || 'java';
+            resultText += "```" + lang + "\n" + detail.source + "\n```";
         }
         else {
             if (detail.doc) {

package/build/indexer.js

@@ -28,16 +28,22 @@ export class Indexer {
      */
     async startWatch() {
         const config = await Config.getInstance();
-        const repoPath = config.localRepository;
-        if (!repoPath || !fsSync.existsSync(repoPath)) {
-            console.error("Repository path not found, skipping watch mode.");
+        const pathsToWatch = [];
+        if (config.localRepository && fsSync.existsSync(config.localRepository)) {
+            pathsToWatch.push(config.localRepository);
+        }
+        if (config.gradleRepository && fsSync.existsSync(config.gradleRepository)) {
+            pathsToWatch.push(config.gradleRepository);
+        }
+        if (pathsToWatch.length === 0) {
+            console.error("No repository paths found, skipping watch mode.");
             return;
         }
         if (this.watcher) {
             return;
         }
-        console.error(`Starting file watcher on ${repoPath}...`);
-        this.watcher = chokidar.watch(repoPath, {
+        console.error(`Starting file watcher on ${pathsToWatch.join(', ')}...`);
+        this.watcher = chokidar.watch(pathsToWatch, {
             ignored: /(^|[\/\\])\../, // ignore dotfiles
             persistent: true,
             ignoreInitial: true,
@@ -88,15 +94,28 @@ export class Indexer {
         try {
             const config = await Config.getInstance();
             const repoPath = config.localRepository;
+            const gradleRepoPath = config.gradleRepository;
             const db = DB.getInstance();
-            if (!repoPath) {
-                console.error("No local repository path found.");
+            if (!repoPath && !gradleRepoPath) {
+                console.error("No repository path found.");
                 return;
             }
             // 1. Scan for artifacts
             console.error("Scanning repository structure...");
-            const artifacts = await this.scanRepository(repoPath);
-            console.error(`Found ${artifacts.length} artifacts on disk.`);
+            let artifacts = [];
+            if (repoPath && fsSync.existsSync(repoPath)) {
+                console.error(`Scanning Maven repo: ${repoPath}`);
+                const mavenArtifacts = await this.scanRepository(repoPath);
+                console.error(`Found ${mavenArtifacts.length} Maven artifacts.`);
+                artifacts = artifacts.concat(mavenArtifacts);
+            }
+            if (gradleRepoPath && fsSync.existsSync(gradleRepoPath)) {
+                console.error(`Scanning Gradle repo: ${gradleRepoPath}`);
+                const gradleArtifacts = await this.scanGradleRepository(gradleRepoPath);
+                console.error(`Found ${gradleArtifacts.length} Gradle artifacts.`);
+                artifacts = artifacts.concat(gradleArtifacts);
+            }
+            console.error(`Found ${artifacts.length} total artifacts on disk.`);
             // 2. Persist artifacts and determine what needs indexing
             // We use is_indexed = 0 for new artifacts.
             const insertArtifact = db.prepare(`
@@ -197,12 +216,86 @@ export class Indexer {
         await scanDir(rootDir);
         return results;
     }
+    /**
+     * Scans a Gradle cache directory for artifacts.
+     * Structure: group/artifact/version/hash/file
+     */
+    async scanGradleRepository(rootDir) {
+        const results = [];
+        // Helper to read directory safely
+        const readDirSafe = async (p) => {
+            try {
+                return await fs.readdir(p, { withFileTypes: true });
+            }
+            catch (e) {
+                return [];
+            }
+        };
+        const groupDirs = await readDirSafe(rootDir);
+        for (const groupEntry of groupDirs) {
+            if (!groupEntry.isDirectory())
+                continue;
+            const groupId = groupEntry.name;
+            const groupPath = path.join(rootDir, groupId);
+            const artifactDirs = await readDirSafe(groupPath);
+            for (const artifactEntry of artifactDirs) {
+                if (!artifactEntry.isDirectory())
+                    continue;
+                const artifactId = artifactEntry.name;
+                const artifactPath = path.join(groupPath, artifactId);
+                const versionDirs = await readDirSafe(artifactPath);
+                for (const versionEntry of versionDirs) {
+                    if (!versionEntry.isDirectory())
+                        continue;
+                    const version = versionEntry.name;
+                    const versionPath = path.join(artifactPath, version);
+                    const hashDirs = await readDirSafe(versionPath);
+                    let jarPath = null;
+                    let hasSource = false;
+                    // We need to iterate all hash dirs to find the jar and source jar
+                    for (const hashEntry of hashDirs) {
+                        if (!hashEntry.isDirectory())
+                            continue;
+                        const hashPath = path.join(versionPath, hashEntry.name);
+                        const files = await readDirSafe(hashPath);
+                        for (const file of files) {
+                            if (file.isFile()) {
+                                if (file.name.endsWith('.jar')) {
+                                    if (file.name.endsWith('-sources.jar')) {
+                                        hasSource = true;
+                                    }
+                                    else if (!file.name.endsWith('-javadoc.jar')) {
+                                        // This should be the main jar
+                                        jarPath = path.join(hashPath, file.name);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (jarPath) {
+                        results.push({
+                            id: 0, // Placeholder
+                            groupId,
+                            artifactId,
+                            version,
+                            abspath: jarPath, // Full path to JAR
+                            hasSource
+                        });
+                    }
+                }
+            }
+        }
+        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`);
+        let jarPath = artifact.abspath;
+        if (!jarPath.endsWith('.jar')) {
+            jarPath = path.join(artifact.abspath, `${artifact.artifactId}-${artifact.version}.jar`);
+        }
         const db = DB.getInstance();
         const config = await Config.getInstance();
         try {
@@ -485,4 +578,26 @@ export class Indexer {
         }
         return undefined;
     }
+    /**
+     * Retrieves an artifact by its Maven coordinate.
+     */
+    getArtifactByCoordinate(groupId, artifactId, version) {
+        const db = DB.getInstance();
+        const row = db.prepare(`
+          SELECT id, group_id as groupId, artifact_id as artifactId, version, abspath, has_source as hasSource
+          FROM artifacts 
+          WHERE group_id = ? AND artifact_id = ? AND version = ?
+      `).get(groupId, artifactId, version);
+        if (row) {
+            return {
+                id: row.id,
+                groupId: row.groupId,
+                artifactId: row.artifactId,
+                version: row.version,
+                abspath: row.abspath,
+                hasSource: Boolean(row.hasSource)
+            };
+        }
+        return undefined;
+    }
 }

package/build/reproduce_issue.js

@@ -0,0 +1,20 @@
+import { Indexer } from "./indexer.js";
+import { DB } from "./db/index.js";
+async function main() {
+    const db = DB.getInstance();
+    const indexer = Indexer.getInstance();
+    // We assume indexing is done since we just ran it.
+    console.log("Searching for 'Kotlin'...");
+    const kotlinResults = db.prepare("SELECT class_name FROM classes_fts WHERE class_name LIKE '%Kotlin%' LIMIT 10").all();
+    console.log("First 10 Kotlin classes:", kotlinResults);
+    console.log("Searching for 'AnAction'...");
+    const anActionResults = indexer.searchClass("AnAction");
+    console.log(`Found ${anActionResults.length} results for 'AnAction'.`);
+    if (anActionResults.length > 0) {
+        console.log(anActionResults[0]);
+    }
+    console.log("Searching for 'StringUtils'...");
+    const stringUtilsResults = indexer.searchClass("StringUtils");
+    console.log(`Found ${stringUtilsResults.length} results for 'StringUtils'.`);
+}
+main().catch(console.error);

package/build/source_parser.js

@@ -28,6 +28,7 @@ export class SourceParser {
                 zipfile.on('entry', (entry) => {
                     if (candidates.includes(entry.fileName)) {
                         found = true;
+                        const language = entry.fileName.endsWith('.kt') ? 'kotlin' : 'java';
                         zipfile.openReadStream(entry, (err, readStream) => {
                             if (err || !readStream) {
                                 resolve(null);
@@ -37,7 +38,7 @@ export class SourceParser {
                             readStream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
                             readStream.on('end', () => {
                                 const source = Buffer.concat(chunks).toString('utf-8');
-                                resolve(SourceParser.parse(className, source, type));
+                                resolve(SourceParser.parse(className, source, type, language));
                             });
                         });
                     }
@@ -81,11 +82,12 @@ export class SourceParser {
                 throw new Error(`CFR stderr: ${stderr}`);
             }
             if (stdout) {
-                return this.parse(className, stdout, type);
+                return this.parse(className, stdout, type, 'java');
             }
             return {
                 className,
-                source: stdout // Return as source
+                source: stdout, // Return as source
+                language: 'java'
             };
         }
         catch (e) {
@@ -108,7 +110,8 @@ export class SourceParser {
                 l !== '}');
             return {
                 className,
-                signatures: lines
+                signatures: lines,
+                language: 'java'
             };
         }
         catch (e) {
@@ -118,9 +121,9 @@ export class SourceParser {
             return null;
         }
     }
-    static parse(className, source, type) {
+    static parse(className, source, type, language = 'java') {
         if (type === 'source') {
-            return { className, source };
+            return { className, source, language };
         }
         // Very simple regex-based parsing to extract methods and javadocs
         // This is heuristic and won't be perfect, but it's fast and dependency-free
@@ -169,7 +172,8 @@ export class SourceParser {
         return {
             className,
             signatures,
-            doc: type === 'docs' ? allDocs.join('\n\n') : undefined
+            doc: type === 'docs' ? allDocs.join('\n\n') : undefined,
+            language
         };
     }
 }

package/package.json

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