@adhisang/minecraft-modding-mcp 3.1.1 → 3.2.0

package/dist/entry-tools/validate-project-service.js

@@ -2,12 +2,14 @@ import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import fastGlob from "fast-glob";
 import { z } from "zod";
+import { mapWithConcurrencyLimit } from "../concurrency.js";
 import { createError, ERROR_CODES } from "../errors.js";
 import { buildIncludeSchema, detailSchema } from "./entry-tool-schema.js";
 import { buildEntryToolResult, createSummarySubject } from "./response-contract.js";
 import { resolveDetail, resolveInclude } from "./request-normalizers.js";
 const nonEmptyString = z.string().trim().min(1);
 const INCLUDE_GROUPS = ["warnings", "issues", "workspace", "recovery"];
+const WORKSPACE_TEXT_FILE_READ_CONCURRENCY = 4;
 const mixinInputSchema = z.discriminatedUnion("mode", [
     z.object({ mode: z.literal("inline"), source: nonEmptyString }),
     z.object({ mode: z.literal("path"), path: nonEmptyString }),
@@ -19,11 +21,15 @@ const accessWidenerInputSchema = z.discriminatedUnion("mode", [
     z.object({ mode: z.literal("inline"), content: nonEmptyString }),
     z.object({ mode: z.literal("path"), path: nonEmptyString })
 ]);
+const accessTransformerInputSchema = z.discriminatedUnion("mode", [
+    z.object({ mode: z.literal("inline"), content: nonEmptyString }),
+    z.object({ mode: z.literal("path"), path: nonEmptyString })
+]);
 const subjectSchema = z.discriminatedUnion("kind", [
     z.object({
         kind: z.literal("workspace"),
         projectPath: nonEmptyString,
-        discover: z.array(z.enum(["mixins", "access-wideners"])).optional()
+        discover: z.array(z.enum(["mixins", "access-wideners", "access-transformers"])).optional()
     }),
     z.object({
         kind: z.literal("mixin"),
@@ -32,13 +38,18 @@ const subjectSchema = z.discriminatedUnion("kind", [
     z.object({
         kind: z.literal("access-widener"),
         input: accessWidenerInputSchema
+    }),
+    z.object({
+        kind: z.literal("access-transformer"),
+        input: accessTransformerInputSchema
     })
 ]);
 export const validateProjectShape = {
-    task: z.enum(["project-summary", "mixin", "access-widener"]),
+    task: z.enum(["project-summary", "mixin", "access-widener", "access-transformer"]),
     subject: subjectSchema,
     version: nonEmptyString.optional(),
     mapping: z.enum(["obfuscated", "mojang", "intermediary", "yarn"]).optional(),
+    atNamespace: z.enum(["srg", "mojang", "obfuscated"]).optional(),
     sourcePriority: z.enum(["loom-first", "maven-first"]).optional(),
     scope: z.enum(["vanilla", "merged", "loader"]).optional(),
     preferProjectVersion: z.boolean().optional(),
@@ -77,6 +88,13 @@ export const validateProjectSchema = z.object(validateProjectShape).superRefine(
             message: "task=access-widener requires subject.kind=access-widener."
         });
     }
+    if (value.task === "access-transformer" && value.subject.kind !== "access-transformer") {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["subject", "kind"],
+            message: "task=access-transformer requires subject.kind=access-transformer."
+        });
+    }
     if (value.configPaths?.length && value.task !== "project-summary") {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
@@ -89,33 +107,153 @@ export async function discoverWorkspaceMixins(projectPath, configPaths) {
     if (configPaths?.length) {
         return [...configPaths];
     }
-    return fastGlob.sync(["**/*.mixins.json"], {
+    return (await fastGlob.glob(["**/*.mixins.json"], {
         cwd: projectPath,
         absolute: true,
         onlyFiles: true,
         ignore: ["**/.git/**", "**/build/**", "**/out/**", "**/node_modules/**"]
-    });
+    })).sort((left, right) => left.localeCompare(right));
 }
 export async function discoverWorkspaceAccessWideners(projectPath) {
-    const descriptorFiles = fastGlob.sync(["fabric.mod.json", "quilt.mod.json", "**/fabric.mod.json", "**/quilt.mod.json"], {
+    const descriptorFiles = (await fastGlob.glob(["fabric.mod.json", "quilt.mod.json", "**/fabric.mod.json", "**/quilt.mod.json"], {
         cwd: projectPath,
         absolute: true,
         onlyFiles: true,
         ignore: ["**/.git/**", "**/build/**", "**/out/**", "**/node_modules/**"]
-    });
+    })).sort((left, right) => left.localeCompare(right));
     const discovered = new Set();
-    for (const descriptorPath of descriptorFiles) {
+    const matches = await mapWithConcurrencyLimit(descriptorFiles, WORKSPACE_TEXT_FILE_READ_CONCURRENCY, async (descriptorPath) => {
         try {
             const parsed = JSON.parse(await readFile(descriptorPath, "utf8"));
             const relative = parsed.accessWidener ?? parsed.access_widener;
-            if (relative) {
-                discovered.add(resolve(descriptorPath, "..", relative));
+            return relative ? [resolve(descriptorPath, "..", relative)] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+    for (const matchList of matches) {
+        for (const match of matchList) {
+            discovered.add(match);
+        }
+    }
+    return [...discovered].sort((left, right) => left.localeCompare(right));
+}
+function addDiscoveredPath(discovered, filePath, relativePath) {
+    const trimmed = relativePath?.trim();
+    if (!trimmed) {
+        return;
+    }
+    discovered.add(resolve(filePath, "..", trimmed));
+}
+function collectFileArgumentMatches(content, filePath, discovered, pattern) {
+    for (const match of content.matchAll(pattern)) {
+        addDiscoveredPath(discovered, filePath, match[2]);
+    }
+}
+function extractNamedDslBlocks(content, blockName) {
+    const blocks = [];
+    const blockPattern = new RegExp(`${blockName}\\s*\\{`, "g");
+    for (const match of content.matchAll(blockPattern)) {
+        const blockStart = (match.index ?? -1) + match[0].length;
+        if (blockStart < match[0].length) {
+            continue;
+        }
+        let depth = 1;
+        for (let index = blockStart; index < content.length; index++) {
+            const char = content[index];
+            if (char === "{") {
+                depth++;
             }
+            else if (char === "}") {
+                depth--;
+            }
+            if (depth === 0) {
+                blocks.push(content.slice(blockStart, index));
+                break;
+            }
+        }
+    }
+    return blocks;
+}
+function collectTomlAccessTransformerEntries(content, filePath, discovered) {
+    const lines = content.split(/\r?\n/);
+    let currentBlock = [];
+    const flushBlock = () => {
+        if (currentBlock.length === 0) {
+            return;
+        }
+        for (const match of currentBlock.join("\n").matchAll(/^\s*file\s*=\s*(["'])(.+?)\1\s*$/gm)) {
+            addDiscoveredPath(discovered, filePath, match[2]);
+        }
+        currentBlock = [];
+    };
+    for (const line of lines) {
+        if (/^\s*\[\[accessTransformers\]\]\s*$/.test(line)) {
+            flushBlock();
+            currentBlock.push(line);
+            continue;
+        }
+        if (currentBlock.length > 0 && /^\s*(?:\[\[.*\]\]|\[[^\[])/.test(line)) {
+            flushBlock();
+        }
+        if (currentBlock.length > 0) {
+            currentBlock.push(line);
+        }
+    }
+    flushBlock();
+}
+export async function discoverWorkspaceAccessTransformers(projectPath) {
+    const discovered = new Set();
+    const textFiles = (await fastGlob.glob([
+        "build.gradle",
+        "build.gradle.kts",
+        "META-INF/mods.toml",
+        "META-INF/neoforge.mods.toml",
+        "**/build.gradle",
+        "**/build.gradle.kts",
+        "**/META-INF/mods.toml",
+        "**/META-INF/neoforge.mods.toml"
+    ], {
+        cwd: projectPath,
+        absolute: true,
+        onlyFiles: true,
+        ignore: ["**/.git/**", "**/build/**", "**/out/**", "**/node_modules/**"]
+    })).sort((left, right) => left.localeCompare(right));
+    const discoveredByFile = await mapWithConcurrencyLimit(textFiles, WORKSPACE_TEXT_FILE_READ_CONCURRENCY, async (filePath) => {
+        let content;
+        try {
+            content = await readFile(filePath, "utf8");
         }
         catch {
-            // ignore malformed descriptors in discovery mode
+            return [];
+        }
+        const perFileDiscovered = new Set();
+        collectFileArgumentMatches(content, filePath, perFileDiscovered, /accessTransformer\s*=\s*file\(\s*(["'])(.+?)\1\s*\)/g);
+        collectFileArgumentMatches(content, filePath, perFileDiscovered, /accessTransformers\.from\s*\(\s*file\(\s*(["'])(.+?)\1\s*\)\s*\)/g);
+        for (const block of extractNamedDslBlocks(content, "accessTransformers")) {
+            collectFileArgumentMatches(block, filePath, perFileDiscovered, /file\(\s*(["'])(.+?)\1\s*\)/g);
+        }
+        collectTomlAccessTransformerEntries(content, filePath, perFileDiscovered);
+        return [...perFileDiscovered];
+    });
+    for (const matchList of discoveredByFile) {
+        for (const match of matchList) {
+            discovered.add(match);
         }
     }
+    for (const fallbackPath of (await fastGlob.glob([
+        "**/META-INF/accesstransformer.cfg",
+        "**/*_at.cfg",
+        "**/accesstransformer*.cfg"
+    ], {
+        cwd: projectPath,
+        absolute: true,
+        onlyFiles: true,
+        ignore: ["**/.git/**", "**/build/**", "**/out/**", "**/node_modules/**"]
+    })).sort((left, right) => left.localeCompare(right))) {
+        discovered.add(fallbackPath);
+    }
     return [...discovered].sort((left, right) => left.localeCompare(right));
 }
 export class ValidateProjectService {
@@ -202,7 +340,9 @@ export class ValidateProjectService {
                     content,
                     version: input.version,
                     mapping: input.mapping,
-                    sourcePriority: input.sourcePriority
+                    sourcePriority: input.sourcePriority,
+                    scope: input.scope,
+                    preferProjectVersion: input.preferProjectVersion
                 });
                 return {
                     ...buildEntryToolResult({
@@ -242,6 +382,77 @@ export class ValidateProjectService {
                     warnings: Array.isArray(output.warnings) ? output.warnings : []
                 };
             }
+            case "access-transformer": {
+                if (input.subject.kind !== "access-transformer") {
+                    throw createError({
+                        code: ERROR_CODES.INVALID_INPUT,
+                        message: "task=access-transformer requires subject.kind=access-transformer."
+                    });
+                }
+                const content = input.subject.input.mode === "inline"
+                    ? input.subject.input.content
+                    : await readFile(input.subject.input.path, "utf8");
+                if (!this.deps.validateAccessTransformer) {
+                    throw createError({
+                        code: ERROR_CODES.CONTEXT_UNRESOLVED,
+                        message: "Access Transformer validation is not configured."
+                    });
+                }
+                const output = await this.deps.validateAccessTransformer({
+                    content,
+                    version: input.version,
+                    atNamespace: input.atNamespace,
+                    sourcePriority: input.sourcePriority,
+                    scope: input.scope,
+                    preferProjectVersion: input.preferProjectVersion
+                });
+                const issueEntries = Array.isArray(output.entries)
+                    ? output.entries.filter((entry) => {
+                        if (!entry || typeof entry !== "object" || !("valid" in entry)) {
+                            return true;
+                        }
+                        return entry.valid !== true;
+                    })
+                    : undefined;
+                return {
+                    ...buildEntryToolResult({
+                        task: "access-transformer",
+                        detail,
+                        include,
+                        summary: {
+                            status: output.valid ? "ok" : "invalid",
+                            headline: output.valid
+                                ? "Access Transformer is valid."
+                                : "Access Transformer contains validation issues.",
+                            subject: createSummarySubject({
+                                task: "access-transformer",
+                                kind: input.subject.kind,
+                                input: input.subject.input,
+                                version: input.version,
+                                sourcePriority: input.sourcePriority,
+                                scope: input.scope,
+                                atNamespace: input.atNamespace
+                            }),
+                            counts: {
+                                valid: output.valid ? 1 : 0,
+                                invalid: output.valid ? 0 : 1
+                            }
+                        },
+                        blocks: {
+                            project: {
+                                summary: {
+                                    total: 1,
+                                    valid: output.valid ? 1 : 0,
+                                    invalid: output.valid ? 0 : 1
+                                }
+                            },
+                            issues: include.includes("issues") || detail !== "summary" ? issueEntries : undefined
+                        },
+                        alwaysBlocks: ["project"]
+                    }),
+                    warnings: Array.isArray(output.warnings) ? output.warnings : []
+                };
+            }
             case "project-summary": {
                 if (input.subject.kind !== "workspace") {
                     throw createError({
@@ -269,10 +480,12 @@ export class ValidateProjectService {
                                         tool: "validate-project",
                                         params: {
                                             task: "project-summary",
-                                            version: "1.21.10",
                                             subject: input.subject
                                         }
                                     }
+                                ],
+                                notes: [
+                                    "Pass version explicitly, or retry with preferProjectVersion=true when gradle.properties declares the Minecraft version."
                                 ]
                             },
                             blocks: {
@@ -285,15 +498,98 @@ export class ValidateProjectService {
                     };
                 }
                 const projectPath = input.subject.projectPath;
+                const detectedProjectVersion = input.preferProjectVersion
+                    ? await this.deps.detectProjectMinecraftVersion?.(projectPath)
+                    : undefined;
+                const resolvedVersion = detectedProjectVersion ?? input.version;
                 const discover = input.subject.discover ?? ["mixins", "access-wideners"];
-                const [mixinConfigs, accessWideners] = await Promise.all([
+                const [mixinConfigs, accessWideners, accessTransformers] = await Promise.all([
                     discover.includes("mixins")
                         ? this.deps.discoverMixins(projectPath, input.configPaths)
                         : Promise.resolve([]),
                     discover.includes("access-wideners")
                         ? this.deps.discoverAccessWideners(projectPath)
+                        : Promise.resolve([]),
+                    discover.includes("access-transformers")
+                        ? this.deps.discoverAccessTransformers?.(projectPath) ?? Promise.resolve([])
                         : Promise.resolve([])
                 ]);
+                if (!resolvedVersion && (mixinConfigs.length > 0 || accessWideners.length > 0 || accessTransformers.length > 0)) {
+                    return {
+                        ...buildEntryToolResult({
+                            task: "project-summary",
+                            detail,
+                            include,
+                            summary: {
+                                status: "blocked",
+                                headline: "Could not resolve Minecraft version for discovered workspace validators.",
+                                subject: createSummarySubject({
+                                    task: "project-summary",
+                                    kind: input.subject.kind,
+                                    projectPath,
+                                    discover: input.subject.discover,
+                                    mapping: input.mapping,
+                                    sourcePriority: input.sourcePriority,
+                                    scope: input.scope
+                                }),
+                                nextActions: [
+                                    {
+                                        tool: "validate-project",
+                                        params: {
+                                            task: "project-summary",
+                                            subject: input.subject
+                                        }
+                                    }
+                                ],
+                                notes: [
+                                    "Pass version explicitly, or make sure gradle.properties declares the Minecraft version before using preferProjectVersion=true."
+                                ]
+                            },
+                            blocks: {
+                                workspace: {
+                                    projectPath
+                                }
+                            }
+                        }),
+                        warnings: [
+                            "Could not resolve Minecraft version from gradle.properties for discovered workspace validators."
+                        ]
+                    };
+                }
+                if (!resolvedVersion) {
+                    return {
+                        ...buildEntryToolResult({
+                            task: "project-summary",
+                            detail,
+                            include,
+                            summary: {
+                                status: "ok",
+                                headline: `Validated ${mixinConfigs.length} mixin config(s), ${accessWideners.length} access widener(s), and ${accessTransformers.length} access transformer(s).`,
+                                subject: createSummarySubject({
+                                    task: "project-summary",
+                                    kind: input.subject.kind,
+                                    projectPath,
+                                    discover: input.subject.discover,
+                                    mapping: input.mapping,
+                                    sourcePriority: input.sourcePriority,
+                                    scope: input.scope
+                                }),
+                                counts: {
+                                    valid: 0,
+                                    partial: 0,
+                                    invalid: 0
+                                }
+                            },
+                            blocks: {
+                                workspace: {
+                                    projectPath
+                                }
+                            }
+                        }),
+                        warnings: []
+                    };
+                }
+                const validationVersion = resolvedVersion;
                 const warnings = [];
                 let validMixins = 0;
                 let partialMixins = 0;
@@ -305,11 +601,12 @@ export class ValidateProjectService {
                                 mode: "config",
                                 configPaths: [configPath]
                             },
-                            version: input.version,
+                            version: validationVersion,
                             mapping: input.mapping,
                             sourcePriority: input.sourcePriority,
                             scope: input.scope,
-                            preferProjectVersion: input.preferProjectVersion,
+                            projectPath,
+                            preferProjectVersion: false,
                             preferProjectMapping: input.preferProjectMapping,
                             sourceRoots: input.sourceRoots,
                             minSeverity: input.minSeverity,
@@ -341,9 +638,12 @@ export class ValidateProjectService {
                     try {
                         const output = await this.deps.validateAccessWidener({
                             content: await readFile(awPath, "utf8"),
-                            version: input.version,
+                            version: validationVersion,
                             mapping: input.mapping,
-                            sourcePriority: input.sourcePriority
+                            sourcePriority: input.sourcePriority,
+                            projectPath,
+                            scope: input.scope,
+                            preferProjectVersion: input.preferProjectVersion
                         });
                         if (output.valid) {
                             validAw += 1;
@@ -362,7 +662,43 @@ export class ValidateProjectService {
                         }
                     }
                 }
-                const invalidCount = invalidMixins + invalidAw;
+                let validAt = 0;
+                let invalidAt = 0;
+                for (const atPath of accessTransformers) {
+                    try {
+                        if (!this.deps.validateAccessTransformer) {
+                            throw createError({
+                                code: ERROR_CODES.CONTEXT_UNRESOLVED,
+                                message: "Access Transformer validation is not configured."
+                            });
+                        }
+                        const output = await this.deps.validateAccessTransformer({
+                            content: await readFile(atPath, "utf8"),
+                            version: validationVersion,
+                            atNamespace: input.atNamespace,
+                            sourcePriority: input.sourcePriority,
+                            projectPath,
+                            scope: input.scope,
+                            preferProjectVersion: input.preferProjectVersion
+                        });
+                        if (output.valid) {
+                            validAt += 1;
+                        }
+                        else {
+                            invalidAt += 1;
+                        }
+                        if (Array.isArray(output.warnings)) {
+                            warnings.push(...output.warnings);
+                        }
+                    }
+                    catch (error) {
+                        invalidAt += 1;
+                        if (error instanceof Error) {
+                            warnings.push(error.message);
+                        }
+                    }
+                }
+                const invalidCount = invalidMixins + invalidAw + invalidAt;
                 const partialCount = partialMixins;
                 const status = invalidCount > 0 ? "invalid" : partialCount > 0 ? "partial" : "ok";
                 return {
@@ -372,19 +708,19 @@ export class ValidateProjectService {
                         include,
                         summary: {
                             status,
-                            headline: `Validated ${mixinConfigs.length} mixin config(s) and ${accessWideners.length} access widener(s).`,
+                            headline: `Validated ${mixinConfigs.length} mixin config(s), ${accessWideners.length} access widener(s), and ${accessTransformers.length} access transformer(s).`,
                             subject: createSummarySubject({
                                 task: "project-summary",
                                 kind: input.subject.kind,
                                 projectPath,
                                 discover: input.subject.discover,
-                                version: input.version,
+                                version: resolvedVersion,
                                 mapping: input.mapping,
                                 sourcePriority: input.sourcePriority,
                                 scope: input.scope
                             }),
                             counts: {
-                                valid: validMixins + validAw,
+                                valid: validMixins + validAw + validAt,
                                 partial: partialCount,
                                 invalid: invalidCount
                             }
@@ -392,7 +728,7 @@ export class ValidateProjectService {
                         blocks: {
                             project: {
                                 summary: {
-                                    valid: validMixins + validAw,
+                                    valid: validMixins + validAw + validAt,
                                     partial: partialCount,
                                     invalid: invalidCount
                                 }
@@ -400,7 +736,8 @@ export class ValidateProjectService {
                             workspace: {
                                 projectPath,
                                 mixinConfigs,
-                                accessWideners
+                                accessWideners,
+                                accessTransformers
                             }
                         },
                         alwaysBlocks: ["project"]

package/dist/gradle-paths.d.ts

@@ -0,0 +1,4 @@
+export declare function normalizeOptionalProjectPath(projectPath: string | undefined): string | undefined;
+export declare function resolveGradleUserHomePath(): string;
+export declare function buildVersionSourceSearchRoots(projectPath: string | undefined): string[];
+export declare function buildLoaderRuntimeSearchRoots(projectPath: string | undefined): string[];

package/dist/gradle-paths.js

@@ -0,0 +1,57 @@
+import { homedir } from "node:os";
+import { dirname, isAbsolute, resolve as resolvePath } from "node:path";
+import { normalizePathForHost } from "./path-converter.js";
+export function normalizeOptionalProjectPath(projectPath) {
+    if (!projectPath) {
+        return undefined;
+    }
+    const trimmed = projectPath.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const normalized = normalizePathForHost(trimmed, undefined, "projectPath");
+    return isAbsolute(normalized) ? normalized : resolvePath(process.cwd(), normalized);
+}
+export function resolveGradleUserHomePath() {
+    const configured = process.env.GRADLE_USER_HOME?.trim();
+    if (!configured) {
+        return resolvePath(homedir(), ".gradle");
+    }
+    const normalized = normalizePathForHost(configured, undefined, "GRADLE_USER_HOME");
+    return isAbsolute(normalized) ? normalized : resolvePath(process.cwd(), normalized);
+}
+export function buildVersionSourceSearchRoots(projectPath) {
+    const roots = new Set();
+    if (projectPath) {
+        roots.add(resolvePath(projectPath, ".gradle", "loom-cache"));
+        roots.add(resolvePath(projectPath, ".gradle-user", "caches", "fabric-loom"));
+        roots.add(resolvePath(projectPath, ".gradle", "caches", "fabric-loom"));
+        const projectParent = dirname(projectPath);
+        roots.add(resolvePath(projectParent, ".gradle-user-home", "loom-cache"));
+        roots.add(resolvePath(projectParent, ".gradle-user-home", "caches", "fabric-loom"));
+    }
+    const homeGradle = resolveGradleUserHomePath();
+    roots.add(resolvePath(homeGradle, "loom-cache"));
+    roots.add(resolvePath(homeGradle, "caches", "fabric-loom"));
+    return [...roots];
+}
+export function buildLoaderRuntimeSearchRoots(projectPath) {
+    const roots = new Set();
+    if (projectPath) {
+        roots.add(resolvePath(projectPath, "build"));
+        roots.add(resolvePath(projectPath, ".gradle"));
+        roots.add(resolvePath(projectPath, ".gradle", "forge-userdev"));
+        roots.add(resolvePath(projectPath, ".gradle", "neogradle"));
+        roots.add(resolvePath(projectPath, ".gradle", "caches", "forge_gradle"));
+        roots.add(resolvePath(projectPath, ".gradle", "caches", "neogradle"));
+        roots.add(resolvePath(projectPath, ".gradle", "caches", "neoformruntime"));
+        roots.add(resolvePath(projectPath, ".gradle", "caches", "moddev"));
+    }
+    const homeGradle = resolveGradleUserHomePath();
+    roots.add(resolvePath(homeGradle, "caches", "forge_gradle"));
+    roots.add(resolvePath(homeGradle, "caches", "neogradle"));
+    roots.add(resolvePath(homeGradle, "caches", "neoformruntime"));
+    roots.add(resolvePath(homeGradle, "caches", "moddev"));
+    return [...roots];
+}
+//# sourceMappingURL=gradle-paths.js.map