@adhisang/minecraft-modding-mcp 6.2.0 → 7.0.0-rc.0

package/dist/source/nested-jars.js

@@ -4,6 +4,7 @@ import { dirname, join } from "node:path";
 import { buildSuggestedCall } from "../build-suggested-call.js";
 import { ERROR_CODES, createError } from "../errors.js";
 import { collectNestedJars } from "../mod-analyzer.js";
+import { isSecureJarEntryPath } from "../path-resolver.js";
 import { listJarEntries, readJarEntryAsBuffer, readJarEntryAsUtf8 } from "../source-jar-reader.js";
 /**
  * A jar with at most this many own `.class` entries can qualify as a
@@ -29,6 +30,84 @@ function rememberClassSet(key, value) {
         classSetCache.delete(oldest);
     }
 }
+async function loadNestedJarClassSet(args) {
+    let extractedPath;
+    try {
+        extractedPath = await extractNestedJar(args.cacheDir, args.outerJarPath, args.outerSignature, args.entryName);
+    }
+    catch {
+        return undefined;
+    }
+    let classSet = classSetCache.get(extractedPath);
+    if (!classSet) {
+        try {
+            const entries = await listJarEntries(extractedPath);
+            classSet = new Set(entries.filter((entry) => entry.endsWith(".class") && isSecureJarEntryPath(entry)));
+        }
+        catch {
+            return undefined;
+        }
+        rememberClassSet(extractedPath, classSet);
+    }
+    return { extractedPath, classSet };
+}
+function nestedClassMatch(entry) {
+    const internalName = entry.slice(0, -".class".length);
+    if (internalName.startsWith("META-INF/versions/")) {
+        return undefined;
+    }
+    const binarySimpleName = internalName.split("/").at(-1) ?? internalName;
+    if (binarySimpleName === "module-info" || binarySimpleName === "package-info") {
+        return undefined;
+    }
+    const innerSegments = binarySimpleName.split("$").slice(1);
+    if (innerSegments.some((segment) => segment.length === 0 || /^\d/.test(segment))) {
+        return undefined;
+    }
+    return {
+        qualifiedName: internalName.replaceAll("/", ".").replaceAll("$", "."),
+        filePath: `${internalName.split("$")[0]}.java`,
+        line: 1,
+        symbolKind: "class"
+    };
+}
+/**
+ * Finds exact class-name matches across a shell's nested bytecode inventory.
+ * Results use the same binary-backed class representation as entry-tool search:
+ * an inferred outer Java path, line 1, and the broad class symbol kind.
+ */
+export async function findNestedJarClasses(args) {
+    const normalizedQuery = args.className.trim().replaceAll("/", ".").replaceAll("$", ".");
+    const isQualified = normalizedQuery.includes(".");
+    const matches = new Map();
+    inventory: for (const entryName of args.inventory) {
+        const loaded = await loadNestedJarClassSet({
+            cacheDir: args.cacheDir,
+            outerJarPath: args.outerJarPath,
+            outerSignature: args.outerSignature,
+            entryName
+        });
+        if (!loaded) {
+            continue;
+        }
+        for (const classEntry of [...loaded.classSet].sort((left, right) => left.localeCompare(right))) {
+            const match = nestedClassMatch(classEntry);
+            if (!match) {
+                continue;
+            }
+            const simpleName = match.qualifiedName.split(".").at(-1) ?? match.qualifiedName;
+            if ((isQualified && match.qualifiedName !== normalizedQuery) ||
+                (!isQualified && simpleName !== normalizedQuery)) {
+                continue;
+            }
+            matches.set(match.qualifiedName, match);
+            if (isQualified || matches.size >= args.limit) {
+                break inventory;
+            }
+        }
+    }
+    return [...matches.values()];
+}
 /**
  * Shell detection with both required signals: near-zero own classes AND
  * bundled nested jars (META-INF/jars scan or fabric.mod.json "jars"
@@ -128,29 +207,19 @@ export async function extractNestedJar(cacheDir, outerJarPath, outerSignature, e
  */
 export async function findNestedJarsContainingClass(args) {
     const classEntry = `${args.internalName}.class`;
+    const qualifiedName = args.internalName.replaceAll("/", ".").replaceAll("$", ".");
     const matches = [];
     for (const entryName of args.inventory) {
-        let extractedPath;
-        try {
-            extractedPath = await extractNestedJar(args.cacheDir, args.outerJarPath, args.outerSignature, entryName);
-        }
-        catch {
-            // Unsafe or unreadable nested entries never become candidates.
-            continue;
-        }
-        let classSet = classSetCache.get(extractedPath);
-        if (!classSet) {
-            try {
-                const entries = await listJarEntries(extractedPath);
-                classSet = new Set(entries.filter((entry) => entry.endsWith(".class")));
-            }
-            catch {
-                continue;
-            }
-            rememberClassSet(extractedPath, classSet);
-        }
-        if (classSet.has(classEntry)) {
-            matches.push({ entryName, extractedPath });
+        const loaded = await loadNestedJarClassSet({
+            cacheDir: args.cacheDir,
+            outerJarPath: args.outerJarPath,
+            outerSignature: args.outerSignature,
+            entryName
+        });
+        const containsClass = loaded?.classSet.has(classEntry) || [...(loaded?.classSet ?? [])].some((entry) => entry.endsWith(".class") &&
+            entry.slice(0, -".class".length).replaceAll("/", ".").replaceAll("$", ".") === qualifiedName);
+        if (loaded && containsClass) {
+            matches.push({ entryName, extractedPath: loaded.extractedPath });
         }
     }
     return matches;

package/dist/source/shared-utils.d.ts

@@ -2,5 +2,26 @@ import type { SourceMapping } from "../types.js";
 export declare function normalizePathStyle(path: string): string;
 export declare function normalizeOptionalString(value: string | undefined): string | undefined;
 export declare function normalizeMapping(mapping: SourceMapping | undefined): SourceMapping;
+/**
+ * The mapping an artifact-targeted call runs in when the caller left `mapping`
+ * out.
+ *
+ * A stored artifact already carries the namespace it was resolved into, so a
+ * follow-up call that names it by `artifactId` must inherit that namespace
+ * instead of falling back to the version-target default ("obfuscated").
+ * Without this, `find-class` -> `get-class-source` -> `get-class-members`
+ * split across two namespaces: source came back in mojang names while members
+ * came back obfuscated (`ownerFqn: "dlp"`), for the same artifact and the same
+ * absent `mapping` argument.
+ *
+ * `requestedMapping` wins over `mappingApplied` so the echoed request keeps
+ * meaning "what was asked for" even on artifacts where the mapping could not
+ * be applied; `mappingApplied` is the fallback for rows stored before the
+ * requested namespace was persisted.
+ */
+export declare function inheritArtifactMapping(inputMapping: SourceMapping | undefined, artifact: {
+    requestedMapping?: SourceMapping;
+    mappingApplied?: SourceMapping;
+}): SourceMapping;
 export declare function pathExists(filePath: string): Promise<boolean>;
 export declare function dedupeQualityFlags(qualityFlags: readonly string[]): string[];

package/dist/source/shared-utils.js

@@ -31,6 +31,29 @@ export function normalizeMapping(mapping) {
         }
     });
 }
