@adhisang/minecraft-modding-mcp 4.0.0 → 4.1.1

package/dist/types.d.ts

@@ -10,6 +10,19 @@ export interface SourceTargetInput {
     kind: ArtifactTargetKind;
     value: string;
 }
+export type WorkspaceTargetInput = {
+    kind: "workspace";
+    scope?: ArtifactScope;
+    strict?: boolean;
+};
+export type DependencyTargetInput = {
+    kind: "dependency";
+    group: string;
+    name: string;
+    version?: string;
+    versionFromProject?: boolean;
+};
+export type ResolveArtifactTargetInput = SourceTargetInput | WorkspaceTargetInput | DependencyTargetInput;
 export interface ResolvedSourceArtifact {
     artifactId: string;
     artifactAlias?: string;
@@ -28,6 +41,26 @@ export interface ResolvedSourceArtifact {
     isDecompiled: boolean;
     resolvedAt: string;
 }
+export interface WorkspaceResolutionProvenance {
+    projectPath: string;
+    detected: {
+        minecraftVersion?: string;
+        compileMapping?: SourceMapping;
+        loader?: string;
+    };
+    source: string;
+    cacheHit: boolean;
+    warnings?: string[];
+}
+export interface DependencyResolutionProvenance {
+    group: string;
+    name: string;
+    resolvedVersion?: string;
+    source: string;
+    candidatesSeen?: string[];
+    attempts?: string[];
+    cacheHit: boolean;
+}
 export interface ArtifactProvenance {
     target: SourceTargetInput;
     resolvedAt: string;
@@ -40,6 +73,9 @@ export interface ArtifactProvenance {
         repoUrl?: string;
     };
     transformChain: string[];
+    workspaceResolution?: WorkspaceResolutionProvenance;
+    dependencyResolution?: DependencyResolutionProvenance;
+    warnings?: string[];
 }
 export interface RuntimeValidationProvenance<TMapping extends RuntimeValidationNamespace = RuntimeValidationNamespace> {
     version: string;

package/dist/version-service.js

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
+import { buildSuggestedCall } from "./build-suggested-call.js";
 import { createError, ERROR_CODES } from "./errors.js";
 import { computeFileSha1 } from "./hash.js";
 import { defaultDownloadPath, downloadToCache } from "./repo-downloader.js";
@@ -24,7 +25,7 @@ function ensureVersionDetail(value, version) {
             details: {
                 version,
                 nextAction: "Use list-versions to see available Minecraft versions.",
-                suggestedCall: { tool: "list-versions", params: {} }
+                ...buildSuggestedCall({ tool: "list-versions", params: {} })
             }
         });
     }
@@ -112,7 +113,7 @@ export class VersionService {
                 details: {
                     version: normalizedVersion,
                     nextAction: "Use list-versions to see available Minecraft versions.",
-                    suggestedCall: { tool: "list-versions", params: {} }
+                    ...buildSuggestedCall({ tool: "list-versions", params: {} })
                 }
             });
         }
@@ -144,7 +145,7 @@ export class VersionService {
                 details: {
                     version: normalizedVersion,
                     nextAction: "Use list-versions to see available Minecraft versions.",
-                    suggestedCall: { tool: "list-versions", params: {} }
+                    ...buildSuggestedCall({ tool: "list-versions", params: {} })
                 }
             });
         }
@@ -157,7 +158,7 @@ export class VersionService {
                 details: {
                     version: normalizedVersion,
                     nextAction: "Use list-versions to see available Minecraft versions.",
-                    suggestedCall: { tool: "list-versions", params: {} }
+                    ...buildSuggestedCall({ tool: "list-versions", params: {} })
                 }
             });
         }
@@ -249,7 +250,7 @@ export class VersionService {
                 details: {
                     version: normalizedVersion,
                     nextAction: "Use list-versions to see available Minecraft versions.",
-                    suggestedCall: { tool: "list-versions", params: {} }
+                    ...buildSuggestedCall({ tool: "list-versions", params: {} })
                 }
             });
         }
