@adhisang/minecraft-modding-mcp 3.1.1 → 3.2.0

package/dist/tool-contract-manifest.js

@@ -15,7 +15,7 @@ const SECTION_ROWS = {
             "| `analyze-symbol` | Handle symbol existence checks, namespace mapping, lifecycle tracing, workspace symbol resolution, and API overviews |",
             "| `compare-minecraft` | Compare version pairs, class diffs, registry diffs, and migration-oriented summaries |",
             "| `analyze-mod` | Summarize mod metadata, decompile and search mod code, inspect class source, and preview or apply remaps |",
-            "| `validate-project` | Summarize workspaces and run direct Mixin or Access Widener validation |",
+            "| `validate-project` | Summarize workspaces and run direct Mixin, Access Widener, or Access Transformer validation |",
             "| `manage-cache` | List, verify, and preview or apply cache cleanup and rebuild operations |"
         ],
         ja: [
@@ -23,7 +23,7 @@ const SECTION_ROWS = {
             "| `analyze-symbol` | シンボル存在確認、名前空間変換、ライフサイクル追跡、ワークスペースシンボル解決、API 概要をまとめて扱う |",
             "| `compare-minecraft` | バージョン差分、クラス差分、レジストリ差分、移行向け概要を比較する |",
             "| `analyze-mod` | Mod メタデータの要約、Mod コードのデコンパイル / 検索、クラスソース確認、リマップのプレビュー / 実行を扱う |",
-            "| `validate-project` | ワークスペース要約と、Mixin / Access Widener の直接検証を行う |",
+            "| `validate-project` | ワークスペース要約と、Mixin / Access Widener / Access Transformer の直接検証を行う |",
             "| `manage-cache` | キャッシュの一覧、検証、クリーンアップ / 再構築のプレビュー / 実行を行う |"
         ]
     },
