@adhisang/minecraft-modding-mcp 3.1.1 → 4.0.0

package/dist/source-jar-reader.js

@@ -9,7 +9,7 @@ function toErrorMessage(value) {
     }
     return String(value);
 }
-function hasJavaSourceExtension(entryPath) {
+export function hasJavaSourceExtension(entryPath) {
     const suffix = ".java";
     if (entryPath.length < suffix.length) {
         return false;
@@ -144,6 +144,22 @@ export async function listJavaEntries(jarPath) {
     const entries = await listJarEntries(jarPath);
     return entries.filter((entry) => hasJavaSourceExtension(entry) && isSecureJarEntryPath(entry));
 }
+export async function hasAnyJarEntry(jarPath, predicate) {
+    return withZipFile(jarPath, async (zipFile) => {
+        while (true) {
+            const entry = await readNextEntry(zipFile);
+            if (!entry) {
+                return false;
+            }
+            if (!isSecureJarEntryPath(entry.fileName)) {
+                continue;
+            }
+            if (predicate(entry.fileName)) {
+                return true;
+            }
+        }
+    });
+}
 export async function readJarEntryAsUtf8(jarPath, entryPath) {
     const contentBuffer = await readJarEntryAsBuffer(jarPath, entryPath);
     return decodeUtf8OrThrow(contentBuffer, jarPath, entryPath);
@@ -177,6 +193,39 @@ export async function readJarEntryAsBuffer(jarPath, entryPath) {
         }
     });
 }
+export async function collectMatchedJarEntriesAsUtf8(jarPath, predicate, options = {}) {
+    return withZipFile(jarPath, async (zipFile) => {
+        const entries = [];
+        const maxEntries = options.maxEntries == null ? undefined : Math.max(1, Math.trunc(options.maxEntries));
+        while (true) {
+            const entry = await readNextEntry(zipFile);
+            if (!entry) {
+                return entries;
+            }
+            if (!isSecureJarEntryPath(entry.fileName)) {
+                continue;
+            }
+            if (!predicate(entry.fileName)) {
+                continue;
+            }
+            try {
+                const contentBuffer = await readEntryStream(zipFile, entry, jarPath, options.maxBytes);
+                entries.push({
+                    filePath: entry.fileName,
+                    content: decodeUtf8OrThrow(contentBuffer, jarPath, entry.fileName)
+                });
+                if (maxEntries != null && entries.length >= maxEntries) {
+                    return entries;
+                }
+            }
+            catch (error) {
+                if (!options.continueOnError) {
+                    throw error;
+                }
+            }
+        }
+    });
+}
 export async function* iterateJavaEntriesAsUtf8(jarPath, maxBytes) {
     const zipFile = await openZipFile(jarPath);
     try {
@@ -227,4 +276,57 @@ export async function readAllJavaEntriesAsUtf8(jarPath, maxBytes) {
     }
     return entries;
 }
+function countMatches(input, pattern) {
+    const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+    const globalPattern = new RegExp(pattern.source, flags);
+    let count = 0;
+    while (globalPattern.exec(input)) {
+        count += 1;
+    }
+    return count;
+}
+export async function detectFabricLikeInputNamespace(inputJar) {
+    const warnings = [];
+    const classEntries = (await listJarEntries(inputJar))
+        .filter((entry) => entry.endsWith(".class"))
+        .slice(0, 24);
+    if (classEntries.length === 0) {
+        warnings.push("Could not inspect class entries to detect input mapping; assuming intermediary.");
+        return {
+            fromNamespace: "intermediary",
+            warnings
+        };
+    }
+    let mojangScore = 0;
+    let intermediaryScore = 0;
+    for (const entry of classEntries) {
+        let text = "";
+        try {
+            text = (await readJarEntryAsBuffer(inputJar, entry)).toString("latin1");
+        }
+        catch {
+            continue;
+        }
+        mojangScore += countMatches(text, /net\/minecraft\/(?:advancements|client|commands|core|data|gametest|nbt|network|recipe|resources|server|sounds|stats|tags|util|world)\//g) * 3;
+        intermediaryScore += countMatches(text, /net\/minecraft\/class_\d+/g) * 3;
+        intermediaryScore += countMatches(text, /\b(?:method|field)_\d+\b/g);
+    }
+    if (mojangScore > intermediaryScore && mojangScore > 0) {
+        return {
+            fromNamespace: "mojang",
+            warnings
+        };
+    }
+    if (intermediaryScore > mojangScore && intermediaryScore > 0) {
+        return {
+            fromNamespace: "intermediary",
+            warnings
+        };
+    }
+    warnings.push("Could not confidently detect whether the input jar uses intermediary or mojang names; assuming intermediary.");
+    return {
+        fromNamespace: "intermediary",
+        warnings
+    };
+}
 //# sourceMappingURL=source-jar-reader.js.map

package/dist/source-resolver.d.ts

@@ -1,8 +1,16 @@
-import type { Config, ResolvedSourceArtifact, SourceTargetInput } from "./types.js";
+import type { Config, MappingVariant, ResolvedSourceArtifact, SourceTargetInput } from "./types.js";
+export type { MappingVariant } from "./types.js";
 export interface ResolveSourceTargetOptions {
     allowDecompile: boolean;
     preferBinaryOnly?: boolean;
     preferredRepos?: string[];
+    /**
+     * When set to "mojang-remapped", the artifactId hash gets a dedicated
+     * suffix so the mojang-remapped variant of an otherwise binary-only artifact
+     * occupies its own cache slot. Defaults to "pass" which preserves the
+     * legacy hash for obfuscated and source-backed artifacts.
+     */
+    mappingVariant?: MappingVariant;
     onRepoFailover?: (event: {
         stage: "source" | "binary";
         repoUrl: string;

package/dist/source-resolver.js

@@ -1,4 +1,4 @@
-import { readdirSync } from "node:fs";
+import { readdir } from "node:fs/promises";
 import { basename, dirname, join, resolve as resolvePath } from "node:path";
 import { homedir } from "node:os";
 import fastGlob from "fast-glob";
@@ -7,7 +7,7 @@ import { buildRemoteBinaryUrls, buildRemoteSourceUrls, hasExistingJar, parseCoor
 import { defaultDownloadPath, downloadToCache } from "./repo-downloader.js";
 import { artifactSignatureFromFile, normalizeJarPath } from "./path-resolver.js";
 import { stableArtifactId } from "./config.js";
-import { listJavaEntries } from "./source-jar-reader.js";
+import { hasAnyJarEntry, hasJavaSourceExtension } from "./source-jar-reader.js";
 function readStatsSignature(filePath) {
     const stats = artifactSignatureFromFile(filePath);
     return stats.signature;
@@ -16,8 +16,7 @@ async function hasJavaSources(jarPath) {
     if (!hasExistingJar(jarPath)) {
         return false;
     }
-    const entries = await listJavaEntries(jarPath);
-    return entries.length > 0;
+    return hasAnyJarEntry(jarPath, hasJavaSourceExtension);
 }
 function resolveExactJarSourceCandidate(inputJarPath) {
     const directory = dirname(inputJarPath);
@@ -35,12 +34,12 @@ function resolveSiblingBinaryJarCandidate(inputJarPath) {
     const candidate = join(directory, binaryName);
     return hasExistingJar(candidate) ? candidate : undefined;
 }
-function listAdjacentJarSourceCandidates(inputJarPath) {
+async function listAdjacentJarSourceCandidates(inputJarPath) {
     const directory = dirname(inputJarPath);
     const exact = resolveExactJarSourceCandidate(inputJarPath);
     const candidates = new Set();
     try {
-        for (const file of readdirSync(directory)) {
+        for (const file of await readdir(directory)) {
             if (file.toLowerCase().endsWith("-sources.jar")) {
                 const candidate = join(directory, file);
                 if (candidate !== inputJarPath && candidate !== exact) {
@@ -90,7 +89,7 @@ function resolveGradleUserHome() {
     }
     return resolvePath(homedir(), ".gradle");
 }
-function resolveGradleCacheCoordinateCandidate(coordinate) {
+async function resolveGradleCacheCoordinateCandidate(coordinate) {
     const parsed = parseCoordinate(coordinate);
     const baseDir = resolvePath(resolveGradleUserHome(), "caches", "modules-2", "files-2.1", parsed.groupId, parsed.artifactId, parsed.version);
     const base = `${parsed.artifactId}-${parsed.version}`;
@@ -105,7 +104,7 @@ function resolveGradleCacheCoordinateCandidate(coordinate) {
     ];
     let discoveredFiles = [];
     try {
-        discoveredFiles = fastGlob.sync("*/*", {
+        discoveredFiles = await fastGlob.glob("*/*", {
             cwd: baseDir,
             absolute: true,
             onlyFiles: true
@@ -134,11 +133,19 @@ function resolveGradleCacheCoordinateCandidate(coordinate) {
 function resolveRemoteBinaryCandidate(coordinate, repos) {
     return buildRemoteBinaryUrls(repos, coordinate);
 }
-function artifactIdForJar(inputKind, artifactPath, signature, suffix) {
-    return stableArtifactId([inputKind, artifactPath, signature, suffix ?? "source"]);
+function artifactIdForJar(inputKind, artifactPath, signature, suffix, mappingVariant = "pass") {
+    const parts = [inputKind, artifactPath, signature, suffix ?? "source"];
+    if (mappingVariant === "mojang-remapped") {
+        parts.push("mojang-remapped");
+    }
+    return stableArtifactId(parts);
 }
-function artifactIdForCoordinate(coordinate, source, signature) {
-    return stableArtifactId(["coord", coordinate, source, signature]);
+function artifactIdForCoordinate(coordinate, source, signature, mappingVariant = "pass") {
+    const parts = ["coord", coordinate, source, signature];
+    if (mappingVariant === "mojang-remapped") {
+        parts.push("mojang-remapped");
+    }
+    return stableArtifactId(parts);
 }
 function resolvedAtNow() {
     return new Date().toISOString();
@@ -150,7 +157,7 @@ export async function resolveSourceTarget(input, options, explicitConfig) {
         const resolvedJarPath = normalizeJarPath(input.value);
         const binarySignature = readStatsSignature(resolvedJarPath);
         const exactSourceJarPath = resolveExactJarSourceCandidate(resolvedJarPath);
-        const adjacentSourceCandidates = listAdjacentJarSourceCandidates(resolvedJarPath);
+        const adjacentSourceCandidates = await listAdjacentJarSourceCandidates(resolvedJarPath);
         const maybeAdjacentSourceCandidates = adjacentSourceCandidates.length > 0 ? adjacentSourceCandidates : undefined;
         const preferBinaryOnly = options.preferBinaryOnly ?? false;
         if (await hasJavaSources(resolvedJarPath)) {
@@ -192,7 +199,7 @@ export async function resolveSourceTarget(input, options, explicitConfig) {
             });
         }
         return {
-            artifactId: artifactIdForJar("jar", resolvedJarPath, `${binarySignature}:decompile`),
+            artifactId: artifactIdForJar("jar", resolvedJarPath, `${binarySignature}:decompile`, undefined, options.mappingVariant ?? "pass"),
             artifactSignature: `${binarySignature}:decompile`,
             origin: "decompiled",
             binaryJarPath: resolvedJarPath,
@@ -225,7 +232,7 @@ export async function resolveSourceTarget(input, options, explicitConfig) {
             };
         }
     }
-    const gradleCacheCandidate = resolveGradleCacheCoordinateCandidate(coordinate);
+    const gradleCacheCandidate = await resolveGradleCacheCoordinateCandidate(coordinate);
     if (gradleCacheCandidate?.sourceJarPath && (await hasJavaSources(gradleCacheCandidate.sourceJarPath))) {
         const signature = readStatsSignature(gradleCacheCandidate.sourceJarPath);
         return {
@@ -327,7 +334,7 @@ export async function resolveSourceTarget(input, options, explicitConfig) {
             }
             const signature = readStatsSignature(downloaded.path);
             return {
-                artifactId: artifactIdForCoordinate(coordinate, "decompiled", signature),
+                artifactId: artifactIdForCoordinate(coordinate, "decompiled", signature, options.mappingVariant ?? "pass"),
                 artifactSignature: signature,
                 origin: "decompiled",
                 binaryJarPath: downloaded.path,

package/dist/source-service.d.ts

@@ -1,9 +1,9 @@
 import { type ResponseContext as ExplorerResponseContext, type SignatureMember } from "./minecraft-explorer-service.js";
-import { type MixinValidationResult, type MixinValidationProvenance, type MappingHealthReport, type AccessWidenerValidationResult } from "./mixin-validator.js";
+import { type MixinValidationResult, type MixinValidationProvenance, type MappingHealthReport, type AccessWidenerValidationResult, type AccessTransformerValidationResult } from "./mixin-validator.js";
 import { type ClassApiMatrixInput as MappingClassApiMatrixInput, type ClassApiMatrixOutput as MappingClassApiMatrixOutput, type FindMappingInput as MappingFindMappingInput, type FindMappingOutput as MappingFindMappingOutput, type ResolveMethodMappingExactInput as MappingResolveMethodMappingExactInput, type ResolveMethodMappingExactOutput as MappingResolveMethodMappingExactOutput, type SymbolResolutionOutput as MappingSymbolResolutionOutput, type SymbolExistenceInput as MappingSymbolExistenceInput, type SymbolExistenceOutput as MappingSymbolExistenceOutput } from "./mapping-service.js";
 import { RuntimeMetrics, type RuntimeMetricSnapshot } from "./observability.js";
 import { type WorkspaceCompileMappingOutput } from "./workspace-mapping-service.js";
-import type { ArtifactProvenance, ArtifactRow, ArtifactScope, Config, MappingSourcePriority, ResolvedSourceArtifact, SourceMapping, SourceTargetInput } from "./types.js";
+import type { AccessTransformerNamespace, ArtifactProvenance, ArtifactRow, ArtifactScope, Config, MappingSourcePriority, ResolvedSourceArtifact, SourceMapping, SourceTargetInput } from "./types.js";
 import { type ListVersionsInput, type ListVersionsOutput } from "./version-service.js";
 import { type GetRegistryDataInput, type GetRegistryDataOutput } from "./registry-service.js";
 import { type CompareVersionsInput, type CompareVersionsOutput } from "./version-diff-service.js";
@@ -18,9 +18,11 @@ export type ResolveArtifactInput = {
     scope?: ArtifactScope;
     preferProjectVersion?: boolean;
     strictVersion?: boolean;
+    compact?: boolean;
 };
 export type ResolveArtifactOutput = {
     artifactId: string;
+    artifactAlias: string;
     origin: "local-jar" | "local-m2" | "remote-repo" | "decompiled";
     isDecompiled: boolean;
     resolvedSourceJarPath?: string;
@@ -74,6 +76,8 @@ export type SearchClassSourceInput = {
     queryMode?: QueryMode;
     limit?: number;
     cursor?: string;
+    queryNamespace?: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
 };
 export type SearchClassSourceOutput = {
     hits: SearchSourceHit[];
@@ -81,6 +85,13 @@ export type SearchClassSourceOutput = {
     mappingApplied: SourceMapping;
     returnedNamespace: SourceMapping;
     artifactContents: ArtifactContentsSummary;
+    translatedQuery?: {
+        original: string;
+        translated: string;
+        fromNamespace: SourceMapping;
+        toNamespace: SourceMapping;
+    };
+    warnings?: string[];
 };
 export type GetArtifactFileInput = {
     artifactId: string;
@@ -207,6 +218,17 @@ export type GetClassMembersInput = {
     preferProjectVersion?: boolean;
     strictVersion?: boolean;
 };
+export type DecompiledMember = {
+    name: string;
+    line: number;
+    kind: "constructor" | "field" | "method";
+};
+export type DecompiledFallback = {
+    constructors: DecompiledMember[];
+    fields: DecompiledMember[];
+    methods: DecompiledMember[];
+    origin: "source-extracted";
+};
 export type GetClassMembersOutput = {
     className: string;
     members: {
@@ -230,6 +252,13 @@ export type GetClassMembersOutput = {
     provenance: ArtifactProvenance;
     qualityFlags: string[];
     artifactContents: ArtifactContentsSummary;
+    decompiledFallback?: DecompiledFallback;
+    decompiledMemberCounts?: {
+        constructors: number;
+        fields: number;
+        methods: number;
+        total: number;
+    };
     warnings: string[];
 };
 export type TraceSymbolLifecycleInput = {
@@ -424,8 +453,21 @@ export type ValidateAccessWidenerInput = {
     version: string;
     mapping?: SourceMapping;
     sourcePriority?: MappingSourcePriority;
+    projectPath?: string;
+    scope?: ArtifactScope;
+    preferProjectVersion?: boolean;
 };
 export type ValidateAccessWidenerOutput = AccessWidenerValidationResult;
+export type ValidateAccessTransformerInput = {
+    content: string;
+    version: string;
+    atNamespace?: AccessTransformerNamespace;
+    sourcePriority?: MappingSourcePriority;
+    projectPath?: string;
+    scope?: ArtifactScope;
+    preferProjectVersion?: boolean;
+};
+export type ValidateAccessTransformerOutput = AccessTransformerValidationResult;
 export declare class SourceService {
     private readonly config;
     private readonly db;
@@ -442,10 +484,33 @@ export declare class SourceService {
     private readonly versionDiffService;
     private readonly modDecompileService;
     private readonly modSearchService;
-    private cacheMetricsState;
+    private readonly lru;
+    private cacheTotalContentBytes;
+    private readonly remappedJarBytes;
+    /** In-flight binary-remap jobs keyed by remapped jar path so concurrent
+     * resolveArtifact calls for the same artifactId share a single tiny-remapper run. */
+    private readonly inflightRemaps;
     constructor(explicitConfig?: Config, metrics?: RuntimeMetrics);
     private discoverVersionSourceJar;
+    private discoverAccessWidenerRuntimeCandidates;
+    private discoverAccessTransformerRuntimeCandidates;
+    private resolveAccessWidenerRuntimeArtifact;
+    private resolveAccessTransformerNamespace;
+    private resolveAccessTransformerRuntimeArtifact;
     private buildVersionSourceRecoveryCommand;
+    /**
+     * Decide whether the upcoming resolveArtifact call may transparently remap a
+     * binary-only artifact (obfuscated -> mojang) and decompile it. The gate
+     * succeeds only when:
+     *   - the requested mapping is "mojang" on a still-obfuscated runtime
+     *   - tiny-remapper jar is downloadable / available locally
+     *   - the version's Mojang tiny mapping file can be produced
+     *   - checkMappingHealth reports mojang mappings are usable
+     * On any failure the variant defaults to "pass" so the legacy
+     * MAPPING_NOT_APPLIED fallback (or the existing source-backed flow) keeps
+     * its existing artifactId hash.
+     */
+    private computeBinaryRemapGate;
     private buildArtifactContentsSummary;
     private inferVersionFromContext;
     private resolveVersionContext;
@@ -464,22 +529,28 @@ export declare class SourceService {
     getClassApiMatrix(input: GetClassApiMatrixInput): Promise<GetClassApiMatrixOutput>;
     checkSymbolExists(input: CheckSymbolExistsInput): Promise<CheckSymbolExistsOutput>;
     resolveWorkspaceSymbol(input: ResolveWorkspaceSymbolInput): Promise<ResolveWorkspaceSymbolOutput>;
+    private checkSymbolExistsInUnobfuscatedRuntime;
     traceSymbolLifecycle(input: TraceSymbolLifecycleInput): Promise<TraceSymbolLifecycleOutput>;
     diffClassSignatures(input: DiffClassSignaturesInput): Promise<DiffClassSignaturesOutput>;
     findClass(input: FindClassInput): FindClassOutput;
     getClassSource(input: GetClassSourceInput): Promise<GetClassSourceOutput>;
     getClassMembers(input: GetClassMembersInput): Promise<GetClassMembersOutput>;
+    private buildDecompiledFallback;
     validateMixin(input: ValidateMixinInput): Promise<ValidateMixinOutput>;
+    private runValidateMixinDispatcher;
     private createProjectValidateMixinConfigInput;
     private shouldRetryValidateMixinWithMavenFirst;
     private findValidateMixinClassMapping;
     private validateMixinSingle;
+    private runValidateMixinPipeline;
     private resolveMixinInputPath;
     private resolveMixinConfigSources;
     private validateMixinMany;
     private applyValidateMixinOutputCompaction;
     private buildValidateMixinOutput;
     validateAccessWidener(input: ValidateAccessWidenerInput): Promise<ValidateAccessWidenerOutput>;
+    validateAccessTransformer(input: ValidateAccessTransformerInput): Promise<ValidateAccessTransformerOutput>;
+    recordToolCall(tool: string, durationMs: number): void;
     getRuntimeMetrics(): RuntimeMetricSnapshot;
     indexArtifact(input: IndexArtifactInput): Promise<IndexArtifactOutput>;
     private searchSymbolIntent;
@@ -491,6 +562,11 @@ export declare class SourceService {
     private indexedCandidateLimit;
     private indexedCandidateLimitForMatch;
     private extractClassMetadata;
+    private extractDecompiledMembers;
+    private computeLineBraceDepths;
+    private computeBraceRange;
+    private scanBraceRange;
+    private computeNestedTypeRanges;
     private resolveClassFilePath;
     private resolveBinaryFallbackArtifact;
     private buildProvenance;
@@ -509,13 +585,53 @@ export declare class SourceService {
     private buildRebuiltArtifactData;
     getArtifact(artifactId: string): ArtifactRow;
     private ingestIfNeeded;
+    /**
+     * If the resolved artifact's transformChain promised an "obf -> mojang"
+     * binary remap, run tiny-remapper now and return the remapped jar path.
+     * Otherwise return the original binaryJarPath unchanged.
+     *
+     * Cache safety: writes to a per-attempt temp file then atomic-renames into
+     * <cacheDir>/remapped/<artifactId>.jar. A per-target inflight Promise map
+     * collapses concurrent calls so two simultaneous resolveArtifact calls for
+     * the same artifactId share one tiny-remapper run instead of racing on the
+     * same output path.
+     */
+    private maybeRemapBinaryForMojang;
+    private recordRemappedJarBytesFromDisk;
+    /**
+     * Best-effort structural check that `path` is a non-empty file beginning with
+     * the ZIP local-file-header magic (`50 4B 03 04`). Used to drop partial /
+     * corrupt remap-cache entries before they reach Vineflower. False positives
+     * are acceptable (Vineflower will surface a clearer error); false negatives
+     * are not (a corrupt cache hit must be evicted).
+     */
+    private isUsableJarFile;
+    private runBinaryRemap;
     private loadFromSourceJar;
     private hasAnyFiles;
+    /**
+     * Best-effort cleanup of `<cacheDir>/remapped/<artifactId>.jar` written by
+     * `maybeRemapBinaryForMojang`. Called from cache-eviction paths so the
+     * Mojang-remapped binary jar does not outlive the artifact row that owns it.
+     * Also releases the jar's bytes from `cacheTotalContentBytes`. Errors are
+     * swallowed: orphaned jars remain visible to `manage-cache` under the
+     * `binary-remap` cache kind and can be reclaimed there.
+     */
+    private unlinkRemappedJarForArtifact;
+    /**
+     * Add the remapped jar's on-disk size to `cacheTotalContentBytes` so the
+     * `enforceCacheLimits` byte gate sees the jar before deciding to evict.
+     * Without this, a Mojang-remapped client jar (tens of MB) can accumulate
+     * silently while the indexed-source byte total stays below `maxCacheBytes`.
+     */
+    private recordRemappedJarBytes;
+    private releaseRemappedJarBytes;
     private enforceCacheLimits;
     private refreshCacheMetrics;
     private touchCacheMetrics;
     private upsertCacheMetrics;
     private removeCacheMetrics;
     private publishCacheMetrics;
+    private snapshotLruAccounting;
 }
 export {};