@adhisang/minecraft-modding-mcp 7.0.0 → 7.1.0

package/dist/entry-tools/validate-project-service.d.ts

@@ -124,9 +124,9 @@ export declare const validateProjectShape: {
     preferProjectVersion: z.ZodOptional<z.ZodBoolean>;
     preferProjectMapping: z.ZodDefault<z.ZodBoolean>;
     detail: z.ZodOptional<z.ZodEnum<{
+        full: "full";
         summary: "summary";
         standard: "standard";
-        full: "full";
     }>>;
     include: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         [x: string]: string;
@@ -236,9 +236,9 @@ export declare const validateProjectSchema: z.ZodObject<{
     preferProjectVersion: z.ZodOptional<z.ZodBoolean>;
     preferProjectMapping: z.ZodDefault<z.ZodBoolean>;
     detail: z.ZodOptional<z.ZodEnum<{
+        full: "full";
         summary: "summary";
         standard: "standard";
-        full: "full";
     }>>;
     include: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         [x: string]: string;

package/dist/index.js

@@ -11,6 +11,7 @@ import { prepareToolInput } from "./tool-input.js";
 import { DETAIL_ENABLED_TOOL_NAMES, DEFAULT_DETAIL_BY_TOOL, projectByDetail } from "./response-utils.js";
 import { loadConfig } from "./config.js";
 import { createError, ERROR_CODES, isAppError } from "./errors.js";
+import { convertRuntimeSqliteCorruption } from "./storage/db.js";
 import { log } from "./logger.js";
 import { applyNbtJsonPatch, nbtBase64ToTypedJson, typedJsonToNbtBase64 } from "./nbt/pipeline.js";
 import { analyzeModJar } from "./mod-analyzer.js";
@@ -136,7 +137,8 @@ const analyzeSymbolService = new AnalyzeSymbolService({
 const compareMinecraftService = new CompareMinecraftService({
     compareVersions: (input) => sourceService.compareVersions(input),
     diffClassSignatures: (input) => sourceService.diffClassSignatures(input),
-    getRegistryData: (input) => sourceService.getRegistryData(input)
+    getRegistryData: (input) => sourceService.getRegistryData(input),
+    getVersionLibraries: (input) => sourceService.getVersionLibraries(input.version)
 });
 const analyzeModService = new AnalyzeModService({
     analyzeModJar: (jarPath, options) => analyzeModJar(jarPath, options),
@@ -428,38 +430,58 @@ async function runTool(tool, rawInput, schema, action) {
         });
     }
     catch (caughtError) {
-        const problem = mapErrorToProblem(caughtError, requestId, {
+        // A raw SQLite corruption error surfaced mid-call (as opposed to at DB
+        // open, which is already a typed AppError by the time it gets here) means
+        // quick_check passed for this file but a live query still hit corruption.
+        // Escalate the next open to a full integrity_check and report a typed,
+        // restart-guiding ERR_DB_FAILURE instead of leaking ERR_INTERNAL.
+        const reportedError = convertRuntimeSqliteCorruption(caughtError, config.sqlitePath);
+        if (reportedError !== caughtError) {
+            // The public envelope only ever gets the generic ERR_DB_FAILURE message
+            // and nextAction (see convertRuntimeSqliteCorruption) - the original
+            // SQLite diagnostic is server-side-only, logged here with the request
+            // context convertRuntimeSqliteCorruption itself does not have access to.
+            const rawSqliteError = caughtError;
+            log("error", "tool.call.sqlite_runtime_corruption", {
+                requestId,
+                tool,
+                message: typeof rawSqliteError?.message === "string" ? rawSqliteError.message : String(caughtError),
+                code: rawSqliteError?.code,
+                errcode: rawSqliteError?.errcode
+            });
+        }
+        const problem = mapErrorToProblem(reportedError, requestId, {
             tool,
             normalizedInput
         });
-        if (isAppError(caughtError)) {
-            const isSevere = caughtError.code === ERROR_CODES.DB_FAILURE ||
-                caughtError.code === ERROR_CODES.REPO_FETCH_FAILED ||
-                caughtError.code === ERROR_CODES.REGISTRY_GENERATION_FAILED ||
-                caughtError.code === ERROR_CODES.JAVA_UNAVAILABLE ||
-                caughtError.code.startsWith("ERR_DECOMPILER");
+        if (isAppError(reportedError)) {
+            const isSevere = reportedError.code === ERROR_CODES.DB_FAILURE ||
+                reportedError.code === ERROR_CODES.REPO_FETCH_FAILED ||
+                reportedError.code === ERROR_CODES.REGISTRY_GENERATION_FAILED ||
+                reportedError.code === ERROR_CODES.JAVA_UNAVAILABLE ||
+                reportedError.code.startsWith("ERR_DECOMPILER");
             if (isSevere) {
                 log("error", "tool.call.failed", {
                     requestId,
                     tool,
-                    code: caughtError.code,
-                    message: caughtError.message
+                    code: reportedError.code,
+                    message: reportedError.message
                 });
             }
             else {
                 log("warn", "tool.call.warning", {
                     requestId,
                     tool,
-                    code: caughtError.code,
-                    message: caughtError.message
+                    code: reportedError.code,
+                    message: reportedError.message
                 });
             }
         }
-        else if (!(caughtError instanceof ZodError)) {
+        else if (!(reportedError instanceof ZodError)) {
             log("error", "tool.call.unhandled", {
                 requestId,
                 tool,
-                reason: caughtError instanceof Error ? caughtError.message : String(caughtError)
+                reason: reportedError instanceof Error ? reportedError.message : String(reportedError)
             });
         }
         const errorDurationMs = Date.now() - startedAt;
@@ -469,7 +491,7 @@ async function runTool(tool, rawInput, schema, action) {
             tool,
             durationMs: errorDurationMs
         };
-        applyErrorMetaExtensions(errorMeta, caughtError);
+        applyErrorMetaExtensions(errorMeta, reportedError);
         return objectResult({
             error: problem,
             meta: errorMeta

package/dist/source/artifact-resolver.d.ts

@@ -1,3 +1,4 @@
+import { type JavaSourceScan } from "../source-jar-reader.js";
 import type { SourceService } from "../source-service.js";
 import type { ArtifactContentsSummary, ProbeMinecraftArtifactInput, ProbeMinecraftArtifactOutput, ResolveArtifactInput, ResolveArtifactOutput } from "../source-service.js";
 import type { AccessTransformerNamespace, ArtifactProvenance, ArtifactScope, ArtifactTargetKind, ResolvedSourceArtifact, RuntimeLoader, RuntimeValidationProvenance, SourceMapping } from "../types.js";
@@ -143,6 +144,19 @@ export declare function hasLoaderRuntimeVersionToken(path: string, mcVersion: st
  * of the path is the version the jar was built for.
  */
 export declare function inferRuntimeJarMinecraftVersion(path: string): string | undefined;
+/**
+ * The Minecraft version a `kind: "jar"` target PROVES it is the unobfuscated
+ * runtime of, or undefined. The file path is never evidence: Loom and other
+ * tools lay jars out in ways that path heuristics have misread before.
+ *
+ * All three must hold: the walk met no `.java` entry, the jar ships
+ * `net/minecraft/SharedConstants.class`, and its root `version.json` parses with a
+ * string `id` that `isUnobfuscatedVersion` accepts. The id is put to that test
+ * only once the other two hold, so it is the id a Minecraft `version.json`
+ * declares, never a library's own release number. A Loom-mapped 1.x jar carries
+ * both signals too; its `1.x` id is what keeps it out. The path is never read.
+ */
+export declare function provenUnobfuscatedRuntimeJarVersion(scan: JavaSourceScan | undefined): string | undefined;
 /**
  * Loader a runtime jar belongs to, read from the tool-written part of its path.
  *

package/dist/source/artifact-resolver.js

@@ -219,6 +219,40 @@ const RUNTIME_JAR_VERSION_REGEX = /(?:^|[^0-9.])(1\.\d+(?:\.\d+)?)(?![0-9.])/;
 export function inferRuntimeJarMinecraftVersion(path) {
     return RUNTIME_JAR_VERSION_REGEX.exec(normalizePathStyle(path))?.[1];
 }
+/**
+ * The Minecraft version a `kind: "jar"` target PROVES it is the unobfuscated
+ * runtime of, or undefined. The file path is never evidence: Loom and other
+ * tools lay jars out in ways that path heuristics have misread before.
+ *
+ * All three must hold: the walk met no `.java` entry, the jar ships
+ * `net/minecraft/SharedConstants.class`, and its root `version.json` parses with a
+ * string `id` that `isUnobfuscatedVersion` accepts. The id is put to that test
+ * only once the other two hold, so it is the id a Minecraft `version.json`
+ * declares, never a library's own release number. A Loom-mapped 1.x jar carries
+ * both signals too; its `1.x` id is what keeps it out. The path is never read.
+ */
+export function provenUnobfuscatedRuntimeJarVersion(scan) {
+    const signals = scan?.minecraftRuntimeSignals;
+    if (!scan || scan.hasJavaSources || !signals?.hasSharedConstantsClass || signals.versionJsonText === undefined) {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(signals.versionJsonText);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return undefined;
+    }
+    const id = parsed.id;
+    if (typeof id !== "string") {
+        return undefined;
+    }
+    const version = id.trim();
+    return isUnobfuscatedVersion(version) ? version : undefined;
+}
 /**
  * Segment that opens a directory tree a BUILD TOOL wrote: a dot-directory
  * (`.gradle`, `.gradle-user-home`, `.m2`), Gradle's `caches` root, or a project
@@ -378,7 +412,8 @@ function buildProvenance(input) {
             version: input.resolved.version,
             repoUrl: input.resolved.repoUrl
         },
-        transformChain: [...input.transformChain]
+        transformChain: [...input.transformChain],
+        ...(input.unobfuscatedRuntime ? { unobfuscatedRuntime: true } : {})
     };
     if (!provenance.resolvedAt || !provenance.target.kind || !provenance.target.value) {
         throw createError({
@@ -1238,7 +1273,14 @@ export async function buildMappingFallbackSuggestedCall(svc, args) {
         return buildLegacyMappingFallback({ kind, value, scope, isVanillaMojang, projectPath: undefined });
     }
     if (kind !== "version") {
-        return buildLegacyMappingFallback({ kind, value, scope, isVanillaMojang, projectPath });
+        return buildLegacyMappingFallback({
+            kind,
+            value,
+            scope,
+            isVanillaMojang,
+            projectPath,
+            projectRuntimeUnobfuscated: isVanillaMojang && (await projectNamesUnobfuscatedMinecraft(svc, projectPath))
+        });
     }
     const cached = svc.workspaceContextCache.read(projectPath);
     if (cached &&
@@ -1299,9 +1341,28 @@ export async function buildMappingFallbackSuggestedCall(svc, args) {
     }
     return buildLegacyMappingFallback({ kind, value, scope, isVanillaMojang, projectPath });
 }
+/**
+ * Whether the project's gradle.properties names a Minecraft 26.1+ release. The
+ * property is a Minecraft version by name (`minecraft_version` and its aliases), so
+ * it may be put to `isUnobfuscatedVersion`. Unreadable or absent answers false.
+ */
+async function projectNamesUnobfuscatedMinecraft(svc, projectPath) {
+    try {
+        const version = await svc.workspaceMappingService.detectProjectMinecraftVersion(projectPath);
+        return version !== undefined && isUnobfuscatedVersion(version);
+    }
+    catch {
+        return false;
+    }
+}
 function buildLegacyMappingFallback(args) {
     const { kind, value, scope, isVanillaMojang, projectPath } = args;
-    if (isVanillaMojang && projectPath) {
+    // scope=merged reaches Loom source discovery only for a version target. For a
+    // jar or coordinate in a 26.1+ project, re-suggesting mojang+merged on the same
+    // target repeats the request that was just refused, so that case takes the
+    // generic retry below instead.
+    const mergedRetryWouldRepeat = kind !== "version" && args.projectRuntimeUnobfuscated === true;
+    if (isVanillaMojang && projectPath && !mergedRetryWouldRepeat) {
         return {
             ...buildSuggestedCall({
                 tool: "resolve-artifact",
@@ -1311,7 +1372,7 @@ function buildLegacyMappingFallback(args) {
                 "Retry with scope=merged to allow source-jar resolution from the project cache."
         };
     }
-    if (isVanillaMojang) {
+    if (isVanillaMojang && !projectPath) {
         return {
             ...buildSuggestedCall({
                 tool: "resolve-artifact",
@@ -1326,7 +1387,14 @@ function buildLegacyMappingFallback(args) {
             tool: "resolve-artifact",
             params: buildResolveArtifactParams({ kind, value }, { mapping: "obfuscated", ...(scope ? { scope } : {}) })
         }),
-        nextAction: "Retry with mapping=obfuscated to use the runtime obfuscated namespace."
+        // A jar reaches here only when it was NOT proven to be a Minecraft runtime jar,
+        // so its version is unknown and "obfuscated" must not be described as
+        // obfuscated names: on 26.1+ the as-shipped names are Mojang names. Version and
+        // coordinate refusals keep their established wording.
+        nextAction: kind === "jar"
+            ? "Retry with mapping=obfuscated to read this jar's names as shipped (already Mojang names on Minecraft 26.1+). " +
+                "For a vanilla Minecraft release, use target kind \"version\" instead."
+            : "Retry with mapping=obfuscated to use the runtime obfuscated namespace."
     };
 }
 export async function resolveArtifact(svc, input) {
@@ -1431,13 +1499,19 @@ export async function resolveArtifact(svc, input) {
         // below), so its mapping is never actually enforced either way.
         const versionNamesMinecraft = kind === "version" ||
             (kind === "coordinate" && !dependencyOrigin && coordinateIsMinecraftRuntime);
-        const minecraftVersion = versionNamesMinecraft ? resolvedVersion : undefined;
-        const runtimeNamesUnobfuscated = minecraftVersion !== undefined && isUnobfuscatedVersion(minecraftVersion);
+        // A kind="jar" target names no version at all. It joins this gate only AFTER its
+        // archive has been walked and proved to be a Minecraft 26.1+ runtime jar (see
+        // `provenUnobfuscatedRuntimeJarVersion` below); until then it stays out.
+        let minecraftVersion = versionNamesMinecraft ? resolvedVersion : undefined;
+        let runtimeNamesUnobfuscated = minecraftVersion !== undefined && isUnobfuscatedVersion(minecraftVersion);
         let effectiveMapping = mapping;
-        if ((mapping === "intermediary" || mapping === "yarn") && runtimeNamesUnobfuscated) {
-            warnings.push(`Version ${minecraftVersion} is unobfuscated; ${mapping} mappings are not applicable. Using the obfuscated namespace label for the deobfuscated runtime names.`);
-            effectiveMapping = "obfuscated";
-        }
+        const dropInapplicableUnobfuscatedMapping = () => {
+            if ((effectiveMapping === "intermediary" || effectiveMapping === "yarn") && runtimeNamesUnobfuscated) {
+                warnings.push(`Version ${minecraftVersion} is unobfuscated; ${effectiveMapping} mappings are not applicable. Using the obfuscated namespace label for the deobfuscated runtime names.`);
+                effectiveMapping = "obfuscated";
+            }
+        };
+        dropInapplicableUnobfuscatedMapping();
         if (kind === "version" &&
             resolvedVersion &&
             effectiveMapping === "mojang" &&
@@ -1471,9 +1545,21 @@ export async function resolveArtifact(svc, input) {
         if (binaryRemapGate.warnings.length > 0) {
             warnings.push(...binaryRemapGate.warnings);
         }
+        // Only a jar the caller named directly can be proved from its contents. A
+        // dependency-origin jar is excluded for the reason given above, and a version
+        // target is rewritten into a jar but already carries its version.
+        const proveRuntimeJar = kind === "jar" && !dependencyOrigin;
+        let subjectJarScan = undefined;
         const resolved = await resolveSourceTargetInternal(resolvedTarget, {
             allowDecompile: effectiveMapping === "mojang" ? true : input.allowDecompile ?? true,
             mappingVariant: binaryRemapGate.mappingVariant,
+            ...(proveRuntimeJar
+                ? {
+                    onSubjectJarScanned: (scan) => {
+                        subjectJarScan = scan;
+                    }
+                }
+                : {}),
             onRepoFailover: (event) => {
                 svc.metrics.recordRepoFailover();
                 log("warn", "repo.failover", {
@@ -1486,6 +1572,13 @@ export async function resolveArtifact(svc, input) {
                 });
             }
         }, svc.config);
+        const provenJarVersion = proveRuntimeJar ? provenUnobfuscatedRuntimeJarVersion(subjectJarScan) : undefined;
+        if (provenJarVersion) {
+            resolvedVersion = provenJarVersion;
+            minecraftVersion = provenJarVersion;
+            runtimeNamesUnobfuscated = true;
+            dropInapplicableUnobfuscatedMapping();
+        }
         resolved.version = resolvedVersion;
         let mappingDecision;
         try {
@@ -1569,7 +1662,8 @@ export async function resolveArtifact(svc, input) {
         const provenance = buildProvenance({
             requestedTarget: { kind, value },
             resolved,
-            transformChain: [...mappingDecision.transformChain, ...additionalTransformChain]
+            transformChain: [...mappingDecision.transformChain, ...additionalTransformChain],
+            unobfuscatedRuntime: runtimeNamesUnobfuscated
         });
         if (workspaceProvenance) {
             provenance.workspaceResolution = workspaceProvenance;

package/dist/source/class-source/members-builder.d.ts

@@ -17,6 +17,13 @@ export type RemapMembersInput = {
     signatureFields: SignatureMember[];
     signatureMethods: SignatureMember[];
     version: string | undefined;
+    /**
+     * `version` when it is a Minecraft version, else undefined: a dependency
+     * artifact's `version` is its own release number, which must not reach the
+     * 26.1+ obfuscated<->mojang identity shortcut, which may only be asked about a
+     * string proven to be a Minecraft version.
+     */
+    minecraftVersion: string | undefined;
     mappingApplied: SourceMapping;
     requestedMapping: SourceMapping;
     sourcePriority: MappingSourcePriority | undefined;

package/dist/source/class-source/members-builder.js

@@ -1,10 +1,13 @@
+import { remapSignatureMembers } from "../lifecycle/mapping-helpers.js";
 import { matchesMemberPattern } from "../member-pattern.js";
 export async function remapAndCountMembers(svc, input) {
     const remap = async (members, kind) => {
         if (input.version == null) {
             return members;
         }
-        const result = await svc.remapSignatureMembers(members, kind, input.version, input.mappingApplied, input.requestedMapping, input.sourcePriority, input.warnings, undefined, input.gradleUserHome);
+        // Called directly rather than through svc.remapSignatureMembers, whose fixed
+        // parameter list cannot carry minecraftVersion.
+        const result = await remapSignatureMembers(svc, members, kind, input.version, input.mappingApplied, input.requestedMapping, input.sourcePriority, input.warnings, undefined, input.gradleUserHome, { minecraftVersion: input.minecraftVersion });
         return result.members;
     };
     let constructors = await remap(input.signatureConstructors, "method");

package/dist/source/class-source.d.ts

@@ -21,7 +21,7 @@ import type { ArtifactProvenance, ArtifactScope, MappingSourcePriority, Resolved
  */
 export declare function reconcileUnobfuscatedNamespace(version: string | undefined, requestedMapping: SourceMapping, mappingApplied: SourceMapping): SourceMapping;
 export declare function resolveClassFilePath(svc: SourceService, artifactId: string, className: string): string | undefined;
-export declare function resolveClassNameForLookup(svc: SourceService, input: {
+type ClassNameLookupInput = {
     className: string;
     version?: string;
     sourceMapping: SourceMapping;
@@ -30,7 +30,13 @@ export declare function resolveClassNameForLookup(svc: SourceService, input: {
     gradleUserHome?: string;
     warnings: string[];
     context: string;
-}): Promise<string>;
+};
+/**
+ * The class-name translation behind `svc.resolveClassNameForLookup`, whose callers
+ * (the lifecycle tools) pass a Minecraft version, so `version` also keys the 26.1+
+ * identity shortcut.
+ */
+export declare function resolveClassNameForLookup(svc: SourceService, input: ClassNameLookupInput): Promise<string>;
 export declare function buildFallbackProvenance(svc: SourceService, input: {
     artifactId: string;
     origin: ResolvedSourceArtifact["origin"];
@@ -98,3 +104,4 @@ export declare function findClass(svc: SourceService, input: FindClassInput): Fi
 export declare function findClassIncludingNested(svc: SourceService, input: FindClassInput): Promise<FindClassOutput>;
 export declare function getClassSource(svc: SourceService, input: GetClassSourceInput): Promise<GetClassSourceOutput>;
 export declare function getClassMembers(svc: SourceService, input: GetClassMembersInput): Promise<GetClassMembersOutput>;
+export {};