@adhisang/minecraft-modding-mcp 1.0.0

package/dist/access-widener-parser.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Parser for Fabric Access Widener files (.accesswidener).
+ * Format: line-based, tab/space separated.
+ * Header: `accessWidener v2 intermediary`
+ * Entry:  `accessible class net/minecraft/foo/Bar`
+ *         `accessible method net/minecraft/foo/Bar baz (I)V`
+ *         `mutable field net/minecraft/foo/Bar qux I`
+ */
+export type AccessWidenerEntry = {
+    line: number;
+    kind: "accessible" | "extendable" | "mutable";
+    targetKind: "class" | "method" | "field";
+    target: string;
+    owner?: string;
+    name?: string;
+    descriptor?: string;
+};
+export type ParsedAccessWidener = {
+    headerVersion: string;
+    namespace: string;
+    entries: AccessWidenerEntry[];
+    parseWarnings: string[];
+};
+export declare function parseAccessWidener(content: string): ParsedAccessWidener;

package/dist/access-widener-parser.js

@@ -0,0 +1,77 @@
+/**
+ * Parser for Fabric Access Widener files (.accesswidener).
+ * Format: line-based, tab/space separated.
+ * Header: `accessWidener v2 intermediary`
+ * Entry:  `accessible class net/minecraft/foo/Bar`
+ *         `accessible method net/minecraft/foo/Bar baz (I)V`
+ *         `mutable field net/minecraft/foo/Bar qux I`
+ */
+const VALID_KINDS = new Set(["accessible", "extendable", "mutable"]);
+const VALID_TARGET_KINDS = new Set(["class", "method", "field"]);
+export function parseAccessWidener(content) {
+    const lines = content.split(/\r?\n/);
+    const parseWarnings = [];
+    const entries = [];
+    let headerVersion = "";
+    let namespace = "";
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i].trim();
+        const lineNum = i + 1;
+        // Skip blank lines and comments
+        if (!raw || raw.startsWith("#"))
+            continue;
+        // Header line
+        if (!headerVersion) {
+            const parts = raw.split(/\s+/);
+            if (parts[0] === "accessWidener" && parts.length >= 3) {
+                headerVersion = parts[1];
+                namespace = parts[2];
+            }
+            else {
+                parseWarnings.push(`Line ${lineNum}: Expected accessWidener header, got: "${raw}"`);
+            }
+            continue;
+        }
+        // Entry lines
+        const parts = raw.split(/\s+/);
+        if (parts.length < 3) {
+            parseWarnings.push(`Line ${lineNum}: Incomplete entry: "${raw}"`);
+            continue;
+        }
+        const kind = parts[0];
+        const targetKind = parts[1];
+        if (!VALID_KINDS.has(kind)) {
+            parseWarnings.push(`Line ${lineNum}: Unknown access kind "${kind}".`);
+            continue;
+        }
+        if (!VALID_TARGET_KINDS.has(targetKind)) {
+            parseWarnings.push(`Line ${lineNum}: Unknown target kind "${targetKind}".`);
+            continue;
+        }
+        const validKind = kind;
+        const validTargetKind = targetKind;
+        if (validTargetKind === "class") {
+            entries.push({ line: lineNum, kind: validKind, targetKind: validTargetKind, target: parts[2] });
+        }
+        else if (parts.length >= 5) {
+            // method/field: <kind> <targetKind> <owner> <name> <descriptor>
+            entries.push({
+                line: lineNum,
+                kind: validKind,
+                targetKind: validTargetKind,
+                target: parts[2],
+                owner: parts[2],
+                name: parts[3],
+                descriptor: parts[4]
+            });
+        }
+        else {
+            parseWarnings.push(`Line ${lineNum}: ${validTargetKind} entry requires owner, name, and descriptor.`);
+        }
+    }
+    if (!headerVersion) {
+        parseWarnings.push("Missing accessWidener header.");
+    }
+    return { headerVersion, namespace, entries, parseWarnings };
+}
+//# sourceMappingURL=access-widener-parser.js.map

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { startServer } from "./index.js";
+startServer();
+//# sourceMappingURL=cli.js.map

package/dist/config.d.ts

