@adhisang/minecraft-modding-mcp 3.2.0 → 4.1.0

package/dist/entry-tools/validate-project-service.js

@@ -3,10 +3,12 @@ import { resolve } from "node:path";
 import fastGlob from "fast-glob";
 import { z } from "zod";
 import { mapWithConcurrencyLimit } from "../concurrency.js";
-import { createError, ERROR_CODES } from "../errors.js";
 import { buildIncludeSchema, detailSchema } from "./entry-tool-schema.js";
-import { buildEntryToolResult, createSummarySubject } from "./response-contract.js";
 import { resolveDetail, resolveInclude } from "./request-normalizers.js";
+import { handleMixin } from "./validate-project/cases/mixin.js";
+import { handleAccessWidener } from "./validate-project/cases/access-widener.js";
+import { handleAccessTransformer } from "./validate-project/cases/access-transformer.js";
+import { handleProjectSummary } from "./validate-project/cases/project-summary.js";
 const nonEmptyString = z.string().trim().min(1);
 const INCLUDE_GROUPS = ["warnings", "issues", "workspace", "recovery"];
 const WORKSPACE_TEXT_FILE_READ_CONCURRENCY = 4;
@@ -265,486 +267,14 @@ export class ValidateProjectService {
         const detail = resolveDetail(input.detail);
         const include = resolveInclude(input.include);
         switch (input.task) {
-            case "mixin": {
-                if (input.subject.kind !== "mixin") {
-                    throw createError({
-                        code: ERROR_CODES.INVALID_INPUT,
-                        message: "task=mixin requires subject.kind=mixin."
-                    });
-                }
-                const output = await this.deps.validateMixin({
-                    input: input.subject.input,
-                    version: input.version,
-                    mapping: input.mapping,
-                    sourcePriority: input.sourcePriority,
-                    scope: input.scope,
-                    preferProjectVersion: input.preferProjectVersion,
-                    preferProjectMapping: input.preferProjectMapping,
-                    sourceRoots: input.sourceRoots,
-                    minSeverity: input.minSeverity,
-                    hideUncertain: input.hideUncertain,
-                    explain: input.explain,
-                    warningMode: input.warningMode,
-                    warningCategoryFilter: input.warningCategoryFilter,
-                    treatInfoAsWarning: input.treatInfoAsWarning,
-                    includeIssues: input.includeIssues
-                });
-                const summary = output.summary;
-                const invalidCount = summary?.invalid ?? 0;
-                const partialCount = summary?.partial ?? 0;
-                return {
-                    ...buildEntryToolResult({
-                        task: "mixin",
-                        detail,
-                        include,
-                        summary: {
-                            status: invalidCount > 0 ? "invalid" : partialCount > 0 ? "partial" : "ok",
-                            headline: `Validated ${summary?.total ?? 0} mixin input(s).`,
-                            subject: createSummarySubject({
-                                task: "mixin",
-                                kind: input.subject.kind,
-                                input: input.subject.input,
-                                version: input.version,
-                                mapping: input.mapping,
-                                sourcePriority: input.sourcePriority,
-                                scope: input.scope
-                            }),
-                            counts: {
-                                valid: summary?.valid ?? 0,
-                                partial: partialCount,
-                                invalid: invalidCount
-                            }
-                        },
-                        blocks: {
-                            project: {
-                                summary
-                            },
-                            issues: include.includes("issues") || detail !== "summary" ? output.results : undefined
-                        },
-                        alwaysBlocks: ["project"]
-                    }),
-                    warnings: Array.isArray(output.warnings) ? output.warnings : []
-                };
-            }
-            case "access-widener": {
-                if (input.subject.kind !== "access-widener") {
-                    throw createError({
-                        code: ERROR_CODES.INVALID_INPUT,
-                        message: "task=access-widener requires subject.kind=access-widener."
-                    });
-                }
-                const content = input.subject.input.mode === "inline"
-                    ? input.subject.input.content
-                    : await readFile(input.subject.input.path, "utf8");
-                const output = await this.deps.validateAccessWidener({
-                    content,
-                    version: input.version,
-                    mapping: input.mapping,
-                    sourcePriority: input.sourcePriority,
-                    scope: input.scope,
-                    preferProjectVersion: input.preferProjectVersion
-                });
-                return {
-                    ...buildEntryToolResult({
-                        task: "access-widener",
-                        detail,
-                        include,
-                        summary: {
-                            status: output.valid ? "ok" : "invalid",
-                            headline: output.valid
-                                ? "Access Widener is valid."
-                                : "Access Widener contains validation issues.",
-                            subject: createSummarySubject({
-                                task: "access-widener",
-                                kind: input.subject.kind,
-                                input: input.subject.input,
-                                version: input.version,
-                                mapping: input.mapping,
-                                sourcePriority: input.sourcePriority
-                            }),
-                            counts: {
-                                valid: output.valid ? 1 : 0,
-                                invalid: output.valid ? 0 : 1
-                            }
-                        },
-                        blocks: {
-                            project: {
-                                summary: {
-                                    total: 1,
-                                    valid: output.valid ? 1 : 0,
-                                    invalid: output.valid ? 0 : 1
-                                }
-                            },
-                            issues: include.includes("issues") || detail !== "summary" ? output.issues : undefined
-                        },
-                        alwaysBlocks: ["project"]
-                    }),
-                    warnings: Array.isArray(output.warnings) ? output.warnings : []
-                };
-            }
-            case "access-transformer": {
-                if (input.subject.kind !== "access-transformer") {
-                    throw createError({
-                        code: ERROR_CODES.INVALID_INPUT,
-                        message: "task=access-transformer requires subject.kind=access-transformer."
-                    });
-                }
-                const content = input.subject.input.mode === "inline"
-                    ? input.subject.input.content
-                    : await readFile(input.subject.input.path, "utf8");
-                if (!this.deps.validateAccessTransformer) {
-                    throw createError({
-                        code: ERROR_CODES.CONTEXT_UNRESOLVED,
-                        message: "Access Transformer validation is not configured."
-                    });
-                }
-                const output = await this.deps.validateAccessTransformer({
-                    content,
-                    version: input.version,
-                    atNamespace: input.atNamespace,
-                    sourcePriority: input.sourcePriority,
-                    scope: input.scope,
-                    preferProjectVersion: input.preferProjectVersion
-                });
-                const issueEntries = Array.isArray(output.entries)
-                    ? output.entries.filter((entry) => {
-                        if (!entry || typeof entry !== "object" || !("valid" in entry)) {
-                            return true;
-                        }
-                        return entry.valid !== true;
-                    })
-                    : undefined;
-                return {
-                    ...buildEntryToolResult({
-                        task: "access-transformer",
-                        detail,
-                        include,
-                        summary: {
-                            status: output.valid ? "ok" : "invalid",
-                            headline: output.valid
-                                ? "Access Transformer is valid."
-                                : "Access Transformer contains validation issues.",
-                            subject: createSummarySubject({
-                                task: "access-transformer",
-                                kind: input.subject.kind,
-                                input: input.subject.input,
-                                version: input.version,
-                                sourcePriority: input.sourcePriority,
-                                scope: input.scope,
-                                atNamespace: input.atNamespace
-                            }),
-                            counts: {
-                                valid: output.valid ? 1 : 0,
-                                invalid: output.valid ? 0 : 1
-                            }
-                        },
-                        blocks: {
-                            project: {
-                                summary: {
-                                    total: 1,
-                                    valid: output.valid ? 1 : 0,
-                                    invalid: output.valid ? 0 : 1
-                                }
-                            },
-                            issues: include.includes("issues") || detail !== "summary" ? issueEntries : undefined
-                        },
-                        alwaysBlocks: ["project"]
-                    }),
-                    warnings: Array.isArray(output.warnings) ? output.warnings : []
-                };
-            }
-            case "project-summary": {
-                if (input.subject.kind !== "workspace") {
-                    throw createError({
-                        code: ERROR_CODES.INVALID_INPUT,
-                        message: "task=project-summary requires subject.kind=workspace."
-                    });
-                }
-                if (!input.version && !input.preferProjectVersion) {
-                    return {
-                        ...buildEntryToolResult({
-                            task: "project-summary",
-                            detail,
-                            include,
-                            summary: {
-                                status: "blocked",
-                                headline: "project-summary requires version or preferProjectVersion=true.",
-                                subject: createSummarySubject({
-                                    task: "project-summary",
-                                    kind: input.subject.kind,
-                                    projectPath: input.subject.projectPath,
-                                    discover: input.subject.discover
-                                }),
-                                nextActions: [
-                                    {
-                                        tool: "validate-project",
-                                        params: {
-                                            task: "project-summary",
-                                            subject: input.subject
-                                        }
-                                    }
-                                ],
-                                notes: [
-                                    "Pass version explicitly, or retry with preferProjectVersion=true when gradle.properties declares the Minecraft version."
-                                ]
-                            },
-                            blocks: {
-                                workspace: {
-                                    projectPath: input.subject.projectPath
-                                }
-                            }
-                        }),
-                        warnings: []
-                    };
-                }
-                const projectPath = input.subject.projectPath;
-                const detectedProjectVersion = input.preferProjectVersion
-                    ? await this.deps.detectProjectMinecraftVersion?.(projectPath)
-                    : undefined;
-                const resolvedVersion = detectedProjectVersion ?? input.version;
-                const discover = input.subject.discover ?? ["mixins", "access-wideners"];
-                const [mixinConfigs, accessWideners, accessTransformers] = await Promise.all([
-                    discover.includes("mixins")
-                        ? this.deps.discoverMixins(projectPath, input.configPaths)
-                        : Promise.resolve([]),
-                    discover.includes("access-wideners")
-                        ? this.deps.discoverAccessWideners(projectPath)
-                        : Promise.resolve([]),
-                    discover.includes("access-transformers")
-                        ? this.deps.discoverAccessTransformers?.(projectPath) ?? Promise.resolve([])
-                        : Promise.resolve([])
-                ]);
-                if (!resolvedVersion && (mixinConfigs.length > 0 || accessWideners.length > 0 || accessTransformers.length > 0)) {
-                    return {
-                        ...buildEntryToolResult({
-                            task: "project-summary",
-                            detail,
-                            include,
-                            summary: {
-                                status: "blocked",
-                                headline: "Could not resolve Minecraft version for discovered workspace validators.",
-                                subject: createSummarySubject({
-                                    task: "project-summary",
-                                    kind: input.subject.kind,
-                                    projectPath,
-                                    discover: input.subject.discover,
-                                    mapping: input.mapping,
-                                    sourcePriority: input.sourcePriority,
-                                    scope: input.scope
-                                }),
-                                nextActions: [
-                                    {
-                                        tool: "validate-project",
-                                        params: {
-                                            task: "project-summary",
-                                            subject: input.subject
-                                        }
-                                    }
-                                ],
-                                notes: [
-                                    "Pass version explicitly, or make sure gradle.properties declares the Minecraft version before using preferProjectVersion=true."
-                                ]
-                            },
-                            blocks: {
-                                workspace: {
-                                    projectPath
-                                }
-                            }
-                        }),
-                        warnings: [
-                            "Could not resolve Minecraft version from gradle.properties for discovered workspace validators."
-                        ]
-                    };
-                }
-                if (!resolvedVersion) {
-                    return {
-                        ...buildEntryToolResult({
-                            task: "project-summary",
-                            detail,
-                            include,
-                            summary: {
-                                status: "ok",
-                                headline: `Validated ${mixinConfigs.length} mixin config(s), ${accessWideners.length} access widener(s), and ${accessTransformers.length} access transformer(s).`,
-                                subject: createSummarySubject({
-                                    task: "project-summary",
-                                    kind: input.subject.kind,
-                                    projectPath,
-                                    discover: input.subject.discover,
-                                    mapping: input.mapping,
-                                    sourcePriority: input.sourcePriority,
-                                    scope: input.scope
-                                }),
-                                counts: {
-                                    valid: 0,
-                                    partial: 0,
-                                    invalid: 0
-                                }
-                            },
-                            blocks: {
-                                workspace: {
-                                    projectPath
-                                }
-                            }
-                        }),
-                        warnings: []
-                    };
-                }
-                const validationVersion = resolvedVersion;
-                const warnings = [];
-                let validMixins = 0;
-                let partialMixins = 0;
-                let invalidMixins = 0;
-                for (const configPath of mixinConfigs) {
-                    try {
-                        const mixinResult = await this.deps.validateMixin({
-                            input: {
-                                mode: "config",
-                                configPaths: [configPath]
-                            },
-                            version: validationVersion,
-                            mapping: input.mapping,
-                            sourcePriority: input.sourcePriority,
-                            scope: input.scope,
-                            projectPath,
-                            preferProjectVersion: false,
-                            preferProjectMapping: input.preferProjectMapping,
-                            sourceRoots: input.sourceRoots,
-                            minSeverity: input.minSeverity,
-                            hideUncertain: input.hideUncertain,
-                            explain: input.explain,
-                            warningMode: input.warningMode,
-                            warningCategoryFilter: input.warningCategoryFilter,
-                            treatInfoAsWarning: input.treatInfoAsWarning,
-                            includeIssues: input.includeIssues
-                        });
-                        const summary = mixinResult.summary;
-                        validMixins += summary?.valid ?? 0;
-                        partialMixins += summary?.partial ?? 0;
-                        invalidMixins += summary?.invalid ?? 0;
-                        if (Array.isArray(mixinResult.warnings)) {
-                            warnings.push(...mixinResult.warnings);
-                        }
-                    }
-                    catch (error) {
-                        invalidMixins += 1;
-                        if (error instanceof Error) {
-                            warnings.push(`${configPath}: ${error.message}`);
-                        }
-                    }
-                }
-                let validAw = 0;
-                let invalidAw = 0;
-                for (const awPath of accessWideners) {
-                    try {
-                        const output = await this.deps.validateAccessWidener({
-                            content: await readFile(awPath, "utf8"),
-                            version: validationVersion,
-                            mapping: input.mapping,
-                            sourcePriority: input.sourcePriority,
-                            projectPath,
-                            scope: input.scope,
-                            preferProjectVersion: input.preferProjectVersion
-                        });
-                        if (output.valid) {
-                            validAw += 1;
-                        }
-                        else {
-                            invalidAw += 1;
-                        }
-                        if (Array.isArray(output.warnings)) {
-                            warnings.push(...output.warnings);
-                        }
-                    }
-                    catch (error) {
-                        invalidAw += 1;
-                        if (error instanceof Error) {
-                            warnings.push(error.message);
-                        }
-                    }
-                }
-                let validAt = 0;
-                let invalidAt = 0;
-                for (const atPath of accessTransformers) {
-                    try {
-                        if (!this.deps.validateAccessTransformer) {
-                            throw createError({
-                                code: ERROR_CODES.CONTEXT_UNRESOLVED,
-                                message: "Access Transformer validation is not configured."
-                            });
-                        }
-                        const output = await this.deps.validateAccessTransformer({
-                            content: await readFile(atPath, "utf8"),
-                            version: validationVersion,
-                            atNamespace: input.atNamespace,
-                            sourcePriority: input.sourcePriority,
-                            projectPath,
-                            scope: input.scope,
-                            preferProjectVersion: input.preferProjectVersion
-                        });
-                        if (output.valid) {
-                            validAt += 1;
-                        }
-                        else {
-                            invalidAt += 1;
-                        }
-                        if (Array.isArray(output.warnings)) {
-                            warnings.push(...output.warnings);
-                        }
-                    }
-                    catch (error) {
-                        invalidAt += 1;
-                        if (error instanceof Error) {
-                            warnings.push(error.message);
-                        }
-                    }
-                }
-                const invalidCount = invalidMixins + invalidAw + invalidAt;
-                const partialCount = partialMixins;
-                const status = invalidCount > 0 ? "invalid" : partialCount > 0 ? "partial" : "ok";
-                return {
-                    ...buildEntryToolResult({
-                        task: "project-summary",
-                        detail,
-                        include,
-                        summary: {
-                            status,
-                            headline: `Validated ${mixinConfigs.length} mixin config(s), ${accessWideners.length} access widener(s), and ${accessTransformers.length} access transformer(s).`,
-                            subject: createSummarySubject({
-                                task: "project-summary",
-                                kind: input.subject.kind,
-                                projectPath,
-                                discover: input.subject.discover,
-                                version: resolvedVersion,
-                                mapping: input.mapping,
-                                sourcePriority: input.sourcePriority,
-                                scope: input.scope
-                            }),
-                            counts: {
-                                valid: validMixins + validAw + validAt,
-                                partial: partialCount,
-                                invalid: invalidCount
-                            }
-                        },
-                        blocks: {
-                            project: {
-                                summary: {
-                                    valid: validMixins + validAw + validAt,
-                                    partial: partialCount,
-                                    invalid: invalidCount
-                                }
-                            },
-                            workspace: {
-                                projectPath,
-                                mixinConfigs,
-                                accessWideners,
-                                accessTransformers
-                            }
-                        },
-                        alwaysBlocks: ["project"]
-                    }),
-                    warnings
-                };
-            }
+            case "mixin":
+                return handleMixin(this.deps, input, detail, include);
+            case "access-widener":
+                return handleAccessWidener(this.deps, input, detail, include);
+            case "access-transformer":
+                return handleAccessTransformer(this.deps, input, detail, include);
+            case "project-summary":
+                return handleProjectSummary(this.deps, input, detail, include);
         }
     }
 }

