@adhisang/minecraft-modding-mcp 4.0.0 → 4.1.0

package/dist/source/access-validate.d.ts

@@ -0,0 +1,4 @@
+import type { SourceService } from "../source-service.js";
+import type { ValidateAccessTransformerInput, ValidateAccessTransformerOutput, ValidateAccessWidenerInput, ValidateAccessWidenerOutput } from "../source-service.js";
+export declare function validateAccessWidener(svc: SourceService, input: ValidateAccessWidenerInput): Promise<ValidateAccessWidenerOutput>;
+export declare function validateAccessTransformer(svc: SourceService, input: ValidateAccessTransformerInput): Promise<ValidateAccessTransformerOutput>;

package/dist/source/access-validate.js

@@ -0,0 +1,254 @@
+import { parseAccessTransformer } from "../access-transformer-parser.js";
+import { parseAccessWidener } from "../access-widener-parser.js";
+import { ERROR_CODES, createError } from "../errors.js";
+import { validateParsedAccessTransformer, validateParsedAccessWidener } from "../mixin-validator.js";
+import { normalizeMapping, normalizeOptionalString } from "./shared-utils.js";
+function normalizeAccessWidenerNamespace(namespace) {
+    const normalized = namespace?.trim().toLowerCase();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized === "named") {
+        return "yarn";
+    }
+    if (normalized === "obfuscated" ||
+        normalized === "mojang" ||
+        normalized === "intermediary" ||
+        normalized === "yarn") {
+        return normalized;
+    }
+    return undefined;
+}
+function isSourceMappingNamespace(namespace) {
+    return (namespace === "obfuscated" ||
+        namespace === "mojang" ||
+        namespace === "intermediary" ||
+        namespace === "yarn");
+}
+export async function validateAccessWidener(svc, input) {
+    const version = input.version.trim();
+    if (!version) {
+        throw createError({ code: ERROR_CODES.INVALID_INPUT, message: "version must be non-empty." });
+    }
+    const content = input.content;
+    if (!content.trim()) {
+        throw createError({ code: ERROR_CODES.INVALID_INPUT, message: "content must be non-empty." });
+    }
+    const warnings = [];
+    const parsed = parseAccessWidener(content);
+    const headerNamespaceRaw = normalizeOptionalString(parsed.namespace);
+    const overrideMapping = input.mapping ? normalizeMapping(input.mapping) : undefined;
+    const headerNamespace = normalizeAccessWidenerNamespace(headerNamespaceRaw);
+    if (!headerNamespace && headerNamespaceRaw && !overrideMapping) {
+        warnings.push(`Unsupported access widener namespace "${headerNamespaceRaw}". Assuming intermediary.`);
+    }
+    const awNamespace = overrideMapping ?? headerNamespace ?? "intermediary";
+    if (overrideMapping && headerNamespace && overrideMapping !== headerNamespace) {
+        warnings.push(`Using mapping override "${overrideMapping}" instead of header namespace "${headerNamespaceRaw}".`);
+    }
+    const runtimeAware = input.projectPath != null || input.scope != null || input.preferProjectVersion === true;
+    let resolvedVersion = version;
+    let jarPath;
+    let lookupMapping = "obfuscated";
+    let provenance;
+    if (runtimeAware) {
+        provenance = await svc.resolveAccessWidenerRuntimeArtifact({
+            version,
+            awNamespace,
+            projectPath: input.projectPath,
+            scope: input.scope,
+            preferProjectVersion: input.preferProjectVersion
+        });
+        resolvedVersion = provenance.version;
+        jarPath = provenance.jarPath;
+        lookupMapping = provenance.mappingApplied;
+    }
+    else {
+        ({ jarPath } = await svc.versionService.resolveVersionJar(version));
+    }
+    const needsLookupMapping = awNamespace !== lookupMapping;
+    // Collect unique class FQNs from entries
+    const classFqns = new Set();
+    for (const entry of parsed.entries) {
+        const fqn = entry.target.replace(/\//g, ".");
+        classFqns.add(fqn);
+    }
+    const membersByClass = new Map();
+    for (const fqn of classFqns) {
+        let lookupFqn = fqn;
+        if (needsLookupMapping) {
+            try {
+                const mapped = await svc.mappingService.findMapping({
+                    version: resolvedVersion,
+                    kind: "class",
+                    name: fqn,
+                    sourceMapping: awNamespace,
+                    targetMapping: lookupMapping,
+                    sourcePriority: input.sourcePriority,
+                    projectPath: input.projectPath
+                });
+                if (mapped.resolved && mapped.resolvedSymbol) {
+                    lookupFqn = mapped.resolvedSymbol.name;
+                }
+                else {
+                    warnings.push(`Could not map class "${fqn}" from ${awNamespace} to ${lookupMapping}.`);
+                }
+            }
+            catch {
+                warnings.push(`Mapping lookup failed for class "${fqn}".`);
+            }
+        }
+        try {
+            const sig = await svc.explorerService.getSignature({
+                fqn: lookupFqn,
+                jarPath,
+                access: "all"
+            });
+            warnings.push(...sig.warnings);
+            let constructors = sig.constructors;
+            let methods = sig.methods;
+            let fields = sig.fields;
+            if (needsLookupMapping) {
+                const [ctorResult, methodResult, fieldResult] = await Promise.all([
+                    svc.remapSignatureMembers(sig.constructors, "method", resolvedVersion, lookupMapping, awNamespace, input.sourcePriority, warnings, input.projectPath),
+                    svc.remapSignatureMembers(sig.methods, "method", resolvedVersion, lookupMapping, awNamespace, input.sourcePriority, warnings, input.projectPath),
+                    svc.remapSignatureMembers(sig.fields, "field", resolvedVersion, lookupMapping, awNamespace, input.sourcePriority, warnings, input.projectPath)
+                ]);
+                constructors = ctorResult.members;
+                methods = methodResult.members;
+                fields = fieldResult.members;
+            }
+            membersByClass.set(fqn, {
+                className: fqn,
+                classAccessFlags: sig.classAccessFlags,
+                constructors,
+                methods,
+                fields
+            });
+        }
+        catch {
+            warnings.push(`Could not load signature for class "${lookupFqn}".`);
+        }
+    }
+    const result = validateParsedAccessWidener(parsed, membersByClass, warnings, {
+        includeRuntimeEvidence: runtimeAware
+    });
+    if (provenance) {
+        result.provenance = provenance;
+    }
+    return result;
+}
+export async function validateAccessTransformer(svc, input) {
+    const version = input.version.trim();
+    if (!version) {
+        throw createError({ code: ERROR_CODES.INVALID_INPUT, message: "version must be non-empty." });
+    }
+    const content = input.content;
+    if (!content.trim()) {
+        throw createError({ code: ERROR_CODES.INVALID_INPUT, message: "content must be non-empty." });
+    }
+    const warnings = [];
+    const parsed = parseAccessTransformer(content);
+    const atNamespace = await svc.resolveAccessTransformerNamespace({
+        atNamespace: input.atNamespace,
+        projectPath: input.projectPath
+    });
+    const runtimeAware = input.projectPath != null || input.scope != null || input.preferProjectVersion === true;
+    let resolvedVersion = version;
+    let jarPath;
+    let lookupMapping = "obfuscated";
+    let provenance;
+    if (runtimeAware) {
+        provenance = await svc.resolveAccessTransformerRuntimeArtifact({
+            version,
+            atNamespace,
+            projectPath: input.projectPath,
+            scope: input.scope,
+            preferProjectVersion: input.preferProjectVersion
+        });
+        resolvedVersion = provenance.version;
+        jarPath = provenance.jarPath;
+        lookupMapping = provenance.mappingApplied;
+    }
+    else {
+        if (atNamespace === "srg") {
+            throw createError({
+                code: ERROR_CODES.INVALID_INPUT,
+                message: "atNamespace=srg requires projectPath and scope=loader so a Forge runtime jar can be resolved."
+            });
+        }
+        ({ jarPath } = await svc.versionService.resolveVersionJar(version));
+    }
+    const needsLookupMapping = atNamespace !== lookupMapping;
+    const classFqns = new Set(parsed.entries.map((entry) => entry.owner));
+    const membersByClass = new Map();
+    for (const fqn of classFqns) {
+        let lookupFqn = fqn;
+        if (needsLookupMapping) {
+            if (!isSourceMappingNamespace(atNamespace) || !isSourceMappingNamespace(lookupMapping)) {
+                warnings.push(`Could not map class "${fqn}" from ${atNamespace} to ${lookupMapping}.`);
+            }
+            else {
+                try {
+                    const mapped = await svc.mappingService.findMapping({
+                        version: resolvedVersion,
+                        kind: "class",
+                        name: fqn,
+                        sourceMapping: atNamespace,
+                        targetMapping: lookupMapping,
+                        sourcePriority: input.sourcePriority,
+                        projectPath: input.projectPath
+                    });
+                    if (mapped.resolved && mapped.resolvedSymbol) {
+                        lookupFqn = mapped.resolvedSymbol.name;
+                    }
+                    else {
+                        warnings.push(`Could not map class "${fqn}" from ${atNamespace} to ${lookupMapping}.`);
+                    }
+                }
+                catch {
+                    warnings.push(`Mapping lookup failed for class "${fqn}".`);
+                }
+            }
+        }
+        try {
+            const sig = await svc.explorerService.getSignature({
+                fqn: lookupFqn,
+                jarPath,
+                access: "all"
+            });
+            warnings.push(...sig.warnings);
+            let constructors = sig.constructors;
+            let methods = sig.methods;
+            let fields = sig.fields;
+            if (needsLookupMapping && isSourceMappingNamespace(atNamespace) && isSourceMappingNamespace(lookupMapping)) {
+                const [ctorResult, methodResult, fieldResult] = await Promise.all([
+                    svc.remapSignatureMembers(sig.constructors, "method", resolvedVersion, lookupMapping, atNamespace, input.sourcePriority, warnings, input.projectPath),
+                    svc.remapSignatureMembers(sig.methods, "method", resolvedVersion, lookupMapping, atNamespace, input.sourcePriority, warnings, input.projectPath),
+                    svc.remapSignatureMembers(sig.fields, "field", resolvedVersion, lookupMapping, atNamespace, input.sourcePriority, warnings, input.projectPath)
+                ]);
+                constructors = ctorResult.members;
+                methods = methodResult.members;
+                fields = fieldResult.members;
+            }
+            membersByClass.set(fqn, {
+                className: fqn,
+                classAccessFlags: sig.classAccessFlags,
+                constructors,
+                methods,
+                fields
+            });
+        }
+        catch {
+            warnings.push(`Could not load signature for class "${lookupFqn}".`);
+        }
+    }
+    const result = validateParsedAccessTransformer(parsed, membersByClass, warnings, {
+        includeRuntimeEvidence: runtimeAware
+    });
+    if (provenance) {
+        result.provenance = provenance;
+    }
+    return result;
+}
+//# sourceMappingURL=access-validate.js.map

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

@@ -0,0 +1,110 @@
+import type { SourceService } from "../source-service.js";
+import type { ArtifactContentsSummary, ResolveArtifactInput, ResolveArtifactOutput } from "../source-service.js";
+import type { AccessTransformerNamespace, ArtifactProvenance, ArtifactScope, ArtifactTargetKind, ResolvedSourceArtifact, RuntimeValidationProvenance, SourceMapping } from "../types.js";
+import type { WorkspaceProjectLoader } from "../workspace-mapping-service.js";
+export type VersionSourceDiscovery = {
+    searchedPaths: string[];
+    candidateArtifacts: string[];
+    selectedSourceJarPath?: string;
+    selectedHasMinecraftNamespace?: boolean;
+};
+type RuntimeJarCandidate = {
+    jarPath: string;
+    score: number;
+    appliedScope: ArtifactScope;
+    origin: RuntimeValidationProvenance["origin"];
+    namespaceHint?: "intermediary" | "mojang" | "named";
+};
+export type MappingFallbackSuggestion = {
+    suggestedCall?: {
+        tool: string;
+        params: Record<string, unknown>;
+    };
+    exampleCalls?: Array<{
+        tool: string;
+        params: Record<string, unknown>;
+        reason: string;
+    }>;
+    nextAction: string;
+    _suggestedCallPrimaryDropped?: boolean;
+};
+export declare function hasExactVersionToken(path: string, version: string): boolean;
+export declare function discoverVersionSourceJar(_svc: SourceService, input: {
+    version: string;
+    projectPath?: string;
+}): Promise<VersionSourceDiscovery>;
+export declare function discoverAccessWidenerRuntimeCandidates(_svc: SourceService, input: {
+    version: string;
+    projectPath?: string;
+    requestedScope: ArtifactScope;
+}): Promise<{
+    searchedPaths: string[];
+    candidateArtifacts: string[];
+    selected?: RuntimeJarCandidate;
+}>;
+export declare function discoverAccessTransformerRuntimeCandidates(_svc: SourceService, input: {
+    version: string;
+    projectPath?: string;
+    requestedScope: ArtifactScope;
+    atNamespace: AccessTransformerNamespace;
+    loader: WorkspaceProjectLoader | "unknown";
+}): Promise<{
+    searchedPaths: string[];
+    candidateArtifacts: string[];
+    selected?: RuntimeJarCandidate;
+}>;
+export declare function resolveAccessWidenerRuntimeArtifact(svc: SourceService, input: {
+    version: string;
+    awNamespace: SourceMapping;
+    projectPath?: string;
+    scope?: ArtifactScope;
+    preferProjectVersion?: boolean;
+}): Promise<RuntimeValidationProvenance<SourceMapping>>;
+export declare function resolveAccessTransformerNamespace(svc: SourceService, input: {
+    atNamespace?: AccessTransformerNamespace;
+    projectPath?: string;
+}): Promise<AccessTransformerNamespace>;
+export declare function resolveAccessTransformerRuntimeArtifact(svc: SourceService, input: {
+    version: string;
+    atNamespace: AccessTransformerNamespace;
+    projectPath?: string;
+    scope?: ArtifactScope;
+    preferProjectVersion?: boolean;
+}): Promise<RuntimeValidationProvenance<AccessTransformerNamespace>>;
+export declare function inferVersionFromContext(input: {
+    version?: string;
+    provenance?: ArtifactProvenance;
+    coordinate?: string;
+}): string | undefined;
+export declare function resolveVersionContext(svc: SourceService, input: {
+    version?: string;
+    provenance?: ArtifactProvenance;
+    coordinate?: string;
+    projectPath?: string;
+    preferProjectVersion?: boolean;
+    warnings: string[];
+}): Promise<string | undefined>;
+export declare function resolveBinaryFallbackArtifact(svc: SourceService, input: {
+    binaryJarPath?: string;
+    version?: string;
+    coordinate?: string;
+    requestedMapping: SourceMapping;
+    mappingApplied: SourceMapping;
+    provenance?: ArtifactProvenance;
+    qualityFlags: string[];
+}): Promise<ResolvedSourceArtifact | undefined>;
+export declare function buildArtifactContentsSummary(_svc: SourceService, input: {
+    origin: ResolvedSourceArtifact["origin"];
+    sourceJarPath?: string;
+    isDecompiled?: boolean;
+    qualityFlags: string[];
+}): ArtifactContentsSummary;
+export declare function buildMappingFallbackSuggestedCall(svc: SourceService, args: {
+    input: ResolveArtifactInput;
+    kind: ArtifactTargetKind;
+    value: string;
+    scope: ArtifactScope | undefined;
+    effectiveMapping: SourceMapping;
+}): Promise<MappingFallbackSuggestion>;
+export declare function resolveArtifact(svc: SourceService, input: ResolveArtifactInput): Promise<ResolveArtifactOutput>;
+export {};