@@ -93,14 +93,14 @@ const SECTION_ROWS = {
     },
     "mod-analysis": {
         en: [
-            "| `analyze-mod-jar` | Extract mod metadata, dependencies, entrypoints, and mixin config info from a JAR |",
+            "| `analyze-mod-jar` | Extract mod metadata, dependencies, entrypoints, mixin config info, and packaged access transformer paths from a JAR |",
             "| `decompile-mod-jar` | Decompile a mod JAR and optionally return one class source |",
             "| `get-mod-class-source` | Read one class source from the decompiled mod cache |",
             "| `search-mod-source` | Search decompiled mod source by class, method, field, or content |",
             "| `remap-mod-jar` | Remap a Fabric or Quilt mod JAR to `yarn` or `mojang` names |"
         ],
         ja: [
-            "| `analyze-mod-jar` | JAR から Mod メタデータ、依存関係、エントリポイント、Mixin 設定情報を抽出する |",
+            "| `analyze-mod-jar` | JAR から Mod メタデータ、依存関係、エントリポイント、Mixin 設定情報、同梱 Access Transformer パスを抽出する |",
             "| `decompile-mod-jar` | Mod JAR をデコンパイルし、必要に応じて 1 つのクラスソースを返す |",
             "| `get-mod-class-source` | デコンパイル済み Mod キャッシュから 1 つのクラスソースを読み取る |",
             "| `search-mod-source` | デコンパイル済み Mod ソースを class、method、field、content で検索する |",
@@ -110,11 +110,13 @@ const SECTION_ROWS = {
     "validation": {
         en: [
             "| `validate-mixin` | Validate Mixin source against a target Minecraft version |",
-            "| `validate-access-widener` | Validate Access Widener content against a target Minecraft version |"
+            "| `validate-access-widener` | Validate Access Widener content against a target Minecraft version, optionally using runtime-aware Loom artifacts |",
+            "| `validate-access-transformer` | Validate Access Transformer content against a target Minecraft version, optionally using Forge/NeoForge runtime artifacts |"
         ],
         ja: [
             "| `validate-mixin` | 対象 Minecraft バージョンに対して Mixin ソースを検証する |",
-            "| `validate-access-widener` | 対象 Minecraft バージョンに対して Access Widener の内容を検証する |"
+            "| `validate-access-widener` | 対象 Minecraft バージョンに対して Access Widener の内容を検証し、必要に応じて Loom runtime artifact も使う |",
+            "| `validate-access-transformer` | 対象 Minecraft バージョンに対して Access Transformer の内容を検証し、必要に応じて Forge / NeoForge runtime artifact も使う |"
         ]
     },
     "registry-diagnostics": {

package/dist/types.d.ts

@@ -1,5 +1,7 @@
 export type SourceOrigin = "local-jar" | "local-m2" | "remote-repo" | "decompiled";
 export type SourceMapping = "obfuscated" | "mojang" | "intermediary" | "yarn";
+export type AccessTransformerNamespace = "srg" | "mojang" | "obfuscated";
+export type RuntimeValidationNamespace = SourceMapping | AccessTransformerNamespace;
 export type MappingSourcePriority = "loom-first" | "maven-first";
 export type ArtifactTargetKind = "version" | "jar" | "coordinate";
 export type ArtifactScope = "vanilla" | "merged" | "loader";
@@ -37,6 +39,21 @@ export interface ArtifactProvenance {
     };
     transformChain: string[];
 }
+export interface RuntimeValidationProvenance<TMapping extends RuntimeValidationNamespace = RuntimeValidationNamespace> {
+    version: string;
+    jarPath: string;
+    requestedScope?: ArtifactScope;
+    appliedScope?: ArtifactScope;
+    requestedMapping: TMapping;
+    mappingApplied: TMapping;
+    origin: SourceOrigin | "loom-cache" | "version-jar";
+    resolutionNotes?: string[];
+    scopeFallback?: {
+        requested: string;
+        applied: string;
+        reason: string;
+    };
+}
 export interface ErrorEnvelope {
     code: string;
     message: string;

package/dist/workspace-mapping-service.d.ts

@@ -13,7 +13,20 @@ export type WorkspaceCompileMappingOutput = {
     evidence: WorkspaceMappingEvidence[];
     warnings: string[];
 };
+export type WorkspaceProjectLoader = "fabric" | "quilt" | "forge" | "neoforge" | "unknown";
+export type WorkspaceLoaderEvidence = {
+    filePath: string;
+    loader: WorkspaceProjectLoader;
+    reason: string;
+};
+export type WorkspaceProjectLoaderOutput = {
+    resolved: boolean;
+    loader?: WorkspaceProjectLoader;
+    evidence: WorkspaceLoaderEvidence[];
+    warnings: string[];
+};
 export declare class WorkspaceMappingService {
     detectCompileMapping(input: WorkspaceCompileMappingInput): Promise<WorkspaceCompileMappingOutput>;
     detectProjectMinecraftVersion(projectPath: string): Promise<string | undefined>;
+    detectProjectLoader(projectPath: string): Promise<WorkspaceProjectLoaderOutput>;
 }

package/dist/workspace-mapping-service.js

@@ -1,7 +1,9 @@
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import fastGlob from "fast-glob";
+import { mapWithConcurrencyLimit } from "./concurrency.js";
 import { createError, ERROR_CODES } from "./errors.js";
+const WORKSPACE_FILE_READ_CONCURRENCY = 4;
 function detectMappingsFromContent(content) {
     const detections = [];
     if (/officialMojangMappings\s*\(/i.test(content)) {
@@ -36,6 +38,46 @@ function detectMappingsFromContent(content) {
     }
     return detections;
 }
+function detectLoadersFromContent(content) {
+    const detections = [];
+    if (/\bid\s*(?:\(\s*)?["']net\.neoforged\.moddev["']\s*\)?/i.test(content)) {
+        detections.push({
+            loader: "neoforge",
+            reason: "net.neoforged.moddev plugin"
+        });
+    }
+    if (/\bid\s*(?:\(\s*)?["']net\.minecraftforge\.gradle["']\s*\)?/i.test(content)) {
+        detections.push({
+            loader: "forge",
+            reason: "net.minecraftforge.gradle plugin"
+        });
+    }
+    if (/\bid\s*(?:\(\s*)?["']org\.quiltmc\.loom["']\s*\)?/i.test(content)) {
+        detections.push({
+            loader: "quilt",
+            reason: "org.quiltmc.loom plugin"
+        });
+    }
+    if (/\bid\s*(?:\(\s*)?["']fabric-loom["']\s*\)?/i.test(content) || /\bid\s*(?:\(\s*)?["']dev\.architectury\.loom["']\s*\)?/i.test(content)) {
+        detections.push({
+            loader: "fabric",
+            reason: "fabric/dev.architectury loom plugin"
+        });
+    }
+    if (/\bminecraft\s*\{[\s\S]*?\baccessTransformer\b/i.test(content)) {
+        detections.push({
+            loader: "forge",
+            reason: "minecraft { accessTransformer ... } block"
+        });
+    }
+    if (/\bneoForge\s*\{[\s\S]*?\baccessTransformers\b/i.test(content)) {
+        detections.push({
+            loader: "neoforge",
+            reason: "neoForge { accessTransformers ... } block"
+        });
+    }
+    return detections;
+}
 export class WorkspaceMappingService {
     async detectCompileMapping(input) {
         const projectPath = input.projectPath?.trim();
@@ -49,30 +91,26 @@ export class WorkspaceMappingService {
             });
         }
         const root = resolve(projectPath);
-        const files = fastGlob.sync(["build.gradle", "build.gradle.kts", "**/build.gradle", "**/build.gradle.kts"], {
+        const files = (await fastGlob.glob(["build.gradle", "build.gradle.kts", "**/build.gradle", "**/build.gradle.kts"], {
             cwd: root,
             absolute: true,
             onlyFiles: true,
             ignore: ["**/.git/**", "**/.gradle/**", "**/build/**", "**/out/**", "**/node_modules/**"]
-        });
-        const evidence = [];
-        for (const filePath of files.sort((left, right) => left.localeCompare(right))) {
+        })).sort((left, right) => left.localeCompare(right));
+        const evidence = (await mapWithConcurrencyLimit(files, WORKSPACE_FILE_READ_CONCURRENCY, async (filePath) => {
             let content;
             try {
                 content = await readFile(filePath, "utf8");
             }
             catch {
-                continue;
+                return [];
             }
-            const detections = detectMappingsFromContent(content);
-            for (const detection of detections) {
-                evidence.push({
-                    filePath,
-                    mapping: detection.mapping,
-                    reason: detection.reason
-                });
-            }
-        }
+            return detectMappingsFromContent(content).map((detection) => ({
+                filePath,
+                mapping: detection.mapping,
+                reason: detection.reason
+            }));
+        })).flat();
         if (evidence.length === 0) {
             return {
                 resolved: false,
@@ -121,5 +159,99 @@ export class WorkspaceMappingService {
         }
         return undefined;
     }
+    async detectProjectLoader(projectPath) {
+        const root = resolve(projectPath);
+        const buildFiles = (await fastGlob.glob(["build.gradle", "build.gradle.kts", "**/build.gradle", "**/build.gradle.kts"], {
+            cwd: root,
+            absolute: true,
+            onlyFiles: true,
+            ignore: ["**/.git/**", "**/.gradle/**", "**/build/**", "**/out/**", "**/node_modules/**"]
+        })).sort((left, right) => left.localeCompare(right));
+        const descriptorFiles = (await fastGlob.glob([
+            "fabric.mod.json",
+            "quilt.mod.json",
+            "META-INF/mods.toml",
+            "META-INF/neoforge.mods.toml",
+            "**/fabric.mod.json",
+            "**/quilt.mod.json",
+            "**/META-INF/mods.toml",
+            "**/META-INF/neoforge.mods.toml"
+        ], {
+            cwd: root,
+            absolute: true,
+            onlyFiles: true,
+            ignore: ["**/.git/**", "**/.gradle/**", "**/build/**", "**/out/**", "**/node_modules/**"]
+        })).sort((left, right) => left.localeCompare(right));
+        const evidence = (await mapWithConcurrencyLimit(buildFiles, WORKSPACE_FILE_READ_CONCURRENCY, async (filePath) => {
+            let content;
+            try {
+                content = await readFile(filePath, "utf8");
+            }
+            catch {
+                return [];
+            }
+            return detectLoadersFromContent(content).map((detection) => ({
+                filePath,
+                loader: detection.loader,
+                reason: detection.reason
+            }));
+        })).flat();
+        for (const descriptorPath of descriptorFiles) {
+            const normalized = descriptorPath.replaceAll("\\", "/");
+            if (normalized.endsWith("fabric.mod.json")) {
+                evidence.push({
+                    filePath: descriptorPath,
+                    loader: "fabric",
+                    reason: "fabric.mod.json"
+                });
+            }
+            else if (normalized.endsWith("quilt.mod.json")) {
+                evidence.push({
+                    filePath: descriptorPath,
+                    loader: "quilt",
+                    reason: "quilt.mod.json"
+                });
+            }
+            else if (normalized.endsWith("META-INF/neoforge.mods.toml")) {
+                evidence.push({
+                    filePath: descriptorPath,
+                    loader: "neoforge",
+                    reason: "META-INF/neoforge.mods.toml"
+                });
+            }
+            else if (normalized.endsWith("META-INF/mods.toml")) {
+                evidence.push({
+                    filePath: descriptorPath,
+                    loader: "forge",
+                    reason: "META-INF/mods.toml"
+                });
+            }
+        }
+        if (evidence.length === 0) {
+            return {
+                resolved: false,
+                evidence,
+                warnings: ["No workspace loader declaration was detected from build.gradle(.kts) files or mod descriptors."]
+            };
+        }
+        const loaderSet = new Set(evidence
+            .map((entry) => entry.loader)
+            .filter((loader) => loader !== "unknown"));
+        if (loaderSet.size !== 1) {
+            return {
+                resolved: false,
+                evidence,
+                warnings: [
+                    `Multiple or ambiguous workspace loaders were detected: ${[...loaderSet].join(", ") || "unknown"}.`
+                ]
+            };
+        }
+        return {
+            resolved: true,
+            loader: [...loaderSet][0],
+            evidence,
+            warnings: []
+        };
+    }
 }
 //# sourceMappingURL=workspace-mapping-service.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhisang/minecraft-modding-mcp",
-  "version": "3.1.1",
+  "version": "3.2.0",
   "description": "MCP server with utilities for Minecraft modding workflows",
   "type": "module",
   "main": "dist/index.js",