package/dist/entry-tools/verify-mixin-target-service.d.ts

@@ -0,0 +1,133 @@
+import { z } from "zod";
+import type { ArtifactProvenance, ArtifactScope, DependencyResolutionProvenance, MappingSourcePriority, ResolveArtifactTargetInput, SourceMapping, WorkspaceResolutionProvenance } from "../types.js";
+export declare const VERIFY_MIXIN_TARGET_OFF: boolean;
+export type VerifyMixinTargetInput = {
+    owner: string;
+    member: {
+        kind: "method";
+        name: string;
+        descriptor?: string;
+    } | {
+        kind: "field";
+        name: string;
+        descriptor?: string;
+    };
+    mixinMemberName?: string;
+    mapping?: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
+    projectPath?: string;
+    target?: ResolveArtifactTargetInput;
+    scope?: ArtifactScope;
+    preferProjectVersion?: boolean;
+    strictVersion?: boolean;
+};
+export type VerifyMixinTargetMatch = {
+    name: string;
+    descriptor: string;
+    accessFlags: string[];
+    javaSignature?: string;
+};
+export type VerifyMixinTargetCandidate = {
+    name: string;
+    descriptor: string;
+    reason: string;
+};
+type SuggestedAnnotation = "@Shadow" | "@Accessor" | "@Invoker" | "@Inject-only";
+export type AccessorAdvice = {
+    suggestedAnnotation: SuggestedAnnotation | null;
+    reasoning: string;
+    exampleSnippet: string;
+    candidates?: Array<{
+        annotation: "@Shadow" | "@Accessor" | "@Invoker";
+        reasoning: string;
+        exampleSnippet: string;
+    }>;
+};
+export type VerifyMixinTargetOutput = {
+    exists: boolean;
+    resolvedOwner: {
+        className: string;
+        mapping: SourceMapping;
+    };
+    matches: VerifyMixinTargetMatch[];
+    candidates: VerifyMixinTargetCandidate[];
+    accessorAdvice?: AccessorAdvice;
+    warnings: string[];
+    provenance: {
+        artifactId: string;
+        mappingNamespace: SourceMapping;
+        workspaceResolution?: WorkspaceResolutionProvenance;
+        dependencyResolution?: DependencyResolutionProvenance;
+    };
+};
+type ExplorerSignatureMember = {
+    ownerFqn: string;
+    name: string;
+    javaSignature: string;
+    jvmDescriptor: string;
+    accessFlags: number;
+    isSynthetic: boolean;
+    sourceLine?: number;
+};
+type ExplorerSignatureOutput = {
+    classAccessFlags?: number;
+    constructors: ExplorerSignatureMember[];
+    methods: ExplorerSignatureMember[];
+    fields: ExplorerSignatureMember[];
+    warnings: string[];
+};
+export type VerifyMixinTargetDeps = {
+    resolveArtifact: (input: {
+        target: ResolveArtifactTargetInput;
+        mapping?: SourceMapping;
+        sourcePriority?: MappingSourcePriority;
+        projectPath?: string;
+        scope?: ArtifactScope;
+        preferProjectVersion?: boolean;
+        strictVersion?: boolean;
+    }) => Promise<{
+        artifactId: string;
+        mappingApplied: SourceMapping;
+        binaryJarPath?: string;
+        provenance?: ArtifactProvenance;
+        warnings?: string[];
+    }>;
+    getSignature: (input: {
+        fqn: string;
+        jarPath: string;
+        access: "public" | "all";
+        includeSynthetic: boolean;
+        includeInherited: boolean;
+    }) => Promise<ExplorerSignatureOutput>;
+};
+export declare class VerifyMixinTargetService {
+    private readonly deps;
+    constructor(deps: VerifyMixinTargetDeps);
+    execute(input: VerifyMixinTargetInput): Promise<VerifyMixinTargetOutput>;
+}
+export declare const verifyMixinTargetMemberSchemaExport: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"method">;
+    name: z.ZodString;
+    descriptor: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    kind: "method";
+    descriptor?: string | undefined;
+}, {
+    name: string;
+    kind: "method";
+    descriptor?: string | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"field">;
+    name: z.ZodString;
+    descriptor: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    kind: "field";
+    descriptor?: string | undefined;
+}, {
+    name: string;
+    kind: "field";
+    descriptor?: string | undefined;
+}>]>;
+export {};