@adhisang/minecraft-modding-mcp 3.2.0 → 4.1.0

package/dist/entry-tools/inspect-minecraft/handlers/class-source.js

@@ -0,0 +1,60 @@
+import { buildEntryToolResult, createSummarySubject } from "../../response-contract.js";
+import { buildClassSubject, resolveClassArtifactReference, invalidTaskSubjectError } from "../internal.js";
+export async function handleClassSource(deps, subject, detail, include) {
+    if (subject.kind !== "class" && !(subject.kind === "workspace" && subject.focus?.kind === "class")) {
+        invalidTaskSubjectError("class-source", subject);
+    }
+    const classSubject = buildClassSubject(subject);
+    const className = classSubject.className;
+    const artifactContext = await resolveClassArtifactReference(deps, subject, classSubject, "class-source");
+    const source = await deps.getClassSource({
+        className,
+        artifactId: artifactContext.artifactId || undefined,
+        mapping: classSubject.mapping,
+        scope: classSubject.scope,
+        projectPath: classSubject.projectPath,
+        preferProjectVersion: classSubject.preferProjectVersion,
+        strictVersion: classSubject.strictVersion,
+        mode: include.includes("source") || detail === "full" ? "snippet" : "metadata"
+    });
+    const summary = {
+        status: "ok",
+        headline: `Resolved source for ${source.className}.`,
+        subject: createSummarySubject({
+            task: "class-source",
+            requested: subject,
+            className: source.className,
+            artifactId: source.artifactId
+        }),
+        counts: {
+            totalLines: source.totalLines
+        }
+    };
+    return {
+        ...buildEntryToolResult({
+            task: "class-source",
+            summary,
+            detail,
+            include,
+            blocks: {
+                subject: {
+                    requested: subject,
+                    resolved: {
+                        artifactId: source.artifactId,
+                        className: source.className
+                    }
+                },
+                source: {
+                    className: source.className,
+                    mode: source.mode,
+                    returnedRange: source.returnedRange,
+                    totalLines: source.totalLines,
+                    sourceText: source.sourceText
+                }
+            },
+            alwaysBlocks: ["subject"]
+        }),
+        warnings: [...artifactContext.warnings, ...source.warnings]
+    };
+}
+//# sourceMappingURL=class-source.js.map

package/dist/entry-tools/inspect-minecraft/handlers/file.d.ts

@@ -0,0 +1,5 @@
+import { type DetailLevel } from "../../response-contract.js";
+import { type Subject, type InspectMinecraftDeps } from "../internal.js";
+export declare function handleFile(deps: InspectMinecraftDeps, subject: Subject, detail: DetailLevel, include: string[]): Promise<{
+    warnings: string[];
+}>;

package/dist/entry-tools/inspect-minecraft/handlers/file.js

@@ -0,0 +1,54 @@
+import { buildEntryToolResult, createSummarySubject } from "../../response-contract.js";
+import { requireWorkspaceFileFocus, resolveWorkspaceArtifactReference, invalidTaskSubjectError, resolveArtifactReference } from "../internal.js";
+export async function handleFile(deps, subject, detail, include) {
+    if (subject.kind !== "file" && !(subject.kind === "workspace" && subject.focus?.kind === "file")) {
+        invalidTaskSubjectError("file", subject);
+    }
+    const fileSubject = subject.kind === "file" ? subject : requireWorkspaceFileFocus(subject);
+    const artifact = subject.kind === "file"
+        ? await resolveArtifactReference(deps, subject, "file")
+        : await resolveWorkspaceArtifactReference(deps, subject, fileSubject.artifact);
+    const file = await deps.getArtifactFile({
+        artifactId: artifact.artifactId,
+        filePath: fileSubject.filePath
+    });
+    const summary = {
+        status: "ok",
+        headline: `Read ${file.filePath}.`,
+        subject: createSummarySubject({
+            task: "file",
+            requested: subject,
+            filePath: file.filePath,
+            artifactId: artifact.artifactId
+        }),
+        counts: {
+            bytes: file.contentBytes
+        }
+    };
+    return {
+        ...buildEntryToolResult({
+            task: "file",
+            summary,
+            detail,
+            include,
+            blocks: {
+                subject: {
+                    requested: subject,
+                    resolved: {
+                        artifactId: artifact.artifactId,
+                        filePath: file.filePath
+                    }
+                },
+                file: {
+                    filePath: file.filePath,
+                    contentBytes: file.contentBytes,
+                    truncated: file.truncated,
+                    content: include.includes("source") || detail !== "summary" ? file.content : undefined
+                }
+            },
+            alwaysBlocks: ["subject"]
+        }),
+        warnings: [...artifact.warnings]
+    };
+}
+//# sourceMappingURL=file.js.map

