@adhisang/minecraft-modding-mcp 2.0.0 → 2.1.0

package/dist/tool-execution-gate.js

@@ -0,0 +1,58 @@
+import { createError, ERROR_CODES } from "./errors.js";
+const DEFAULT_OPTIONS = {
+    maxConcurrent: 1,
+    maxQueue: 2
+};
+export class ToolExecutionGate {
+    maxConcurrent;
+    maxQueue;
+    activeCount = 0;
+    queue = [];
+    constructor(options = {}) {
+        this.maxConcurrent = Math.max(1, Math.trunc(options.maxConcurrent ?? DEFAULT_OPTIONS.maxConcurrent));
+        this.maxQueue = Math.max(0, Math.trunc(options.maxQueue ?? DEFAULT_OPTIONS.maxQueue));
+    }
+    run(tool, task) {
+        if (this.activeCount < this.maxConcurrent) {
+            return this.execute({ tool, task: task });
+        }
+        if (this.queue.length >= this.maxQueue) {
+            return Promise.reject(createError({
+                code: ERROR_CODES.LIMIT_EXCEEDED,
+                message: `Heavy tool queue is full; "${tool}" was not started.`,
+                details: {
+                    tool,
+                    activeCount: this.activeCount,
+                    queuedCount: this.queue.length,
+                    maxConcurrent: this.maxConcurrent,
+                    maxQueue: this.maxQueue,
+                    nextAction: "Retry after the current heavy analysis request completes. Avoid sending multiple heavy mapping/version analysis tools in parallel."
+                }
+            }));
+        }
+        return new Promise((resolve, reject) => {
+            this.queue.push({
+                tool,
+                task: task,
+                resolve: resolve,
+                reject
+            });
+        });
+    }
+    execute(entry) {
+        this.activeCount += 1;
+        return Promise.resolve()
+            .then(entry.task)
+            .finally(() => {
+            this.activeCount = Math.max(0, this.activeCount - 1);
+            this.drain();
+        });
+    }
+    drain() {
+        while (this.activeCount < this.maxConcurrent && this.queue.length > 0) {
+            const next = this.queue.shift();
+            this.execute(next).then(next.resolve, next.reject);
+        }
+    }
+}
+//# sourceMappingURL=tool-execution-gate.js.map

package/dist/version-diff-service.js

@@ -22,6 +22,9 @@ function filterByPackage(classes, prefix) {
     const normalized = prefix.endsWith(".") ? prefix : `${prefix}.`;
     return classes.filter((fqn) => fqn.startsWith(normalized));
 }
+function filterSetByPackage(classes, prefix) {
+    return new Set(filterByPackage([...classes], prefix));
+}
 function diffSets(from, to) {
     const added = [];
     const removed = [];
@@ -162,11 +165,13 @@ export class VersionDiffService {
                 ]);
                 const fromClasses = extractClassEntries(fromEntries);
                 const toClasses = extractClassEntries(toEntries);
-                let { added, removed, unchanged } = diffSets(fromClasses, toClasses);
-                if (input.packageFilter) {
-                    added = filterByPackage(added, input.packageFilter);
-                    removed = filterByPackage(removed, input.packageFilter);
-                }
+                const filteredFromClasses = input.packageFilter
+                    ? filterSetByPackage(fromClasses, input.packageFilter)
+                    : fromClasses;
+                const filteredToClasses = input.packageFilter
+                    ? filterSetByPackage(toClasses, input.packageFilter)
+                    : toClasses;
+                const { added, removed, unchanged } = diffSets(filteredFromClasses, filteredToClasses);
                 const truncatedAdded = added.slice(0, maxClassResults);
                 const truncatedRemoved = removed.slice(0, maxClassResults);
                 if (added.length > maxClassResults) {

package/dist/version-service.js

@@ -401,8 +401,13 @@ export class VersionService {
     }
     trimVersionDetailCache() {
         const maxEntries = Math.max(1, this.config.maxVersionDetailCache ?? 256);
-        while (this.versionDetailCache.size > maxEntries) {
-            const oldest = this.versionDetailCache.keys().next().value;
+        const overflow = this.versionDetailCache.size - maxEntries;
+        if (overflow <= 0) {
+            return;
+        }
+        const keyIterator = this.versionDetailCache.keys();
+        for (let index = 0; index < overflow; index += 1) {
+            const oldest = keyIterator.next().value;
             if (!oldest) {
                 return;
             }

package/dist/workspace-mapping-service.js

@@ -22,6 +22,18 @@ function detectMappingsFromContent(content) {
             reason: "mappings net.fabricmc:intermediary"
         });
     }
+    if (/\bid\s*(?:\(\s*)?["']net\.neoforged\.moddev["']\s*\)?/i.test(content)) {
+        detections.push({
+            mapping: "mojang",
+            reason: "net.neoforged.moddev plugin"
+        });
+    }
+    if (/\bneoForge\s*\{[\s\S]*?\bparchment\s*\{/i.test(content)) {
+        detections.push({
+            mapping: "mojang",
+            reason: "neoForge parchment block"
+        });
+    }
     return detections;
 }
 export class WorkspaceMappingService {

package/package.json

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