@@ -262,7 +263,7 @@ export class VersionService {
                 details: {
                     version: normalizedVersion,
                     nextAction: "Use list-versions to see available Minecraft versions.",
-                    suggestedCall: { tool: "list-versions", params: {} }
+                    ...buildSuggestedCall({ tool: "list-versions", params: {} })
                 }
             });
         }

package/dist/workspace-context-cache.d.ts

@@ -0,0 +1,32 @@
+import type { SourceMapping } from "./types.js";
+import type { WorkspaceProjectLoader } from "./workspace-mapping-service.js";
+export type WorkspaceContextEvidence = {
+    source: string;
+    field: string;
+    value?: string;
+};
+export type WorkspaceContext = {
+    projectPath: string;
+    minecraftVersion?: string;
+    compileMapping?: SourceMapping;
+    loader?: WorkspaceProjectLoader;
+    detectedAt: number;
+    evidence: WorkspaceContextEvidence[];
+    dependencyVersions: Map<string, string>;
+    partial?: boolean;
+};
+export interface WorkspaceContextCache {
+    read(projectPath: string): WorkspaceContext | undefined;
+    write(ctx: WorkspaceContext): void;
+    invalidate(projectPath: string): boolean;
+    list(): WorkspaceContext[];
+    clear(): void;
+}
+export type WorkspaceContextCacheOptions = {
+    maxEntries?: number;
+    ttlMs?: number;
+    clock?: () => number;
+};
+export declare function createWorkspaceContextCache(opts?: WorkspaceContextCacheOptions): WorkspaceContextCache;
+export declare function getProcessWorkspaceContextCache(): WorkspaceContextCache;
+export declare function resetProcessWorkspaceContextCacheForTesting(): void;

package/dist/workspace-context-cache.js

@@ -0,0 +1,66 @@
+import { resolve as resolvePath } from "node:path";
+import { LruList } from "./lru-list.js";
+const DEFAULT_MAX_ENTRIES = 16;
+const DEFAULT_TTL_MS = 5 * 60_000;
+function normalizeKey(projectPath) {
+    return resolvePath(projectPath);
+}
+export function createWorkspaceContextCache(opts = {}) {
+    const maxEntries = opts.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    const ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS;
+    const clock = opts.clock ?? (() => Date.now());
+    const lru = new LruList();
+    function isExpired(ctx) {
+        return clock() - ctx.detectedAt > ttlMs;
+    }
+    function evictExcess() {
+        while (lru.size > maxEntries) {
+            const oldest = lru.peekOldest();
+            if (!oldest) {
+                return;
+            }
+            lru.remove(oldest.key);
+        }
+    }
+    return {
+        read(projectPath) {
+            const key = normalizeKey(projectPath);
+            const value = lru.touch(key);
+            if (!value) {
+                return undefined;
+            }
+            if (isExpired(value)) {
+                lru.remove(key);
+                return undefined;
+            }
+            return value;
+        },
+        write(ctx) {
+            const key = normalizeKey(ctx.projectPath);
+            lru.upsert(key, { ...ctx, projectPath: key });
+            evictExcess();
+        },
+        invalidate(projectPath) {
+            const key = normalizeKey(projectPath);
+            return lru.remove(key) !== undefined;
+        },
+        list() {
+            const all = lru.toArray().map((entry) => entry.value);
+            return all.filter((value) => !isExpired(value));
+        },
+        clear() {
+            lru.clear();
+        }
+    };
+}
+let processCache;
+export function getProcessWorkspaceContextCache() {
+    if (!processCache) {
+        processCache = createWorkspaceContextCache();
+    }
+    return processCache;
+}
+export function resetProcessWorkspaceContextCacheForTesting() {
+    processCache = undefined;
+}
+//# sourceMappingURL=workspace-context-cache.js.map

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