package/dist/entry-tools/inspect-minecraft/handlers/list-files.d.ts

@@ -0,0 +1,5 @@
+import { type DetailLevel } from "../../response-contract.js";
+import { type Subject, type InspectMinecraftDeps } from "../internal.js";
+export declare function handleListFiles(deps: InspectMinecraftDeps, subject: Subject, detail: DetailLevel, include: string[], limit: number | undefined, cursor: string | undefined): Promise<{
+    warnings: string[];
+}>;

package/dist/entry-tools/inspect-minecraft/handlers/list-files.js

@@ -0,0 +1,100 @@
+import { buildEntryToolResult, createNextAction, createSummarySubject } from "../../response-contract.js";
+import { capArray, nextActionsOrUndefined } from "../../request-normalizers.js";
+import { hasPartialVanillaCoverage, resolveArtifactReference } from "../internal.js";
+export async function handleListFiles(deps, subject, detail, include, limit, cursor) {
+    const artifact = await resolveArtifactReference(deps, subject, "list-files");
+    const files = await deps.listArtifactFiles({
+        artifactId: artifact.artifactId,
+        limit,
+        cursor
+    });
+    const sampled = capArray(files.items, 10);
+    const partialCoverage = subject.kind === "workspace" && hasPartialVanillaCoverage(artifact.artifact);
+    const nextActions = [
+        ...(files.items.length > 0
+            ? [
+                createNextAction("inspect-minecraft", {
+                    task: "file",
+                    subject: {
+                        kind: "file",
+                        filePath: files.items[0],
+                        artifact: {
+                            type: "resolved-id",
+                            artifactId: artifact.artifactId
+                        }
+                    }
+                })
+            ]
+            : []),
+        ...(partialCoverage
+            ? [
+                createNextAction("inspect-minecraft", {
+                    task: "class-source",
+                    subject: {
+                        kind: "workspace",
+                        projectPath: subject.projectPath,
+                        mapping: subject.mapping,
+                        scope: subject.scope,
+                        preferProjectVersion: subject.preferProjectVersion,
+                        strictVersion: subject.strictVersion,
+                        focus: {
+                            kind: "class",
+                            className: "net.minecraft.world.item.Item"
+                        }
+                    }
+                })
+            ]
+            : [])
+    ];
+    const summary = {
+        status: partialCoverage ? "partial" : "ok",
+        headline: `Listed ${files.items.length} files for ${artifact.artifactId}.`,
+        subject: createSummarySubject({
+            task: "list-files",
+            requested: subject,
+            artifactId: artifact.artifactId
+        }),
+        counts: {
+            files: files.items.length
+        },
+        nextActions: nextActionsOrUndefined(nextActions),
+        ...(partialCoverage
+            ? {
+                notes: [
+                    "This listing is partial because the resolved source artifact does not contain net.minecraft entries."
+                ]
+            }
+            : {})
+    };
+    return {
+        ...buildEntryToolResult({
+            task: "list-files",
+            summary,
+            detail,
+            include,
+            blocks: {
+                subject: {
+                    requested: subject,
+                    resolved: {
+                        artifactId: artifact.artifactId
+                    }
+                },
+                files: {
+                    items: detail === "summary" ? sampled.items : files.items,
+                    nextCursor: files.nextCursor,
+                    ...(partialCoverage
+                        ? {
+                            coverage: {
+                                sourceCoverage: "partial",
+                                missingNamespaces: ["net.minecraft"]
+                            }
+                        }
+                        : {})
+                }
+            },
+            alwaysBlocks: ["subject"]
+        }),
+        warnings: [...artifact.warnings, ...files.warnings]
+    };
+}
+//# sourceMappingURL=list-files.js.map

package/dist/entry-tools/inspect-minecraft/handlers/search.d.ts

