@adhisang/minecraft-modding-mcp 6.2.0 → 7.0.0-rc.0

package/dist/entry-tools/inspect-minecraft/internal.js

@@ -30,27 +30,27 @@ export const artifactRefSchema = z.discriminatedUnion("type", [
 ]);
 export const workspaceFocusSchema = z.discriminatedUnion("kind", [
     z.object({
-        kind: z.literal("class"),
-        className: nonEmptyString,
-        artifact: artifactRefSchema.optional()
-    }),
+        kind: z.literal("class").describe("Select class inspection."),
+        className: nonEmptyString.describe("Fully-qualified class name to inspect."),
+        artifact: artifactRefSchema.optional().describe("Optional explicit artifact override; otherwise resolve it from the workspace.")
+    }).describe('Class focus object: {"kind":"class","className":"net.minecraft.world.item.Item"}. task=auto dispatches it to class-overview; select class-source or class-members explicitly when needed.'),
     z.object({
-        kind: z.literal("file"),
-        filePath: nonEmptyString,
-        artifact: artifactRefSchema.optional()
-    }),
+        kind: z.literal("file").describe("Select an artifact-relative file read."),
+        filePath: nonEmptyString.describe("Artifact-relative file path to read."),
+        artifact: artifactRefSchema.optional().describe("Optional explicit artifact override; otherwise resolve it from the workspace.")
+    }).describe('File focus object: {"kind":"file","filePath":"net/minecraft/world/item/Item.java"}. task=auto dispatches it to file.'),
     z.object({
-        kind: z.literal("search"),
-        query: nonEmptyString,
-        artifact: artifactRefSchema.optional(),
+        kind: z.literal("search").describe("Select source search."),
+        query: nonEmptyString.describe("Source, symbol, or path query to search for."),
+        artifact: artifactRefSchema.optional().describe("Optional explicit artifact override; otherwise resolve it from the workspace."),
         intent: z.enum(["symbol", "text", "path"]).optional(),
         match: z.enum(["exact", "prefix", "contains", "regex"]).optional(),
         symbolKind: z.enum(["class", "interface", "enum", "record", "method", "field"]).optional(),
         packagePrefix: nonEmptyString.optional(),
         fileGlob: nonEmptyString.optional(),
         queryMode: z.enum(["auto", "token", "literal"]).default("auto")
-    })
-]);
+    }).describe('Search focus object: {"kind":"search","query":"CreativeModeTab"}. task=auto dispatches it to search.')
+]).describe('Structured workspace focus. Object, not string. Choose {kind:"class",className}, {kind:"file",filePath}, or {kind:"search",query}.');
 export const subjectSchema = z.discriminatedUnion("kind", [
     z.object({
         kind: z.literal("version"),
@@ -108,8 +108,16 @@ export const subjectSchema = z.discriminatedUnion("kind", [
         preferProjectVersion: z.boolean().optional(),
         strictVersion: z.boolean().optional(),
         focus: workspaceFocusSchema.optional()
-    })
-]);
+    }).describe("Workspace subject. Resolves Minecraft artifact context from projectPath; add a structured focus object for class, file, or search work.")
+]).describe("Structured inspection subject. Use kind=workspace with a structured focus object when the workspace should resolve artifact context.");
+/**
+ * Read at call time, never at module load: tests flip WORKSPACE_TARGET_OFF per
+ * case, and resolve-artifact itself rejects target.kind="workspace" while it is
+ * set (src/source/workspace-target.ts).
+ */
+function workspaceTargetDisabled() {
+    return process.env.WORKSPACE_TARGET_OFF === "1";
+}
 export function hasPartialVanillaCoverage(artifact) {
     return artifact?.qualityFlags.includes("partial-source-no-net-minecraft") === true
         || artifact?.artifactContents.sourceCoverage === "partial";
@@ -402,16 +410,20 @@ export async function resolveArtifactReference(deps, subject, task) {
                 const version = unique.minecraftVersion ??
                     (await deps.detectProjectMinecraftVersion(unique.projectPath));
                 if (version) {
-                    const artifact = await deps.resolveArtifact({
-                        target: { kind: "version", value: version },
-                        projectPath: unique.projectPath
-                    });
+                    // Same routing as the workspace subject: a bare {kind:"version"}
+                    // target here would resolve a different artifact than resolve-artifact
+                    // does for the same directory. The pre-detected version stays only as
+                    // the guard that a workspace is usable at all, so an undetectable one
+                    // still falls through to the actionable artifact-context error below.
+                    const artifact = await deps.resolveArtifact(workspaceTargetDisabled()
+                        ? { target: { kind: "version", value: version }, projectPath: unique.projectPath }
+                        : { target: { kind: "workspace" }, projectPath: unique.projectPath });
                     return {
                         artifactId: artifact.artifactId,
                         artifact,
-                        version,
+                        version: artifact.version ?? version,
                         warnings: [
-                            `subject.artifact was omitted; auto-resolved through the unique known workspace ${unique.projectPath} (Minecraft ${version}). Pass subject.artifact to target a different artifact.`,
+                            `subject.artifact was omitted; auto-resolved through the unique known workspace ${unique.projectPath} (Minecraft ${artifact.version ?? version}). Pass subject.artifact to target a different artifact.`,
                             ...artifact.warnings
                         ]
                     };
@@ -454,16 +466,41 @@ export async function resolveArtifactReference(deps, subject, task) {
             warnings: [...artifact.warnings]
         };
     }
-    const version = await deps.detectProjectMinecraftVersion(subject.projectPath);
-    if (!version) {
+    if (workspaceTargetDisabled()) {
+        // Kill switch parity: resolve-artifact rejects target.kind="workspace" under
+        // WORKSPACE_TARGET_OFF=1, so fall back to the pre-workspace-target routing
+        // instead of turning the toggle into a hard failure here.
+        const version = await deps.detectProjectMinecraftVersion(subject.projectPath);
+        if (!version) {
+            return {
+                artifactId: "",
+                version: undefined,
+                warnings: [`Could not infer Minecraft version from ${subject.projectPath}.`]
+            };
+        }
+        const legacyArtifact = await deps.resolveArtifact({
+            target: { kind: "version", value: version },
+            mapping: subject.mapping,
+            scope: subject.scope,
+            projectPath: subject.projectPath,
+            ...(subject.gradleUserHome !== undefined ? { gradleUserHome: subject.gradleUserHome } : {}),
+            preferProjectVersion: subject.preferProjectVersion ?? true,
+            strictVersion: subject.strictVersion
+        });
         return {
-            artifactId: "",
-            version: undefined,
-            warnings: [`Could not infer Minecraft version from ${subject.projectPath}.`]
+            artifactId: legacyArtifact.artifactId,
+            artifact: legacyArtifact,
+            version,
+            warnings: [...legacyArtifact.warnings]
         };
     }
+    // Hand the directory to resolve-artifact as a workspace target so both tools
+    // agree on the artifact. A failed version detection now surfaces as
+    // ERR_WORKSPACE_VERSION_UNRESOLVED (which carries nextAction + suggestedCall)
+    // instead of degrading to an empty artifactId and a misleading
+    // "Either artifactId or target must be provided." further down the call chain.
     const artifact = await deps.resolveArtifact({
-        target: { kind: "version", value: version },
+        target: { kind: "workspace" },
         mapping: subject.mapping,
         scope: subject.scope,
         projectPath: subject.projectPath,
@@ -474,7 +511,7 @@ export async function resolveArtifactReference(deps, subject, task) {
     return {
         artifactId: artifact.artifactId,
         artifact,
-        version,
+        version: artifact.version,
         warnings: [...artifact.warnings]
     };
 }