@@ -25,8 +25,24 @@ export type WorkspaceProjectLoaderOutput = {
     evidence: WorkspaceLoaderEvidence[];
     warnings: string[];
 };
+export type DependencyVersionResolution = {
+    resolved: true;
+    version: string;
+    source: string;
+    candidatesSeen: string[];
+    attempts: string[];
+} | {
+    resolved: false;
+    candidatesSeen: string[];
+    attempts: string[];
+};
+export type DependencyVersionOptions = {
+    includeSnapshots?: boolean;
+};
+export declare function isSafeMavenVersionToken(token: string): boolean;
 export declare class WorkspaceMappingService {
     detectCompileMapping(input: WorkspaceCompileMappingInput): Promise<WorkspaceCompileMappingOutput>;
     detectProjectMinecraftVersion(projectPath: string): Promise<string | undefined>;
+    detectDependencyVersion(projectPath: string, group: string, name: string, opts?: DependencyVersionOptions): Promise<DependencyVersionResolution>;
     detectProjectLoader(projectPath: string): Promise<WorkspaceProjectLoaderOutput>;
 }

package/dist/workspace-mapping-service.js

@@ -1,4 +1,5 @@
-import { readFile } from "node:fs/promises";
+import { readdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
 import { resolve } from "node:path";
 import fastGlob from "fast-glob";
 import { mapWithConcurrencyLimit } from "./concurrency.js";
@@ -38,6 +39,93 @@ function detectMappingsFromContent(content) {
     }
     return detections;
 }