@@ -0,0 +1,5 @@
+import { type DetailLevel } from "../../response-contract.js";
+import { type Subject, type InspectMinecraftDeps } from "../internal.js";
+export declare function handleSearch(deps: InspectMinecraftDeps, subject: Subject, detail: DetailLevel, include: string[], limit: number | undefined, cursor: string | undefined): Promise<{
+    warnings: string[];
+}>;

package/dist/entry-tools/inspect-minecraft/handlers/search.js

@@ -0,0 +1,155 @@
+import { buildEntryToolResult, createNextAction, createSummarySubject } from "../../response-contract.js";
+import { capArray, nextActionsOrUndefined } from "../../request-normalizers.js";
+import { classNameToFilePath, hasPartialVanillaCoverage, hitTargetsVanillaNamespace, looksLikeClassQuery, requireWorkspaceSearchFocus, resolveWorkspaceArtifactReference, summarizeRequestedSubject, invalidTaskSubjectError, resolveBinaryBackedClass, resolveArtifactReference } from "../internal.js";
+export async function handleSearch(deps, subject, detail, include, limit, cursor) {
+    if (subject.kind !== "search" && !(subject.kind === "workspace" && subject.focus?.kind === "search")) {
+        invalidTaskSubjectError("search", subject);
+    }
+    const searchSubject = subject.kind === "search" ? subject : requireWorkspaceSearchFocus(subject);
+    const requestedSubject = summarizeRequestedSubject(subject);
+    const queryMode = searchSubject.queryMode ?? "auto";
+    const artifact = subject.kind === "search"
+        ? await resolveArtifactReference(deps, subject, "search")
+        : await resolveWorkspaceArtifactReference(deps, subject, searchSubject.artifact);
+    const search = await deps.searchClassSource({
+        artifactId: artifact.artifactId,
+        query: searchSubject.query,
+        intent: searchSubject.intent,
+        match: searchSubject.match,
+        queryMode,
+        limit,
+        cursor,
+        scope: searchSubject.packagePrefix || searchSubject.fileGlob || searchSubject.symbolKind
+            ? {
+                packagePrefix: searchSubject.packagePrefix,
+                fileGlob: searchSubject.fileGlob,
+                symbolKind: searchSubject.symbolKind
+            }
+            : undefined
+    });
+    const needsBinaryBackedClassHit = subject.kind === "workspace" &&
+        hasPartialVanillaCoverage(artifact.artifact) &&
+        looksLikeClassQuery(searchSubject.query) &&
+        !search.hits.some((hit) => hitTargetsVanillaNamespace(hit));
+    const binaryBackedClassHit = needsBinaryBackedClassHit
+        ? await resolveBinaryBackedClass(deps, searchSubject.query, {
+            version: artifact.version,
+            mapping: subject.mapping
+        })
+        : undefined;
+    const binaryBackedHitRecord = binaryBackedClassHit == null
+        ? undefined
+        : {
+            filePath: classNameToFilePath(binaryBackedClassHit.className),
+            score: 100,
+            matchedIn: "symbol",
+            reasonCodes: ["binary-class-lookup"],
+            symbol: {
+                symbolKind: "class",
+                symbolName: binaryBackedClassHit.className.split(".").at(-1) ?? binaryBackedClassHit.className,
+                qualifiedName: binaryBackedClassHit.className,
+                line: 1
+            }
+        };
+    const effectiveHits = binaryBackedHitRecord == null
+        ? search.hits
+        : [
+            binaryBackedHitRecord,
+            ...search.hits.filter((hit) => hit.filePath !== binaryBackedHitRecord.filePath)
+        ];
+    const sampledHits = capArray(effectiveHits, 5);
+    const isAutoSeparatorMiss = effectiveHits.length === 0 &&
+        queryMode === "auto" &&
+        /[._$]/.test(searchSubject.query);
+    const literalRetrySubject = subject.kind === "search"
+        ? {
+            ...subject,
+            queryMode: "literal"
+        }
+        : {
+            ...subject,
+            focus: {
+                ...searchSubject,
+                kind: "search",
+                queryMode: "literal"
+            }
+        };
+    const summary = {
+        status: effectiveHits.length > 0 ? "ok" : "not_found",
+        headline: effectiveHits.length > 0
+            ? `Found ${effectiveHits.length} source hits for ${searchSubject.query}.`
+            : `No source hits were found for ${searchSubject.query}.`,
+        subject: createSummarySubject({
+            task: "search",
+            requested: requestedSubject,
+            query: searchSubject.query,
+            artifactId: artifact.artifactId
+        }),
+        counts: {
+            hits: effectiveHits.length
+        },
+        nextActions: nextActionsOrUndefined([
+            ...(effectiveHits.length > 0
+                ? [
+                    createNextAction("inspect-minecraft", {
+                        task: "file",
+                        subject: {
+                            kind: "file",
+                            filePath: effectiveHits[0].filePath,
+                            artifact: {
+                                type: "resolved-id",
+                                artifactId: artifact.artifactId
+                            }
+                        },
+                        include: ["source"]
+                    })
+                ]
+                : []),
+            ...(isAutoSeparatorMiss
+                ? [
+                    createNextAction("inspect-minecraft", {
+                        task: "search",
+                        subject: literalRetrySubject
+                    })
+                ]
+                : [])
+        ]),
+        ...(isAutoSeparatorMiss
+            ? {
+                notes: [
+                    "Separator query returned no indexed hits. Retry with queryMode=\"literal\" for an explicit full substring scan."
+                ]
+            }
+            : binaryBackedClassHit
+                ? {
+                    notes: [
+                        "Source coverage was partial, so inspect-minecraft returned a binary-backed class match for the vanilla symbol."
+                    ]
+                }
+                : {})
+    };
+    return {
+        ...buildEntryToolResult({
+            task: "search",
+            summary,
+            detail,
+            include,
+            blocks: {
+                subject: {
+                    requested: requestedSubject,
+                    resolved: {
+                        artifactId: artifact.artifactId
+                    }
+                },
+                search: {
+                    query: searchSubject.query,
+                    hits: detail === "summary" ? sampledHits.items : effectiveHits,
+                    nextCursor: search.nextCursor
+                }
+            },
+            alwaysBlocks: ["subject"]
+        }),
+        warnings: [...artifact.warnings, ...(binaryBackedClassHit?.warnings ?? [])]
+    };
+}
+//# sourceMappingURL=search.js.map