@@ -0,0 +1,27 @@
+import type { Config } from "./types.js";
+declare const DEFAULTS: {
+    readonly cacheDir: ".cache/minecraft-modding-mcp";
+    readonly sourceRepos: readonly ["https://repo1.maven.org/maven2", "https://maven.fabricmc.net", "https://maven.minecraftforge.net", "https://maven.neoforged.net/releases"];
+    readonly localM2Path: "~/.m2/repository";
+    readonly indexedSearchEnabled: true;
+    readonly mappingSourcePriority: "loom-first";
+    readonly maxContentBytes: 1000000;
+    readonly maxSearchHits: 200;
+    readonly maxArtifacts: 200;
+    readonly maxCacheBytes: 2147483648;
+    readonly fetchTimeoutMs: 15000;
+    readonly fetchRetries: 2;
+    readonly searchScanPageSize: 250;
+    readonly indexInsertChunkSize: 200;
+    readonly maxMappingGraphCache: 16;
+    readonly maxSignatureCache: 2000;
+    readonly maxVersionDetailCache: 256;
+    readonly maxNbtInputBytes: number;
+    readonly maxNbtInflatedBytes: number;
+    readonly maxNbtResponseBytes: number;
+    readonly remapTimeoutMs: 600000;
+    readonly remapMaxMemoryMb: 4096;
+};
+export declare function loadConfig(): Config;
+export declare function stableArtifactId(parts: string[]): string;
+export { DEFAULTS };

package/dist/config.js