+function camelCaseDependencyName(name) {
+    const parts = name.split(/[-_]/).filter((part) => part.length > 0);
+    if (parts.length === 0) {
+        return name;
+    }
+    const [first, ...rest] = parts;
+    const head = first ?? "";
+    return (head +
+        rest
+            .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+            .join(""));
+}
+function lastGroupSegment(group) {
+    const segments = group.split(".").filter((segment) => segment.length > 0);
+    return segments[segments.length - 1] ?? group;
+}
+function buildDependencyPropertyKeys(group, name) {
+    const camelName = camelCaseDependencyName(name);
+    const groupSegment = lastGroupSegment(group);
+    const camelGroupName = camelCaseDependencyName(`${groupSegment}_${name}`);
+    const keys = [
+        `${name}_version`,
+        `${camelName}Version`,
+        `${groupSegment}_${name}_version`,
+        `${camelGroupName}Version`
+    ];
+    const seen = new Set();
+    const deduped = [];
+    for (const key of keys) {
+        if (!seen.has(key)) {
+            seen.add(key);
+            deduped.push(key);
+        }
+    }
+    return deduped;
+}
+function readPropertyValue(content, key) {
+    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`^\\s*${escaped}\\s*=\\s*(.+?)\\s*$`, "m");
+    const match = content.match(pattern);
+    if (!match) {
+        return undefined;
+    }
+    const value = match[1]?.trim();
+    return value && value.length > 0 ? value : undefined;
+}
+function compareSemverDescending(left, right) {
+    const leftParts = left.split(/[.+-]/);
+    const rightParts = right.split(/[.+-]/);
+    const length = Math.max(leftParts.length, rightParts.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftPart = leftParts[index] ?? "0";
+        const rightPart = rightParts[index] ?? "0";
+        const leftNum = /^\d+$/.test(leftPart) ? Number.parseInt(leftPart, 10) : Number.NaN;
+        const rightNum = /^\d+$/.test(rightPart) ? Number.parseInt(rightPart, 10) : Number.NaN;
+        if (!Number.isNaN(leftNum) && !Number.isNaN(rightNum)) {
+            if (leftNum !== rightNum) {
+                return rightNum - leftNum;
+            }
+            continue;
+        }
+        if (leftPart !== rightPart) {
+            return rightPart.localeCompare(leftPart);
+        }
+    }
+    return 0;
+}
+function isPathTraversalToken(token) {
+    return token.length === 0 || token.includes("/") || token.includes("\\") || token.includes("..") || token.includes("\0");
+}
+const SAFE_VERSION_TOKEN_RE = /^[A-Za-z0-9._+-]+$/;
+export function isSafeMavenVersionToken(token) {
+    if (typeof token !== "string" || token.length === 0 || token.length > 200) {
+        return false;
+    }
+    if (token.startsWith(".") || token.includes("..")) {
+        return false;
+    }
+    return SAFE_VERSION_TOKEN_RE.test(token);
+}
+function resolveGradleUserHome() {
+    const configured = process.env.GRADLE_USER_HOME?.trim();
+    if (configured) {
+        return configured;
+    }
+    return resolve(homedir(), ".gradle");
+}
 function detectLoadersFromContent(content) {
     const detections = [];
     if (/\bid\s*(?:\(\s*)?["']net\.neoforged\.moddev["']\s*\)?/i.test(content)) {
@@ -159,6 +247,90 @@ export class WorkspaceMappingService {
         }
         return undefined;
     }
+    async detectDependencyVersion(projectPath, group, name, opts) {
+        if (isPathTraversalToken(group) || isPathTraversalToken(name)) {
+            throw createError({
+                code: ERROR_CODES.INVALID_INPUT,
+                message: "Dependency group and name must not contain path traversal characters.",
+                details: { group, name }
+            });
+        }
+        const includeSnapshots = opts?.includeSnapshots === true;
+        const attempts = [];
+        const candidatesSeen = [];
+        const root = resolve(projectPath);
+        const propsPath = resolve(root, "gradle.properties");
+        let propsContent;
+        try {
+            propsContent = await readFile(propsPath, "utf8");
+        }
+        catch {
+            propsContent = undefined;
+        }
+        const keys = buildDependencyPropertyKeys(group, name);
+        if (propsContent !== undefined) {
+            for (const key of keys) {
+                attempts.push(`gradle.properties:${key}`);
+                const value = readPropertyValue(propsContent, key);
+                if (value) {
+                    if (!isSafeMavenVersionToken(value)) {
+                        attempts.push(`gradle.properties:${key}:rejected-unsafe-version`);
+                        continue;
+                    }
+                    return {
+                        resolved: true,
+                        version: value,
+                        source: `gradle.properties:${key}`,
+                        candidatesSeen,
+                        attempts
+                    };
+                }
+            }
+        }
+        else {
+            for (const key of keys) {
+                attempts.push(`gradle.properties:${key}`);
+            }
+        }
+        const modulesDir = resolve(resolveGradleUserHome(), "caches", "modules-2", "files-2.1", group, name);
+        attempts.push(`modules-2:${modulesDir}`);
+        let entries = [];
+        try {
+            entries = await readdir(modulesDir);
+        }
+        catch {
+            return { resolved: false, candidatesSeen, attempts };
+        }
+        const filtered = entries.filter((entry) => {
+            if (!isSafeMavenVersionToken(entry)) {
+                return false;
+            }
+            if (includeSnapshots) {
+                return true;
+            }
+            const lower = entry.toLowerCase();
+            return !lower.endsWith("-snapshot") && !lower.endsWith("-dev");
+        });
+        const sorted = [...filtered].sort(compareSemverDescending);
+        candidatesSeen.push(...sorted);
+        if (sorted.length === 0) {
+            return { resolved: false, candidatesSeen, attempts };
+        }
+        if (sorted.length > 1) {
+            return { resolved: false, candidatesSeen, attempts };
+        }
+        const chosen = sorted[0];
+        if (!chosen) {
+            return { resolved: false, candidatesSeen, attempts };
+        }
+        return {
+            resolved: true,
+            version: chosen,
+            source: `modules-2:${modulesDir}`,
+            candidatesSeen,
+            attempts
+        };
+    }
     async detectProjectLoader(projectPath) {
         const root = resolve(projectPath);
         const buildFiles = (await fastGlob.glob(["build.gradle", "build.gradle.kts", "**/build.gradle", "**/build.gradle.kts"], {