+/**
+ * The mapping an artifact-targeted call runs in when the caller left `mapping`
+ * out.
+ *
+ * A stored artifact already carries the namespace it was resolved into, so a
+ * follow-up call that names it by `artifactId` must inherit that namespace
+ * instead of falling back to the version-target default ("obfuscated").
+ * Without this, `find-class` -> `get-class-source` -> `get-class-members`
+ * split across two namespaces: source came back in mojang names while members
+ * came back obfuscated (`ownerFqn: "dlp"`), for the same artifact and the same
+ * absent `mapping` argument.
+ *
+ * `requestedMapping` wins over `mappingApplied` so the echoed request keeps
+ * meaning "what was asked for" even on artifacts where the mapping could not
+ * be applied; `mappingApplied` is the fallback for rows stored before the
+ * requested namespace was persisted.
+ */
+export function inheritArtifactMapping(inputMapping, artifact) {
+    if (inputMapping != null) {
+        return normalizeMapping(inputMapping);
+    }
+    return artifact.requestedMapping ?? artifact.mappingApplied ?? normalizeMapping(undefined);
+}
 export async function pathExists(filePath) {
     try {
         await access(filePath);

package/dist/source-service.d.ts

@@ -268,11 +268,20 @@ export type FindClassMatch = {
     filePath: string;
     line: number;
     symbolKind: string;
+    /** Set when the match is a type declared INSIDE another type. */
+    nested?: boolean;
+    /** The enclosing top-level type, present only on a nested match. */
+    enclosingClass?: string;
 };
 export type FindClassOutput = {
     matches: FindClassMatch[];
     total: number;
     warnings: string[];
+    /** Recovery route when the index legitimately cannot answer (partial coverage). */
+    suggestedCall?: {
+        tool: string;
+        params: Record<string, unknown>;
+    };
 };
 type MemberAccess = "public" | "all";
 export type GetClassMembersInput = {
@@ -638,6 +647,7 @@ export declare class SourceService {
         requestedScope: ArtifactScope;
         atNamespace: AccessTransformerNamespace;
         loader: import("./workspace-mapping-service.js").WorkspaceProjectLoader | "unknown";
+        projectMinecraftVersion?: string;
     }): ReturnType<typeof artifactResolver.discoverAccessTransformerRuntimeCandidates>;
     buildMappingFallbackSuggestedCall(args: {
         input: ResolveArtifactInput;
@@ -670,6 +680,7 @@ export declare class SourceService {
     traceSymbolLifecycle(input: TraceSymbolLifecycleInput): Promise<TraceSymbolLifecycleOutput>;
     diffClassSignatures(input: DiffClassSignaturesInput): Promise<DiffClassSignaturesOutput>;
     findClass(input: FindClassInput): FindClassOutput;
+    findClassIncludingNested(input: FindClassInput): Promise<FindClassOutput>;
     getClassSource(input: GetClassSourceInput): Promise<GetClassSourceOutput>;
     getClassMembers(input: GetClassMembersInput): Promise<GetClassMembersOutput>;
     validateMixin(input: ValidateMixinInput, options?: ValidateMixinOptions): Promise<ValidateMixinOutput>;
@@ -701,6 +712,7 @@ export declare class SourceService {
         mappingApplied: SourceMapping;
         provenance?: ArtifactProvenance;
         qualityFlags: string[];
+        allowDecompile?: boolean;
     }): Promise<ResolvedSourceArtifact | undefined>;
     getArtifact(artifactId: string): ArtifactRow;
     ingestIfNeeded(resolved: ResolvedSourceArtifact): Promise<void>;

package/dist/source-service.js

@@ -215,6 +215,9 @@ export class SourceService {
     findClass(input) {
         return classSource.findClass(this, input);
     }
+    async findClassIncludingNested(input) {
+        return classSource.findClassIncludingNested(this, input);
+    }
     async getClassSource(input) {
         return classSource.getClassSource(this, input);
     }