@adhisang/minecraft-modding-mcp 1.0.0

package/dist/mod-remap-service.js

@@ -0,0 +1,186 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, statSync, rmSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
+import { createError, ERROR_CODES } from "./errors.js";
+import { log } from "./logger.js";
+import { resolveTinyMappingFile } from "./mapping-service.js";
+import { resolveMojangTinyFile } from "./mojang-tiny-mapping-service.js";
+import { analyzeModJar } from "./mod-analyzer.js";
+import { normalizePathForHost } from "./path-converter.js";
+import { remapJar } from "./tiny-remapper-service.js";
+import { resolveTinyRemapperJar } from "./tiny-remapper-resolver.js";
+function normalizeTargetNamespace(target) {
+    return target === "yarn" ? "yarn" : "mojang";
+}
+function sourceNamespaceForLoader(loader) {
+    if (loader === "fabric" || loader === "quilt") {
+        return "intermediary";
+    }
+    throw createError({
+        code: ERROR_CODES.REMAP_FAILED,
+        message: `Unsupported mod loader for remapping: "${loader}". Only Fabric and Quilt mods are supported.`,
+        details: { loader }
+    });
+}
+function extractMinecraftVersion(dependencies) {
+    if (!dependencies) {
+        return undefined;
+    }
+    const mcDep = dependencies.find((dep) => dep.modId === "minecraft");
+    if (!mcDep?.versionRange) {
+        return undefined;
+    }
+    // Try to extract exact version from ranges like ">=1.20.4", "~1.20.4", "1.20.4", "^1.20.4"
+    const match = mcDep.versionRange.match(/(\d+\.\d+(?:\.\d+)?)/);
+    return match?.[1];
+}
+function buildCacheKey(inputJar, fromNamespace, targetNamespace, mcVersion) {
+    const stat = statSync(inputJar, { throwIfNoEntry: false });
+    const signature = stat ? `${stat.mtimeMs}:${stat.size}` : "unknown";
+    return createHash("sha256")
+        .update(`${inputJar}|${signature}|${fromNamespace}|${targetNamespace}|${mcVersion}`)
+        .digest("hex");
+}
+export async function remapModJar(input, config) {
+    const startedAt = Date.now();
+    const warnings = [];
+    // 1. Normalize input JAR path
+    const normalizedInput = normalizePathForHost(input.inputJar, undefined, "inputJar");
+    if (!normalizedInput.toLowerCase().endsWith(".jar")) {
+        throw createError({
+            code: ERROR_CODES.INVALID_INPUT,
+            message: "inputJar must point to a .jar file.",
+            details: { inputJar: normalizedInput }
+        });
+    }
+    if (!existsSync(normalizedInput)) {
+        throw createError({
+            code: ERROR_CODES.JAR_NOT_FOUND,
+            message: `Input JAR not found: ${normalizedInput}`,
+            details: { inputJar: normalizedInput }
+        });
+    }
+    const resolvedTargetNamespace = normalizeTargetNamespace(input.targetMapping);
+    // 2. Analyze mod metadata
+    const analysis = await analyzeModJar(normalizedInput);
+    if (analysis.loader === "unknown") {
+        throw createError({
+            code: ERROR_CODES.REMAP_FAILED,
+            message: "Could not detect mod loader. Only Fabric and Quilt mods are supported.",
+            details: { inputJar: normalizedInput }
+        });
+    }
+    const fromNamespace = sourceNamespaceForLoader(analysis.loader);
+    // 3. Determine MC version
+    const mcVersion = input.mcVersion ?? extractMinecraftVersion(analysis.dependencies);
+    if (!mcVersion) {
+        throw createError({
+            code: ERROR_CODES.INVALID_INPUT,
+            message: "Could not determine Minecraft version from mod metadata. Please provide mcVersion explicitly.",
+            details: {
+                inputJar: normalizedInput,
+                loader: analysis.loader,
+                modId: analysis.modId
+            }
+        });
+    }
+    // 4. Check cache after mapping context is known
+    const cacheKey = buildCacheKey(normalizedInput, fromNamespace, resolvedTargetNamespace, mcVersion);
+    const cacheDir = join(config.cacheDir, "remapped-mods");
+    mkdirSync(cacheDir, { recursive: true });
+    const cachedOutput = join(cacheDir, `${cacheKey}.jar`);
+    if (existsSync(cachedOutput)) {
+        const outputJar = input.outputJar
+            ? normalizePathForHost(input.outputJar, undefined, "outputJar")
+            : cachedOutput;
+        if (outputJar !== cachedOutput) {
+            const { copyFileSync } = await import("node:fs");
+            mkdirSync(dirname(outputJar), { recursive: true });
+            copyFileSync(cachedOutput, outputJar);
+        }
+        log("info", "remap.cache-hit", { inputJar: normalizedInput, outputJar });
+        return {
+            outputJar,
+            mcVersion,
+            fromMapping: fromNamespace,
+            targetMapping: input.targetMapping,
+            resolvedTargetNamespace,
+            durationMs: Date.now() - startedAt,
+            warnings: ["Result served from cache."]
+        };
+    }
+    // 5. Resolve tiny-remapper
+    const tinyRemapperJar = await resolveTinyRemapperJar(config.cacheDir, config.tinyRemapperJarPath);
+    // 6. Resolve mapping file and remap
+    let mappingsFile;
+    let toNamespace;
+    if (resolvedTargetNamespace === "yarn") {
+        mappingsFile = await resolveTinyMappingFile(mcVersion, "yarn", config.cacheDir);
+        toNamespace = "named";
+    }
+    else {
+        const mojangTiny = await resolveMojangTinyFile(mcVersion, config);
+        mappingsFile = mojangTiny.path;
+        toNamespace = "mojang";
+        warnings.push(...mojangTiny.warnings);
+    }
+    // 7. Determine output path
+    const modId = analysis.modId ?? "mod";
+    const modVersion = analysis.modVersion ?? "0";
+    const defaultOutputName = `${modId}-${modVersion}-${input.targetMapping}.jar`;
+    const outputJar = input.outputJar
+        ? normalizePathForHost(input.outputJar, undefined, "outputJar")
+        : join(dirname(normalizedInput), defaultOutputName);
+    mkdirSync(dirname(outputJar), { recursive: true });
+    // 8. Use temporary directory for intermediate work
+    const tempDir = join(tmpdir(), `mcp-remap-${cacheKey.slice(0, 12)}`);
+    mkdirSync(tempDir, { recursive: true });
+    try {
+        const tempOutput = join(tempDir, "remapped.jar");
+        await remapJar(tinyRemapperJar, {
+            inputJar: normalizedInput,
+            outputJar: tempOutput,
+            mappingsFile,
+            fromNamespace,
+            toNamespace,
+            timeoutMs: config.remapTimeoutMs,
+            maxMemoryMb: config.remapMaxMemoryMb
+        });
+        // Copy to final destination and cache
+        const { copyFileSync } = await import("node:fs");
+        copyFileSync(tempOutput, outputJar);
+        if (outputJar !== cachedOutput) {
+            mkdirSync(dirname(cachedOutput), { recursive: true });
+            copyFileSync(tempOutput, cachedOutput);
+        }
+        const durationMs = Date.now() - startedAt;
+        log("info", "remap.pipeline.done", {
+            inputJar: normalizedInput,
+            outputJar,
+            mcVersion,
+            fromMapping: fromNamespace,
+            targetMapping: input.targetMapping,
+            durationMs
+        });
+        return {
+            outputJar,
+            mcVersion,
+            fromMapping: fromNamespace,
+            targetMapping: input.targetMapping,
+            resolvedTargetNamespace,
+            durationMs,
+            warnings
+        };
+    }
+    finally {
+        // Cleanup temporary directory
+        try {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch {
+            // best-effort cleanup
+        }
+    }
+}
+//# sourceMappingURL=mod-remap-service.js.map

package/dist/mod-search-service.d.ts

@@ -0,0 +1,28 @@
+import { ModDecompileService } from "./mod-decompile-service.js";
+export type SearchModSourceSearchType = "class" | "method" | "field" | "content" | "all";
+export type SearchModSourceInput = {
+    jarPath: string;
+    query: string;
+    searchType?: SearchModSourceSearchType;
+    limit?: number;
+};
+export type SearchModSourceHit = {
+    type: "class" | "method" | "field" | "content";
+    name: string;
+    file: string;
+    line?: number;
+    context?: string;
+};
+export type SearchModSourceOutput = {
+    query: string;
+    searchType: SearchModSourceSearchType;
+    hits: SearchModSourceHit[];
+    totalHits: number;
+    truncated: boolean;
+    warnings: string[];
+};
+export declare class ModSearchService {
+    private readonly modDecompileService;
+    constructor(modDecompileService: ModDecompileService);
+    searchModSource(input: SearchModSourceInput): Promise<SearchModSourceOutput>;
+}

package/dist/mod-search-service.js

@@ -0,0 +1,174 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createError, ERROR_CODES } from "./errors.js";
+import { log } from "./logger.js";
+import { validateAndNormalizeJarPath } from "./path-resolver.js";
+const DEFAULT_LIMIT = 50;
+const MAX_LIMIT = 200;
+const MAX_QUERY_LENGTH = 200;
+const CONTEXT_LINES = 1;
+const METHOD_PATTERN = /^\s*(public|private|protected)\s+.*\(/;
+const FIELD_PATTERN = /^\s*(public|private|protected)\s+(?:static\s+)?(?:final\s+)?[\w<>,\[\]?]+\s+\w+\s*[;=]/;
+function buildRegex(query) {
+    try {
+        return new RegExp(query, "gi");
+    }
+    catch {
+        // If the query is not valid regex, escape it and use as literal
+        const escaped = query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        try {
+            return new RegExp(escaped, "gi");
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+function classifyLine(line) {
+    if (METHOD_PATTERN.test(line))
+        return "method";
+    if (FIELD_PATTERN.test(line))
+        return "field";
+    return "content";
+}
+function extractContext(lines, lineIndex) {
+    const start = Math.max(0, lineIndex - CONTEXT_LINES);
+    const end = Math.min(lines.length - 1, lineIndex + CONTEXT_LINES);
+    return lines.slice(start, end + 1).join("\n");
+}
+function filePathToClassName(filePath) {
+    return filePath.replace(/\.java$/, "").replaceAll("/", ".");
+}
+export class ModSearchService {
+    modDecompileService;
+    constructor(modDecompileService) {
+        this.modDecompileService = modDecompileService;
+    }
+    async searchModSource(input) {
+        const jarPath = validateAndNormalizeJarPath(input.jarPath);
+        const query = input.query.trim();
+        const searchType = input.searchType ?? "all";
+        const requestedLimit = Math.max(1, Math.trunc(input.limit ?? DEFAULT_LIMIT));
+        const limit = Math.min(requestedLimit, MAX_LIMIT);
+        if (!query) {
+            throw createError({
+                code: ERROR_CODES.INVALID_INPUT,
+                message: "query must be non-empty."
+            });
+        }
+        if (query.length > MAX_QUERY_LENGTH) {
+            throw createError({
+                code: ERROR_CODES.INVALID_INPUT,
+                message: `query exceeds max length of ${MAX_QUERY_LENGTH} characters.`,
+                details: { queryLength: query.length, maxLength: MAX_QUERY_LENGTH }
+            });
+        }
+        const regex = buildRegex(query);
+        if (!regex) {
+            throw createError({
+                code: ERROR_CODES.INVALID_INPUT,
+                message: `Invalid search query: "${query}".`,
+                details: { query }
+            });
+        }
+        const warnings = [];
+        if (requestedLimit > MAX_LIMIT) {
+            warnings.push(`limit was clamped to ${MAX_LIMIT} from ${requestedLimit}.`);
+        }
+        const startedAt = Date.now();
+        const decompileResult = await this.modDecompileService.decompileModJar({ jarPath });
+        const outputDir = decompileResult.outputDir;
+        warnings.push(...decompileResult.warnings);
+        const classNames = decompileResult.files ?? [];
+        const hits = [];
+        let totalHits = 0;
+        let reachedLimit = false;
+        for (const className of classNames) {
+            if (hits.length >= limit) {
+                reachedLimit = true;
+                break;
+            }
+            const filePath = className.replaceAll(".", "/") + ".java";
+            // Class name search: check if the simple class name matches
+            if (searchType === "class" || searchType === "all") {
+                const simpleClassName = className.split(".").pop() ?? className;
+                regex.lastIndex = 0;
+                if (regex.test(simpleClassName)) {
+                    totalHits++;
+                    if (hits.length < limit) {
+                        hits.push({
+                            type: "class",
+                            name: className,
+                            file: filePath
+                        });
+                    }
+                    // If searching only classes, skip content search for this file
+                    if (searchType === "class")
+                        continue;
+                }
+            }
+            // Content/method/field search: read and scan the file
+            if (searchType === "method" || searchType === "field" || searchType === "content" || searchType === "all") {
+                let content;
+                try {
+                    content = readFileSync(join(outputDir, filePath), "utf8");
+                }
+                catch {
+                    // File might not exist at the expected path, skip
+                    continue;
+                }
+                const lines = content.split("\n");
+                for (let i = 0; i < lines.length; i++) {
+                    if (hits.length >= limit) {
+                        reachedLimit = true;
+                        break;
+                    }
+                    regex.lastIndex = 0;
+                    if (!regex.test(lines[i]))
+                        continue;
+                    const lineType = classifyLine(lines[i]);
+                    // Filter by search type
+                    if (searchType !== "all" && searchType !== lineType)
+                        continue;
+                    totalHits++;
+                    if (hits.length < limit) {
+                        hits.push({
+                            type: lineType,
+                            name: lineType === "content" ? className : extractSymbolName(lines[i], lineType),
+                            file: filePath,
+                            line: i + 1,
+                            context: extractContext(lines, i)
+                        });
+                    }
+                }
+            }
+        }
+        log("info", "mod-search.done", {
+            jarPath,
+            query,
+            searchType,
+            hitCount: hits.length,
+            durationMs: Date.now() - startedAt
+        });
+        return {
+            query,
+            searchType,
+            hits,
+            totalHits,
+            truncated: reachedLimit,
+            warnings
+        };
+    }
+}
+function extractSymbolName(line, type) {
+    const trimmed = line.trim();
+    if (type === "method") {
+        // Extract method name: last identifier before '('
+        const match = trimmed.match(/(\w+)\s*\(/);
+        return match?.[1] ?? trimmed.slice(0, 60);
+    }
+    // Extract field name: last identifier before '=' or ';'
+    const match = trimmed.match(/(\w+)\s*[;=]/);
+    return match?.[1] ?? trimmed.slice(0, 60);
+}
+//# sourceMappingURL=mod-search-service.js.map

package/dist/mojang-tiny-mapping-service.d.ts

@@ -0,0 +1,13 @@
+import type { Config } from "./types.js";
+import { VersionService } from "./version-service.js";
+type VersionMappingsResolver = Pick<VersionService, "resolveVersionMappings">;
+export interface ResolveMojangTinyDeps {
+    fetchFn?: typeof fetch;
+    versionService?: VersionMappingsResolver;
+}
+export interface ResolveMojangTinyResult {
+    path: string;
+    warnings: string[];
+}
+export declare function resolveMojangTinyFile(version: string, config: Config, deps?: ResolveMojangTinyDeps): Promise<ResolveMojangTinyResult>;
+export {};