package/dist/entry-tools/inspect-minecraft/handlers/versions.d.ts

@@ -0,0 +1,6 @@
+import { type DetailLevel } from "../../response-contract.js";
+import { type InspectMinecraftDeps } from "../internal.js";
+import { type InspectMinecraftInput } from "../../inspect-minecraft-service.js";
+export declare function handleVersions(deps: InspectMinecraftDeps, input: InspectMinecraftInput, detail: DetailLevel, include: string[]): Promise<{
+    warnings: never[];
+}>;

package/dist/entry-tools/inspect-minecraft/handlers/versions.js

@@ -0,0 +1,49 @@
+import { buildEntryToolResult, createNextAction, createSummarySubject } from "../../response-contract.js";
+import { nextActionsOrUndefined } from "../../request-normalizers.js";
+export async function handleVersions(deps, input, detail, include) {
+    const versions = await deps.listVersions({
+        includeSnapshots: input.includeSnapshots,
+        limit: input.limit
+    });
+    const summary = {
+        status: "ok",
+        headline: `Found ${versions.totalAvailable} Minecraft versions.`,
+        subject: createSummarySubject({
+            task: "versions",
+            kind: "versions",
+            includeSnapshots: input.includeSnapshots === false ? undefined : input.includeSnapshots,
+            limit: input.limit
+        }),
+        counts: {
+            releases: versions.releases.length,
+            snapshots: versions.snapshots?.length ?? 0
+        },
+        nextActions: nextActionsOrUndefined([
+            createNextAction("inspect-minecraft", {
+                task: "artifact",
+                subject: {
+                    kind: "version",
+                    version: versions.latest.release ?? versions.releases[0]?.id
+                }
+            })
+        ])
+    };
+    return {
+        ...buildEntryToolResult({
+            task: "versions",
+            summary,
+            detail,
+            include,
+            blocks: {
+                versions: {
+                    latest: versions.latest,
+                    releases: detail === "summary" ? versions.releases.slice(0, 5) : versions.releases,
+                    snapshots: input.includeSnapshots ? versions.snapshots : undefined,
+                    cached: versions.cached
+                }
+            }
+        }),
+        warnings: []
+    };
+}
+//# sourceMappingURL=versions.js.map