mcdev-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,77 @@
+MIT License
+
+Copyright (c) 2025 mcdev-mcp contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+--------------------------------------------------------------------------------
+
+## Third-Party Licenses
+
+This project includes or uses third-party software under the following licenses:
+
+### DecompilerMC
+
+The decompiler integration logic in `src/decompiler/` is adapted and translated from Python to TypeScript based on DecompilerMC's architecture.
+
+Source: https://github.com/hube12/DecompilerMC
+
+MIT License
+
+Copyright (c) 2020 Neil
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+### Vineflower
+
+This project uses Vineflower for decompiling Minecraft JAR files.
+
+Source: https://github.com/Vineflower/vineflower
+
+Apache License 2.0
+
+Copyright (c) 2021-2023 Vineflower contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,365 @@
+# mcdev-mcp
+
+[![CI](https://github.com/weikengchen/mcdev-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/weikengchen/mcdev-mcp/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+An **MCP (Model Context Protocol) server** that empowers AI coding agents to work effectively with Minecraft mod development. Provides accurate, up-to-date access to decompiled Minecraft source code using official Mojang mappings.
+
+## Features
+
+- **Decompiled Source Access** — Auto-downloads and decompiles Minecraft client using [Vineflower](https://github.com/Vineflower/vineflower)
+- **Dev Snapshot Support** — Works with development snapshots (e.g., `26.1-snapshot-10`) that lack ProGuard mappings
+- **Symbol Search** — Search for classes, methods, and fields by name
+- **Source Retrieval** — Get full class source or individual methods with context
+- **Package Exploration** — List all classes under a package path or discover available packages
+- **Class Hierarchy** — Find subclasses and interface implementors
+- **Call Graph Analysis** — Find method callers and callees across the entire codebase
+- **Zero Configuration** — Auto-initializes on first use if sources are cached
+
+## Quick Start
+
+> **Security note — `init` is intentionally terminal-only.** The MCP server only exposes read/query tools. Downloading and decompiling Minecraft sources must be triggered by you in the terminal; an AI agent connected to the server has no tool surface to trigger `init`, `rebuild`, `clean`, or `callgraph`.
+
+### 1. Initialize in your terminal
+
+```bash
+# Download, decompile, and index Minecraft sources (~2-5 minutes)
+npx mcdev-mcp init -v 1.21.11
+```
+
+This command:
+1. Downloads the Minecraft client JAR
+2. Decompiles using Vineflower (pure Java, 8 threads)
+3. Builds the symbol index (classes, methods, fields, inheritance)
+4. Generates call graph for `mc_find_refs`
+
+Data is stored under `~/.mcdev-mcp/`, so it persists across `npx` invocations.
+
+### 2. Add to your MCP client
+
+```json
+{
+  "mcpServers": {
+    "mcdev": {
+      "command": "npx",
+      "args": ["-y", "mcdev-mcp", "serve"]
+    }
+  }
+}
+```
+
+The `serve` subcommand starts the MCP server over stdio. Your MCP client (Claude Desktop, Cursor, etc.) launches it automatically — you never run `serve` directly.
+
+### Supported Versions
+
+| Version Type | Example | Notes |
+|--------------|---------|-------|
+| Dev snapshots | `26.1-snapshot-10` | Already unobfuscated, no mappings needed |
+| Release (>= 1.21.11) | `1.21.11` | Uses pre-unobfuscated JAR when available |
+| Old versions | `< 1.21.11` | Not supported |
+
+> **Note:** Minecraft is now using a new versioning scheme (26.x). Versions before 1.21.11 are not supported.
+
+### (Optional) Skip Call Graph
+
+```bash
+# Skip callgraph generation if you don't need mc_find_refs
+npx mcdev-mcp init -v 1.21.11 --skip-callgraph
+
+# Generate callgraph later
+npx mcdev-mcp callgraph -v 1.21.11
+```
+
+### Verify Installation
+
+```bash
+npx mcdev-mcp status
+```
+
+> **Note:** The `mc_set_version` tool must be called before using any other MCP tools. If the version isn't initialized, the AI will be instructed to ask you to run `init`.
+
+### Install from source (development)
+
+```bash
+git clone https://github.com/weikengchen/mcdev-mcp.git
+cd mcdev-mcp
+npm install
+npm run build
+
+# Use the local build instead of npx
+node dist/cli.js init -v 1.21.11
+node dist/cli.js serve         # stdio MCP server; MCP clients launch this
+```
+
+> **Upgrading from an older version?** If you have a previous installation using DecompilerMC, run `npx mcdev-mcp clean --all` first to remove old cached data.
+
+## MCP Tools
+
+### Version Management
+
+Before using any other tools, set the active Minecraft version:
+
+### `mc_set_version`
+Set the active Minecraft version for this session. Must be called before other tools.
+
+```json
+{
+  "version": "1.21.11"
+}
+```
+
+### `mc_list_versions`
+List all Minecraft versions that have been initialized.
+
+```json
+{}
+```
+
+### Tool Requirements
+
+| Tool | Requires `init` | Requires `callgraph` |
+|------|-----------------|---------------------|
+| `mc_set_version` | - | - |
+| `mc_list_versions` | - | - |
+| `mc_search` | ✓ | - |
+| `mc_get_class` | ✓ | - |
+| `mc_get_method` | ✓ | - |
+| `mc_list_classes` | ✓ | - |
+| `mc_list_packages` | ✓ | - |
+| `mc_find_hierarchy` | ✓ | - |
+| `mc_find_refs` | ✓ | ✓ |
+
+### `mc_search`
+Search for Minecraft classes, methods, or fields by name pattern.
+
+```json
+{
+  "query": "Minecraft",
+  "type": "class"
+}
+```
+
+### `mc_get_class`
+Get the full decompiled source code for a class.
+
+```json
+{
+  "className": "net.minecraft.client.Minecraft"
+}
+```
+
+### `mc_get_method`
+Get source code for a specific method with context.
+
+```json
+{
+  "className": "net.minecraft.client.Minecraft",
+  "methodName": "tick"
+}
+```
+
+### `mc_find_refs`
+Find who calls a method (callers) or what it calls (callees).
+
+```json
+{
+  "className": "net.minecraft.client.MouseHandler",
+  "methodName": "setup",
+  "direction": "callers"
+}
+```
+
+| Direction | Description |
+|-----------|-------------|
+| `callers` | Find methods that call this method |
+| `callees` | Find methods this method calls |
+
+> **Note:** Requires callgraph to be generated (included in `init` by default).
+
+### `mc_list_classes`
+List all classes under a specific package path (includes subpackages).
+
+```json
+{
+  "packagePath": "net.minecraft.client.gui.screens"
+}
+```
+
+### `mc_list_packages`
+List all available packages. Optionally filter by namespace.
+
+```json
+{
+  "namespace": "minecraft"
+}
+```
+
+| Namespace | Description |
+|-----------|-------------|
+| `minecraft` | Minecraft client classes |
+| `fabric` | Fabric API classes (if indexed) |
+
+### `mc_find_hierarchy`
+Find classes that extend or implement a given class or interface.
+
+```json
+{
+  "className": "net.minecraft.world.entity.Entity",
+  "direction": "subclasses"
+}
+```
+
+| Direction | Description |
+|-----------|-------------|
+| `subclasses` | Classes that extend this class |
+| `implementors` | Classes that implement this interface |
+
+## Requirements
+
+| Dependency | Version | Purpose |
+|------------|---------|---------|
+| Node.js | 18+ | Runtime |
+| Java | 8+ | Decompilation (Vineflower) & callgraph |
+| ~2GB | disk | Decompiled sources + cache |
+
+> **Note:** Java 17+ is recommended for the `callgraph` command due to Gradle compatibility.
+
+## CLI Commands
+
+Invoke via `npx mcdev-mcp <command>` (or `node dist/cli.js <command>` from a source checkout).
+
+| Command | Description |
+|---------|-------------|
+| `serve` | Start the MCP server over stdio (launched by MCP clients — not run by humans) |
+| `init -v <version>` | Download, decompile, index Minecraft sources, and generate callgraph |
+| `callgraph -v <version>` | Generate call graph for `mc_find_refs` |
+| `status` | Show all initialized versions |
+| `rebuild -v <version>` | Rebuild the symbol index from cached sources |
+| `clean --all` | Clean all cached data |
+
+### Re-indexing
+
+To re-index a version:
+
+```bash
+# Clean existing data for a version
+npx mcdev-mcp clean -v 1.21.11 --all
+
+# Re-initialize
+npx mcdev-mcp init -v 1.21.11
+```
+
+## Architecture
+
+```
+mcdev-mcp/
+├── src/
+│   ├── index.ts              # MCP server entry point
+│   ├── cli.ts                # CLI commands
+│   ├── tools/                # MCP tool implementations
+│   ├── decompiler/           # Vineflower integration (pure TypeScript/Java)
+│   ├── indexer/              # Symbol index builder
+│   ├── callgraph/            # Call graph generation & queries
+│   └── storage/              # Source & index storage
+└── dist/                     # Compiled output
+```
+
+### How It Works
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                     MCP Client (AI Agent)                    │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│                      mcdev-mcp Server                        │
+│  ┌─────────┐ ┌──────────┐ ┌──────────┐ ┌───────────┐       │
+│  │ search  │ │get_class │ │get_method│ │ find_refs │       │
+│  └────┬────┘ └────┬─────┘ └────┬─────┘ └─────┬─────┘       │
+│  ┌─────────────┐ ┌───────────────┐ ┌─────────────────┐     │
+│  │list_classes │ │list_packages  │ │ find_hierarchy  │     │
+│  └──────┬──────┘ └───────┬───────┘ └────────┬────────┘     │
+│         └────────────────┼──────────────────┘              │
+│                          │                                  │
+│       ┌──────────────────┴───────────────────┐             │
+│       ▼                                       ▼             │
+│  ┌──────────┐                          ┌─────────────┐      │
+│  │  Index   │                          │  Callgraph  │      │
+│  │ (JSON)   │                          │  (SQLite)   │      │
+│  └────┬─────┘                          └──────┬──────┘      │
+└───────┼────────────────────────────────────────┼────────────┘
+        ▼                                        ▼
+┌───────────────────┐                  ┌─────────────────────┐
+│ Decompiled Src    │                  │ java-callgraph2     │
+│ (Vineflower)      │                  │ (static analysis)   │
+└───────────────────┘                  └─────────────────────┘
+```
+
+See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for detailed design documentation.
+
+## Directory Structure
+
+```
+~/.mcdev-mcp/
+├── tools/
+│   └── vineflower.jar         # Downloaded once
+├── java-callgraph2/           # Call graph tool
+├── cache/
+│   └── {version}/
+│       ├── jars/               # Downloaded JARs
+│       └── client/             # Decompiled Minecraft sources
+├── index/
+│   └── {version}/
+│       ├── manifest.json       # Index metadata
+│       └── minecraft/          # Per-package symbol indices
+└── tmp/                        # Temporary files (cleaned by --all)
+```
+
+## Development
+
+```bash
+npm run build    # Compile TypeScript
+npm test         # Run tests
+npm run lint     # Lint code
+```
+
+## Limitations
+
+- **Static Analysis Only**: `mc_find_refs` cannot trace calls through reflection, JNI callbacks, or lambda/method references created dynamically
+- **Client Only**: Server-side classes are not included
+
+## Legal Notice
+
+This tool decompiles Minecraft source code for development reference purposes. Please respect Mojang's intellectual property:
+
+**You MAY:**
+- Decompile and study the code for understanding and learning
+- Use the knowledge to develop mods that don't contain substantial Mojang code
+- Reference class/method names for mod development
+
+**You may NOT:**
+- Distribute decompiled source code
+- Distribute modified versions of Minecraft
+- Use decompiled code commercially without permission
+
+Per the [Minecraft EULA](https://www.minecraft.net/eula): *"You may not distribute any Modded Versions of our game or software"* and *"Mods are okay to distribute; hacked versions or Modded Versions of the game client or server software are not okay to distribute."*
+
+This tool is for **reference only** — do not copy decompiled code directly into your projects.
+
+## Third-Party Components
+
+This project includes or uses third-party software under the following licenses:
+
+- **[DecompilerMC](https://github.com/hube12/DecompilerMC)** (MIT) — Decompiler logic adapted and translated from Python to TypeScript in `src/decompiler/`
+- **[Vineflower](https://github.com/Vineflower/vineflower)** (Apache-2.0) — Java decompiler used for source generation
+- **[java-callgraph2](https://github.com/Adrninistrator/java-callgraph2)** — Cloned at runtime for static call graph generation
+
+Additional runtime dependencies (downloaded/used):
+- **[Mojang](https://www.minecraft.net/)** — Official ProGuard mappings and Minecraft client JAR
+
+See [LICENSE](LICENSE) for full license text and third-party attributions.
+
+## License
+
+[MIT](LICENSE) — Copyright (c) 2025 mcdev-mcp contributors

package/dist/callgraph/index.d.ts

@@ -0,0 +1,14 @@
+export declare function getJavaCGDir(): string;
+export declare function getJavaCGJarPath(): string;
+export declare function getJavaCGLibDir(): string;
+export declare function getDecompilerMCDir(): string;
+export declare function getRemappedJarPath(version: string): string;
+export type ProgressCallback = (stage: string, progress: number, message: string) => void;
+export declare function ensureJavaCG(progressCb?: ProgressCallback): Promise<string>;
+export declare function ensureRemappedJar(version: string, progressCb?: ProgressCallback): Promise<string>;
+export declare function generateCallgraph(version: string, progressCb?: ProgressCallback): Promise<string>;
+export declare function hasCallgraphDb(version: string): boolean;
+export declare function parseCallgraphAndCreateDb(version: string, callgraphFile: string, progressCb?: ProgressCallback): number;
+export declare function ensureCallgraph(version: string, progressCb?: ProgressCallback): Promise<void>;
+export { openDb, closeDb, findCallers, findCallees, searchMethods, getCallgraphStats } from './query.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/callgraph/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/callgraph/index.ts"],"names":[],"mappings":"AASA,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAGzC;AAED,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;AAE1F,wBAAsB,YAAY,CAAC,UAAU,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAwDjF;AAED,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CA0BvG;AAED,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CA+BvG;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAqDvH;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAInG;AAED,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC"}

package/dist/callgraph/index.js

@@ -0,0 +1,201 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { spawn } from 'child_process';
+import Database from 'better-sqlite3';
+import { ensureDir, getHomeDir, getMinecraftJarPath } from '../utils/paths.js';
+import { getCallgraphDir, getCallgraphDbPath } from './query.js';
+const SPECIAL_SOURCE_VERSION = '1.11.4';
+export function getJavaCGDir() {
+    return path.join(getHomeDir(), 'java-callgraph2');
+}
+export function getJavaCGJarPath() {
+    // gen_run_jar creates jar_output_dir/jar/run_javacg2.jar
+    return path.join(getJavaCGDir(), 'jar_output_dir', 'jar', 'run_javacg2.jar');
+}
+export function getJavaCGLibDir() {
+    return path.join(getJavaCGDir(), 'jar_output_dir', 'lib');
+}
+export function getDecompilerMCDir() {
+    return path.join(getHomeDir(), 'DecompilerMC');
+}
+export function getRemappedJarPath(version) {
+    return path.join(getCallgraphDir(version), 'client-remapped.jar');
+}
+export async function ensureJavaCG(progressCb) {
+    const jarPath = getJavaCGJarPath();
+    if (fs.existsSync(jarPath))
+        return jarPath;
+    const jcDir = getJavaCGDir();
+    const gradlewPath = path.join(jcDir, 'gradlew');
+    const gradlewBatPath = path.join(jcDir, 'gradlew.bat');
+    const isWindows = process.platform === 'win32';
+    const gradlewCmd = isWindows ? 'gradlew.bat' : 'gradlew';
+    const gradlewExists = isWindows ? fs.existsSync(gradlewBatPath) : fs.existsSync(gradlewPath);
+    if (progressCb)
+        progressCb('javacg', 0, 'Cloning java-callgraph2...');
+    // Clone if gradlew doesn't exist (covers incomplete/corrupted clones)
+    if (!gradlewExists) {
+        if (fs.existsSync(jcDir)) {
+            fs.rmSync(jcDir, { recursive: true, force: true });
+        }
+        await new Promise((resolve, reject) => {
+            const proc = spawn('git', ['clone', 'https://github.com/Adrninistrator/java-callgraph2.git', jcDir], { stdio: 'inherit' });
+            proc.on('error', (err) => reject(new Error(`git clone failed: ${err.message}`)));
+            proc.on('close', (code) => code === 0 ? resolve() : reject(new Error(`git clone failed: ${code}`)));
+        });
+    }
+    // Update gradle wrapper to Gradle 9.3.1 (supports Java 25)
+    const gradleWrapperProps = path.join(jcDir, 'gradle', 'wrapper', 'gradle-wrapper.properties');
+    if (fs.existsSync(gradleWrapperProps)) {
+        fs.writeFileSync(gradleWrapperProps, 'distributionUrl=https\\://services.gradle.org/distributions/gradle-9.3.1-bin.zip\n');
+    }
+    // Make gradlew executable (Unix only)
+    if (!isWindows && fs.existsSync(gradlewPath)) {
+        fs.chmodSync(gradlewPath, 0o755);
+    }
+    // Patch build.gradle for Gradle 9.x compatibility (remove deprecated properties)
+    const buildGradlePath = path.join(jcDir, 'build.gradle');
+    if (fs.existsSync(buildGradlePath)) {
+        let buildGradle = fs.readFileSync(buildGradlePath, 'utf-8');
+        buildGradle = buildGradle.replace(/sourceCompatibility\s*=\s*1\.8\s*\n?/g, '');
+        buildGradle = buildGradle.replace(/targetCompatibility\s*=\s*1\.8\s*\n?/g, '');
+        fs.writeFileSync(buildGradlePath, buildGradle);
+    }
+    if (progressCb)
+        progressCb('javacg', 50, 'Building java-callgraph2 with Gradle 9.3...');
+    // Use gen_run_jar task instead of shadowJar (creates run_javacg2.jar with lib/ folder)
+    await new Promise((resolve, reject) => {
+        const proc = spawn(gradlewCmd, ['gen_run_jar'], { cwd: jcDir, stdio: 'inherit', shell: isWindows });
+        proc.on('error', (err) => reject(new Error(`gradle build failed: ${err.message}`)));
+        proc.on('close', (code) => code === 0 ? resolve() : reject(new Error(`gradle build failed: ${code}`)));
+    });
+    if (progressCb)
+        progressCb('javacg', 100, 'java-callgraph2 ready.');
+    return jarPath;
+}
+export async function ensureRemappedJar(version, progressCb) {
+    const remappedJar = getRemappedJarPath(version);
+    if (fs.existsSync(remappedJar))
+        return remappedJar;
+    const clientJar = getMinecraftJarPath(version);
+    const dmcdDir = getDecompilerMCDir();
+    const tsrgMappings = path.join(dmcdDir, 'mappings', version, 'client.tsrg');
+    const specialSource = path.join(dmcdDir, 'lib', `SpecialSource-${SPECIAL_SOURCE_VERSION}.jar`);
+    // For dev snapshots (no mappings), use client.jar directly
+    if (!fs.existsSync(tsrgMappings)) {
+        if (progressCb)
+            progressCb('remap', 0, 'No mappings found, using unobfuscated jar directly...');
+        ensureDir(path.dirname(remappedJar));
+        fs.copyFileSync(clientJar, remappedJar);
+        if (progressCb)
+            progressCb('remap', 100, 'Jar ready (no remapping needed).');
+        return remappedJar;
+    }
+    if (progressCb)
+        progressCb('remap', 0, 'Creating remapped jar...');
+    ensureDir(path.dirname(remappedJar));
+    return new Promise((resolve, reject) => {
+        const proc = spawn('java', ['-Xmx2g', '-jar', specialSource, '--in-jar', clientJar, '--out-jar', remappedJar, '--srg-in', tsrgMappings, '--kill-lvt'], { stdio: 'inherit' });
+        proc.on('error', (err) => reject(new Error(`SpecialSource failed: ${err.message}`)));
+        proc.on('close', (code) => code === 0 && fs.existsSync(remappedJar) ? (progressCb?.('remap', 100, 'Remapped jar created.'), resolve(remappedJar)) : reject(new Error(`SpecialSource failed: ${code}`)));
+    });
+}
+export async function generateCallgraph(version, progressCb) {
+    const javacgPath = await ensureJavaCG(progressCb);
+    const libDir = getJavaCGLibDir();
+    const outputDir = getCallgraphDir(version);
+    const remappedJar = await ensureRemappedJar(version, progressCb);
+    // java-callgraph2 outputs to {jar}-output_javacg2/method_call.txt
+    const expectedOutput = path.join(outputDir, `${path.basename(remappedJar)}-output_javacg2`, 'method_call.txt');
+    if (fs.existsSync(expectedOutput))
+        return expectedOutput;
+    ensureDir(outputDir);
+    if (progressCb)
+        progressCb('callgraph', 0, 'Generating callgraph...');
+    // java-callgraph2 expects config in _javacg2_config/ directory
+    const configDir = path.join(outputDir, '_javacg2_config');
+    ensureDir(configDir);
+    fs.writeFileSync(path.join(configDir, 'jar_dir.properties'), remappedJar);
+    fs.writeFileSync(path.join(configDir, 'config.properties'), `output.dir=${outputDir}\nparse.method.call.info=1\n`);
+    // Build classpath: jar + all libs
+    const libJars = fs.existsSync(libDir)
+        ? fs.readdirSync(libDir).filter(f => f.endsWith('.jar')).map(f => path.join(libDir, f))
+        : [];
+    const classpathSep = process.platform === 'win32' ? ';' : ':';
+    const classpath = [javacgPath, ...libJars].join(classpathSep);
+    return new Promise((resolve, reject) => {
+        const proc = spawn('java', ['-Xmx4g', '-cp', classpath, 'com.adrninistrator.javacg2.entry.JavaCG2Entry', configDir], { cwd: outputDir, stdio: 'inherit' });
+        proc.on('error', (err) => reject(new Error(`java-callgraph2 failed: ${err.message}`)));
+        proc.on('close', (code) => code === 0 || fs.existsSync(expectedOutput) ? (progressCb?.('callgraph', 100, 'Callgraph generated.'), resolve(expectedOutput)) : reject(new Error(`java-callgraph2 failed: ${code}`)));
+    });
+}
+export function hasCallgraphDb(version) {
+    return fs.existsSync(getCallgraphDbPath(version));
+}
+export function parseCallgraphAndCreateDb(version, callgraphFile, progressCb) {
+    if (progressCb)
+        progressCb('index', 0, 'Parsing callgraph...');
+    const content = fs.readFileSync(callgraphFile, 'utf-8');
+    const lines = content.split('\n');
+    const dbPath = getCallgraphDbPath(version);
+    if (fs.existsSync(dbPath))
+        fs.unlinkSync(dbPath);
+    const db = new Database(dbPath);
+    db.exec(`CREATE TABLE calls (id INTEGER PRIMARY KEY, caller_class TEXT, caller_method TEXT, caller_desc TEXT, callee_class TEXT, callee_method TEXT, callee_desc TEXT, line_number INTEGER); CREATE INDEX idx_callee ON calls(callee_class, callee_method); CREATE INDEX idx_caller ON calls(caller_class, caller_method);`);
+    const insert = db.prepare('INSERT INTO calls VALUES (NULL, ?, ?, ?, ?, ?, ?, ?)');
+    const insertMany = db.transaction((items) => { for (const item of items)
+        insert.run(...item); });
+    let count = 0;
+    const batch = [];
+    // Format: seq	num	caller	callee	line	return_type	...
+    // caller format: class:method(args)
+    // callee format: (TYPE)class:method(args) where TYPE is VIR/STA/SPE
+    for (const line of lines) {
+        if (!line.trim() || line.startsWith('#'))
+            continue;
+        const parts = line.split('\t');
+        if (parts.length < 5)
+            continue;
+        const callerRaw = parts[2] || '';
+        const calleeRaw = parts[3] || '';
+        const lineNumber = parts[4] ? parseInt(parts[4], 10) : null;
+        // Parse caller: class:method(args)
+        const callerMatch = callerRaw.match(/^(.+):(.+)(\([^)]*\))$/);
+        // Parse callee: (TYPE)class:method(args)
+        const calleeMatch = calleeRaw.match(/^\([A-Z]+\)(.+):(.+)(\([^)]*\))$/);
+        if (callerMatch && calleeMatch) {
+            batch.push([
+                callerMatch[1], callerMatch[2], callerMatch[3],
+                calleeMatch[1], calleeMatch[2], calleeMatch[3],
+                lineNumber
+            ]);
+            if (batch.length >= 10000) {
+                insertMany(batch);
+                count += batch.length;
+                batch.length = 0;
+                if (progressCb && count % 100000 === 0)
+                    progressCb('index', 50, `Indexed ${count}...`);
+            }
+        }
+    }
+    if (batch.length > 0) {
+        insertMany(batch);
+        count += batch.length;
+    }
+    db.pragma('optimize');
+    db.close();
+    if (progressCb)
+        progressCb('index', 100, `Indexed ${count} call references.`);
+    return count;
+}
+export async function ensureCallgraph(version, progressCb) {
+    if (hasCallgraphDb(version)) {
+        if (progressCb)
+            progressCb('callgraph', 100, 'Callgraph database ready.');
+        return;
+    }
+    const callgraphFile = await generateCallgraph(version, progressCb);
+    parseCallgraphAndCreateDb(version, callgraphFile, progressCb);
+}
+export { openDb, closeDb, findCallers, findCallees, searchMethods, getCallgraphStats } from './query.js';
+//# sourceMappingURL=index.js.map