@@ -0,0 +1,178 @@
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+import { isAbsolute, resolve } from "node:path";
+import { normalizePathForHost } from "./path-converter.js";
+const DEFAULTS = {
+    cacheDir: ".cache/minecraft-modding-mcp",
+    sourceRepos: [
+        "https://repo1.maven.org/maven2",
+        "https://maven.fabricmc.net",
+        "https://maven.minecraftforge.net",
+        "https://maven.neoforged.net/releases"
+    ],
+    localM2Path: "~/.m2/repository",
+    indexedSearchEnabled: true,
+    mappingSourcePriority: "loom-first",
+    maxContentBytes: 1_000_000,
+    maxSearchHits: 200,
+    maxArtifacts: 200,
+    maxCacheBytes: 2_147_483_648,
+    fetchTimeoutMs: 15000,
+    fetchRetries: 2,
+    searchScanPageSize: 250,
+    indexInsertChunkSize: 200,
+    maxMappingGraphCache: 16,
+    maxSignatureCache: 2_000,
+    maxVersionDetailCache: 256,
+    maxNbtInputBytes: 4 * 1024 * 1024,
+    maxNbtInflatedBytes: 16 * 1024 * 1024,
+    maxNbtResponseBytes: 8 * 1024 * 1024,
+    remapTimeoutMs: 600_000,
+    remapMaxMemoryMb: 4096
+};
+const MAX_RETRIES_LOWER_BOUND = 0;
+const MAX_RETRIES_UPPER_BOUND = 20;
+const MAX_BYTES_LOWER_BOUND = 1;
+const MAX_SEARCH_HITS_LOWER_BOUND = 1;
+const MAX_SEARCH_HITS_UPPER_BOUND = 10_000;
+const MAX_ARTIFACTS_LOWER_BOUND = 1;
+const MAX_ARTIFACTS_UPPER_BOUND = 100_000;
+const MAX_CACHE_BYTES_LOWER_BOUND = 1_024;
+const TIMEOUT_LOWER_BOUND_MS = 500;
+const SEARCH_SCAN_PAGE_SIZE_LOWER_BOUND = 1;
+const SEARCH_SCAN_PAGE_SIZE_UPPER_BOUND = 10_000;
+const INDEX_INSERT_CHUNK_SIZE_LOWER_BOUND = 1;
+const INDEX_INSERT_CHUNK_SIZE_UPPER_BOUND = 20_000;
+const CACHE_ENTRIES_LOWER_BOUND = 1;
+const CACHE_ENTRIES_UPPER_BOUND = 100_000;
+function expandHome(pathValue) {
+    if (!pathValue.startsWith("~")) {
+        return pathValue;
+    }
+    const withoutTilde = pathValue.startsWith("~/") ? pathValue.slice(2) : pathValue.slice(1);
+    return resolve(homedir(), withoutTilde);
+}
+function normalizePath(pathValue, field) {
+    const expanded = expandHome(pathValue.trim());
+    const normalizedForHost = normalizePathForHost(expanded, undefined, field);
+    if (isAbsolute(normalizedForHost)) {
+        return normalizedForHost;
+    }
+    return resolve(process.cwd(), normalizedForHost);
+}
+function parseNumber(envValue, fallback, min, max) {
+    if (!envValue) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(envValue, 10);
+    if (!Number.isFinite(parsed) || parsed < min || parsed > max) {
+        return fallback;
+    }
+    return parsed;
+}
+function parseRepos(envValue) {
+    const entries = (envValue ?? "").split(",").map((value) => value.trim()).filter(Boolean);
+    if (entries.length === 0) {
+        return [...DEFAULTS.sourceRepos];
+    }
+    const validated = [];
+    for (const entry of entries) {
+        const parsed = parseRepoUrl(entry);
+        if (parsed) {
+            validated.push(parsed);
+        }
+    }
+    return validated.length > 0 ? validated : [...DEFAULTS.sourceRepos];
+}
+function parseBoolean(envValue, fallback) {
+    if (!envValue) {
+        return fallback;
+    }
+    const normalized = envValue.trim().toLowerCase();
+    if (normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on") {
+        return true;
+    }
+    if (normalized === "0" || normalized === "false" || normalized === "no" || normalized === "off") {
+        return false;
+    }
+    return fallback;
+}
+function parseRepoUrl(raw) {
+    try {
+        const parsed = new URL(raw);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+            return undefined;
+        }
+        return raw;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseMappingSourcePriority(envValue) {
+    const normalized = envValue?.trim().toLowerCase();
+    if (normalized === "maven-first") {
+        return "maven-first";
+    }
+    if (normalized === "loom-first") {
+        return "loom-first";
+    }
+    return DEFAULTS.mappingSourcePriority;
+}
+function parseOptionalJarPath(envValue, field) {
+    if (!envValue) {
+        return undefined;
+    }
+    const trimmed = envValue.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return normalizePath(trimmed, field);
+}
+function parseVineflowerPath(envValue) {
+    return parseOptionalJarPath(envValue, "MCP_VINEFLOWER_JAR_PATH");
+}
+function buildArtifactsDirectory(cacheDir) {
+    const input = `${cacheDir}/source-cache.db`;
+    return normalizePath(input, "MCP_SQLITE_PATH");
+}
+export function loadConfig() {
+    const cacheDir = normalizePath(process.env.MCP_CACHE_DIR ?? DEFAULTS.cacheDir, "MCP_CACHE_DIR");
+    const localM2Path = normalizePath(process.env.MCP_LOCAL_M2 ?? DEFAULTS.localM2Path, "MCP_LOCAL_M2");
+    const sourceRepos = parseRepos(process.env.MCP_SOURCE_REPOS);
+    return {
+        cacheDir,
+        sqlitePath: normalizePath(process.env.MCP_SQLITE_PATH ?? buildArtifactsDirectory(cacheDir), "MCP_SQLITE_PATH"),
+        sourceRepos,
+        localM2Path,
+        vineflowerJarPath: parseVineflowerPath(process.env.MCP_VINEFLOWER_JAR_PATH),
+        indexedSearchEnabled: parseBoolean(process.env.MCP_ENABLE_INDEXED_SEARCH, DEFAULTS.indexedSearchEnabled),
+        mappingSourcePriority: parseMappingSourcePriority(process.env.MCP_MAPPING_SOURCE_PRIORITY),
+        maxContentBytes: parseNumber(process.env.MCP_MAX_CONTENT_BYTES, DEFAULTS.maxContentBytes, MAX_BYTES_LOWER_BOUND, Number.MAX_SAFE_INTEGER),
+        maxSearchHits: parseNumber(process.env.MCP_MAX_SEARCH_HITS, DEFAULTS.maxSearchHits, MAX_SEARCH_HITS_LOWER_BOUND, MAX_SEARCH_HITS_UPPER_BOUND),
+        maxArtifacts: parseNumber(process.env.MCP_MAX_ARTIFACTS, DEFAULTS.maxArtifacts, MAX_ARTIFACTS_LOWER_BOUND, MAX_ARTIFACTS_UPPER_BOUND),
+        maxCacheBytes: parseNumber(process.env.MCP_MAX_CACHE_BYTES, DEFAULTS.maxCacheBytes, MAX_CACHE_BYTES_LOWER_BOUND, Number.MAX_SAFE_INTEGER),
+        fetchTimeoutMs: parseNumber(process.env.MCP_FETCH_TIMEOUT_MS, DEFAULTS.fetchTimeoutMs, TIMEOUT_LOWER_BOUND_MS, Number.MAX_SAFE_INTEGER),
+        fetchRetries: parseNumber(process.env.MCP_FETCH_RETRIES, DEFAULTS.fetchRetries, MAX_RETRIES_LOWER_BOUND, MAX_RETRIES_UPPER_BOUND),
+        searchScanPageSize: parseNumber(process.env.MCP_SEARCH_SCAN_PAGE_SIZE, DEFAULTS.searchScanPageSize, SEARCH_SCAN_PAGE_SIZE_LOWER_BOUND, SEARCH_SCAN_PAGE_SIZE_UPPER_BOUND),
+        indexInsertChunkSize: parseNumber(process.env.MCP_INDEX_INSERT_CHUNK_SIZE, DEFAULTS.indexInsertChunkSize, INDEX_INSERT_CHUNK_SIZE_LOWER_BOUND, INDEX_INSERT_CHUNK_SIZE_UPPER_BOUND),
+        maxMappingGraphCache: parseNumber(process.env.MCP_CACHE_GRAPH_MAX, DEFAULTS.maxMappingGraphCache, CACHE_ENTRIES_LOWER_BOUND, CACHE_ENTRIES_UPPER_BOUND),
+        maxSignatureCache: parseNumber(process.env.MCP_CACHE_SIGNATURE_MAX, DEFAULTS.maxSignatureCache, CACHE_ENTRIES_LOWER_BOUND, CACHE_ENTRIES_UPPER_BOUND),
+        maxVersionDetailCache: parseNumber(process.env.MCP_CACHE_VERSION_DETAIL_MAX, DEFAULTS.maxVersionDetailCache, CACHE_ENTRIES_LOWER_BOUND, CACHE_ENTRIES_UPPER_BOUND),
+        maxNbtInputBytes: parseNumber(process.env.MCP_MAX_NBT_INPUT_BYTES, DEFAULTS.maxNbtInputBytes, MAX_BYTES_LOWER_BOUND, Number.MAX_SAFE_INTEGER),
+        maxNbtInflatedBytes: parseNumber(process.env.MCP_MAX_NBT_INFLATED_BYTES, DEFAULTS.maxNbtInflatedBytes, MAX_BYTES_LOWER_BOUND, Number.MAX_SAFE_INTEGER),
+        maxNbtResponseBytes: parseNumber(process.env.MCP_MAX_NBT_RESPONSE_BYTES, DEFAULTS.maxNbtResponseBytes, MAX_BYTES_LOWER_BOUND, Number.MAX_SAFE_INTEGER),
+        tinyRemapperJarPath: parseOptionalJarPath(process.env.MCP_TINY_REMAPPER_JAR_PATH, "MCP_TINY_REMAPPER_JAR_PATH"),
+        remapTimeoutMs: parseNumber(process.env.MCP_REMAP_TIMEOUT_MS, DEFAULTS.remapTimeoutMs, TIMEOUT_LOWER_BOUND_MS, Number.MAX_SAFE_INTEGER),
+        remapMaxMemoryMb: parseNumber(process.env.MCP_REMAP_MAX_MEMORY_MB, DEFAULTS.remapMaxMemoryMb, 64, Number.MAX_SAFE_INTEGER)
+    };
+}
+export function stableArtifactId(parts) {
+    const normalizer = parts
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .join("|");
+    return createHash("sha256").update(normalizer).digest("hex");
+}
+export { DEFAULTS };
+//# sourceMappingURL=config.js.map

package/dist/decompiler/vineflower.d.ts

@@ -0,0 +1,15 @@
+export interface DecompileResult {
+    outputDir: string;
+    javaFiles: Array<{
+        filePath: string;
+        content: string;
+    }>;
+}
+interface DecompileBinaryOptions {
+    vineflowerJarPath?: string;
+    timeoutMs?: number;
+    signature?: string;
+    artifactIdCandidate?: string;
+}
+export declare function decompileBinaryJar(binaryJarPath: string, cacheDir: string, options?: DecompileBinaryOptions): Promise<DecompileResult>;
+export {};

package/dist/decompiler/vineflower.js

@@ -0,0 +1,185 @@
+import { access, constants } from "node:fs/promises";
+import { mkdirSync, readdirSync, statSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { basename, join, relative, sep } from "node:path";
+import { createError, ERROR_CODES, isAppError } from "../errors.js";
+import { assertJavaAvailable, runJavaProcess } from "../java-process.js";
+import { log } from "../logger.js";
+const DEFAULT_TIMEOUT_MS = 120_000;
+function emitDecompileLog(event, details) {
+    log(event === "decompile.error" ? "error" : "info", event, details);
+}
+function extractStderrTail(error) {
+    if (!isAppError(error)) {
+        return undefined;
+    }
+    const tail = error.details?.stderrTail;
+    return typeof tail === "string" ? tail : undefined;
+}
+function normalizeBinaryJarPath(binaryJarPath) {
+    const normalized = binaryJarPath.trim();
+    if (!normalized.toLowerCase().endsWith(".jar")) {
+        throw createError({
+            code: ERROR_CODES.DECOMPILER_UNAVAILABLE,
+            message: "binaryJarPath must point to a .jar file.",
+            details: { binaryJarPath }
+        });
+    }
+    return normalized;
+}
+function normalizeOutputPath(root, childPath) {
+    return relative(root, childPath).split(sep).join("/");
+}
+async function assertVineflowerAvailable(vineflowerJarPath) {
+    try {
+        await access(vineflowerJarPath, constants.F_OK | constants.R_OK);
+    }
+    catch {
+        throw createError({
+            code: ERROR_CODES.DECOMPILER_UNAVAILABLE,
+            message: "Vineflower jar is not available.",
+            details: { vineflowerJarPath }
+        });
+    }
+}
+function collectJavaFilesSync(baseDir, currentDir = "") {
+    const absoluteBase = currentDir ? join(baseDir, currentDir) : baseDir;
+    const entries = readdirSync(absoluteBase, { withFileTypes: true });
+    const result = [];
+    for (const entry of entries) {
+        const next = currentDir ? join(currentDir, entry.name) : entry.name;
+        if (entry.isDirectory()) {
+            result.push(...collectJavaFilesSync(baseDir, next));
+            continue;
+        }
+        if (entry.isFile() && entry.name.endsWith(".java")) {
+            result.push(next);
+        }
+    }
+    return result;
+}
+async function collectJavaFiles(baseDir) {
+    try {
+        const fastGlobModule = (await import("fast-glob"));
+        const sync = fastGlobModule.default?.sync;
+        if (typeof sync === "function") {
+            return sync("**/*.java", { cwd: baseDir, onlyFiles: true });
+        }
+    }
+    catch {
+        // optional dependency: fallback to recursive traversal
+    }
+    return collectJavaFilesSync(baseDir).map((candidate) => candidate.split(sep).join("/"));
+}
+function readFileTreeText(filePath) {
+    return new Promise((resolve, reject) => {
+        import("node:fs/promises")
+            .then((fs) => fs.readFile(filePath, "utf8"))
+            .then(resolve)
+            .catch(reject);
+    });
+}
+function decompileOutputDir(cacheDir, binaryJarPath, signature) {
+    const digest = createHash("sha256").update(binaryJarPath).update(signature).digest("hex");
+    return join(cacheDir, "decompiled", digest);
+}
+async function runVineflower(vineflowerJarPath, binaryJarPath, outputDir, timeoutMs) {
+    const result = await runJavaProcess({
+        jarPath: vineflowerJarPath,
+        args: [binaryJarPath, outputDir, "-din=1", "-rbr=1", "-dgs=1"],
+        timeoutMs,
+        normalizePathArgs: true
+    });
+    if (result.exitCode !== 0) {
+        throw createError({
+            code: ERROR_CODES.DECOMPILER_FAILED,
+            message: `Vineflower exited with code ${result.exitCode}.`,
+            details: {
+                binaryJarPath,
+                outputDir,
+                code: result.exitCode,
+                stdout: result.stdoutTail,
+                stderrTail: result.stderrTail
+            }
+        });
+    }
+}
+export async function decompileBinaryJar(binaryJarPath, cacheDir, options) {
+    const normalizedBinaryJarPath = normalizeBinaryJarPath(binaryJarPath);
+    if (!options?.vineflowerJarPath) {
+        throw createError({
+            code: ERROR_CODES.DECOMPILER_UNAVAILABLE,
+            message: "Vineflower JAR path was not resolved. Set MCP_VINEFLOWER_JAR_PATH or ensure auto-download can reach GitHub."
+        });
+    }
+    const startedAt = Date.now();
+    emitDecompileLog("decompile.start", {
+        binaryJarPath: normalizedBinaryJarPath,
+        artifactIdCandidate: options.artifactIdCandidate
+    });
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const signature = options.signature ?? basename(normalizedBinaryJarPath);
+    const outputDir = decompileOutputDir(cacheDir, normalizedBinaryJarPath, signature).replace(/[/\\]$/, "");
+    try {
+        mkdirSync(outputDir, { recursive: true });
+        await assertVineflowerAvailable(options.vineflowerJarPath);
+        await assertJavaAvailable();
+        if (statSync(outputDir, { throwIfNoEntry: false })) {
+            const existingJavaFiles = await collectJavaFiles(outputDir);
+            if (existingJavaFiles.length > 0) {
+                const results = await Promise.all(existingJavaFiles.map(async (candidate) => {
+                    const abs = join(outputDir, candidate);
+                    return {
+                        filePath: normalizeOutputPath(outputDir, abs),
+                        content: await readFileTreeText(abs)
+                    };
+                }));
+                emitDecompileLog("decompile.done", {
+                    durationMs: Date.now() - startedAt,
+                    artifactIdCandidate: options.artifactIdCandidate,
+                    javaFileCount: results.length
+                });
+                return {
+                    outputDir,
+                    javaFiles: results
+                };
+            }
+        }
+        await runVineflower(options.vineflowerJarPath, normalizedBinaryJarPath, outputDir, timeoutMs);
+        const javaFileNames = await collectJavaFiles(outputDir);
+        if (javaFileNames.length === 0) {
+            throw createError({
+                code: ERROR_CODES.DECOMPILER_FAILED,
+                message: "No Java files were produced by decompilation.",
+                details: { binaryJarPath: normalizedBinaryJarPath, outputDir }
+            });
+        }
+        const javaFiles = await Promise.all(javaFileNames.map(async (candidate) => {
+            const abs = join(outputDir, candidate);
+            return {
+                filePath: normalizeOutputPath(outputDir, abs),
+                content: await readFileTreeText(abs)
+            };
+        }));
+        emitDecompileLog("decompile.done", {
+            durationMs: Date.now() - startedAt,
+            artifactIdCandidate: options.artifactIdCandidate,
+            javaFileCount: javaFiles.length
+        });
+        return {
+            outputDir,
+            javaFiles
+        };
+    }
+    catch (error) {
+        emitDecompileLog("decompile.error", {
+            durationMs: Date.now() - startedAt,
+            binaryJarPath: normalizedBinaryJarPath,
+            artifactIdCandidate: options.artifactIdCandidate,
+            code: isAppError(error) ? error.code : ERROR_CODES.DECOMPILER_FAILED,
+            stderrTail: extractStderrTail(error)
+        });
+        throw error;
+    }
+}
+//# sourceMappingURL=vineflower.js.map

package/dist/errors.d.ts

@@ -0,0 +1,50 @@
+export declare const ERROR_CODES: {
+    readonly INVALID_INPUT: "ERR_INVALID_INPUT";
+    readonly SOURCE_NOT_FOUND: "ERR_SOURCE_NOT_FOUND";
+    readonly REPO_FETCH_FAILED: "ERR_REPO_FETCH_FAILED";
+    readonly COORDINATE_PARSE_FAILED: "ERR_COORDINATE_PARSE_FAILED";
+    readonly DB_FAILURE: "ERR_DB_FAILURE";
+    readonly DECOMPILER_UNAVAILABLE: "ERR_DECOMPILER_UNAVAILABLE";
+    readonly DECOMPILER_FAILED: "ERR_DECOMPILER_FAILED";
+    readonly FILE_NOT_FOUND: "ERR_FILE_NOT_FOUND";
+    readonly LIMIT_EXCEEDED: "ERR_LIMIT_EXCEEDED";
+    readonly INVALID_LINE_RANGE: "ERR_INVALID_LINE_RANGE";
+    readonly ARTIFACT_RESOLUTION_FAILED: "ERR_ARTIFACT_RESOLUTION_FAILED";
+    readonly MAPPING_NOT_APPLIED: "ERR_MAPPING_NOT_APPLIED";
+    readonly PROVENANCE_INCOMPLETE: "ERR_PROVENANCE_INCOMPLETE";
+    readonly CONTEXT_UNRESOLVED: "ERR_CONTEXT_UNRESOLVED";
+    readonly JAR_NOT_FOUND: "ERR_JAR_NOT_FOUND";
+    readonly VERSION_NOT_FOUND: "ERR_VERSION_NOT_FOUND";
+    readonly CLASS_NOT_FOUND: "ERR_CLASS_NOT_FOUND";
+    readonly NAMESPACE_MISMATCH: "ERR_NAMESPACE_MISMATCH";
+    readonly MAPPING_UNAVAILABLE: "ERR_MAPPING_UNAVAILABLE";
+    readonly DECOMPILE_DISABLED: "ERR_DECOMPILE_DISABLED";
+    readonly NBT_PARSE_FAILED: "ERR_NBT_PARSE_FAILED";
+    readonly NBT_INVALID_TYPED_JSON: "ERR_NBT_INVALID_TYPED_JSON";
+    readonly JSON_PATCH_INVALID: "ERR_JSON_PATCH_INVALID";
+    readonly JSON_PATCH_CONFLICT: "ERR_JSON_PATCH_CONFLICT";
+    readonly NBT_ENCODE_FAILED: "ERR_NBT_ENCODE_FAILED";
+    readonly NBT_UNSUPPORTED_FEATURE: "ERR_NBT_UNSUPPORTED_FEATURE";
+    readonly REGISTRY_GENERATION_FAILED: "ERR_REGISTRY_GENERATION_FAILED";
+    readonly JAVA_UNAVAILABLE: "ERR_JAVA_UNAVAILABLE";
+    readonly JAVA_PROCESS_FAILED: "ERR_JAVA_PROCESS_FAILED";
+    readonly REMAP_FAILED: "ERR_REMAP_FAILED";
+    readonly REMAPPER_UNAVAILABLE: "ERR_REMAPPER_UNAVAILABLE";
+    readonly INTERNAL: "ERR_INTERNAL";
+};
+export type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES];
+export interface ErrorDetails {
+    [key: string]: unknown;
+}
+export interface ErrorPayload {
+    code: ErrorCode;
+    message: string;
+    details?: ErrorDetails;
+}
+export declare class AppError extends Error {
+    readonly code: ErrorCode;
+    readonly details?: ErrorDetails;
+    constructor(payload: ErrorPayload);
+}
+export declare const createError: (payload: ErrorPayload) => AppError;
+export declare const isAppError: (value: unknown) => value is AppError;

package/dist/errors.js

@@ -0,0 +1,49 @@
+export const ERROR_CODES = {
+    INVALID_INPUT: "ERR_INVALID_INPUT",
+    SOURCE_NOT_FOUND: "ERR_SOURCE_NOT_FOUND",
+    REPO_FETCH_FAILED: "ERR_REPO_FETCH_FAILED",
+    COORDINATE_PARSE_FAILED: "ERR_COORDINATE_PARSE_FAILED",
+    DB_FAILURE: "ERR_DB_FAILURE",
+    DECOMPILER_UNAVAILABLE: "ERR_DECOMPILER_UNAVAILABLE",
+    DECOMPILER_FAILED: "ERR_DECOMPILER_FAILED",
+    FILE_NOT_FOUND: "ERR_FILE_NOT_FOUND",
+    LIMIT_EXCEEDED: "ERR_LIMIT_EXCEEDED",
+    INVALID_LINE_RANGE: "ERR_INVALID_LINE_RANGE",
+    ARTIFACT_RESOLUTION_FAILED: "ERR_ARTIFACT_RESOLUTION_FAILED",
+    MAPPING_NOT_APPLIED: "ERR_MAPPING_NOT_APPLIED",
+    PROVENANCE_INCOMPLETE: "ERR_PROVENANCE_INCOMPLETE",
+    CONTEXT_UNRESOLVED: "ERR_CONTEXT_UNRESOLVED",
+    JAR_NOT_FOUND: "ERR_JAR_NOT_FOUND",
+    VERSION_NOT_FOUND: "ERR_VERSION_NOT_FOUND",
+    CLASS_NOT_FOUND: "ERR_CLASS_NOT_FOUND",
+    NAMESPACE_MISMATCH: "ERR_NAMESPACE_MISMATCH",
+    MAPPING_UNAVAILABLE: "ERR_MAPPING_UNAVAILABLE",
+    DECOMPILE_DISABLED: "ERR_DECOMPILE_DISABLED",
+    NBT_PARSE_FAILED: "ERR_NBT_PARSE_FAILED",
+    NBT_INVALID_TYPED_JSON: "ERR_NBT_INVALID_TYPED_JSON",
+    JSON_PATCH_INVALID: "ERR_JSON_PATCH_INVALID",
+    JSON_PATCH_CONFLICT: "ERR_JSON_PATCH_CONFLICT",
+    NBT_ENCODE_FAILED: "ERR_NBT_ENCODE_FAILED",
+    NBT_UNSUPPORTED_FEATURE: "ERR_NBT_UNSUPPORTED_FEATURE",
+    REGISTRY_GENERATION_FAILED: "ERR_REGISTRY_GENERATION_FAILED",
+    JAVA_UNAVAILABLE: "ERR_JAVA_UNAVAILABLE",
+    JAVA_PROCESS_FAILED: "ERR_JAVA_PROCESS_FAILED",
+    REMAP_FAILED: "ERR_REMAP_FAILED",
+    REMAPPER_UNAVAILABLE: "ERR_REMAPPER_UNAVAILABLE",
+    INTERNAL: "ERR_INTERNAL"
+};
+export class AppError extends Error {
+    code;
+    details;
+    constructor(payload) {
+        super(payload.message);
+        this.name = "AppError";
+        this.code = payload.code;
+        this.details = payload.details;
+    }
+}
+export const createError = (payload) => new AppError(payload);
+export const isAppError = (value) => {
+    return value instanceof Error && value.code !== undefined;
+};
+//# sourceMappingURL=errors.js.map

package/dist/hash.d.ts

@@ -0,0 +1 @@
+export declare function computeFileSha1(filePath: string): Promise<string>;

package/dist/hash.js

@@ -0,0 +1,12 @@
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+export async function computeFileSha1(filePath) {
+    return new Promise((resolve, reject) => {
+        const hash = createHash("sha1");
+        const stream = createReadStream(filePath);
+        stream.on("data", (chunk) => hash.update(chunk));
+        stream.on("end", () => resolve(hash.digest("hex")));
+        stream.on("error", reject);
+    });
+}
+//# sourceMappingURL=hash.js.map

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { SourceService } from "./source-service.js";
+declare const SERVER_VERSION: string;
+declare const server: import("mcp-use/server").McpServerInstance<false>;
+declare const config: import("./types.js").Config;
+declare const sourceService: SourceService;
+export declare function startServer(): void;
+export { server, sourceService, config, SERVER_VERSION };