@adhisang/minecraft-modding-mcp 4.0.0 → 4.1.1

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

@@ -0,0 +1,303 @@
+import { stat, readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { isAppError } from "../../errors.js";
+import { buildVersionSourceSearchRoots } from "../../gradle-paths.js";
+const VALIDATE_PROJECT_TASKS_OFF = process.env.VALIDATE_PROJECT_TASKS_OFF === "1";
+const TASK_KEYS = [
+    "workspace.detected",
+    "gradle.readable",
+    "loom.cache.found",
+    "minecraft.artifact.resolved",
+    "mixins.validated",
+    "accessWideners.validated",
+    "accessTransformers.validated"
+];
+// Helpers live as free functions so ValidateProjectService keeps its baseline
+// declaration surface (constructor + execute only).
+async function pathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function probeWorkspaceDetected(projectPath) {
+    const startedAt = Date.now();
+    const candidates = [
+        "gradle.properties",
+        "settings.gradle",
+        "settings.gradle.kts",
+        "build.gradle",
+        "build.gradle.kts"
+    ];
+    try {
+        const evidence = [];
+        for (const candidate of candidates) {
+            if (await pathExists(resolve(projectPath, candidate))) {
+                evidence.push(candidate);
+            }
+        }
+        const durationMs = Date.now() - startedAt;
+        if (evidence.length === 0) {
+            return { status: "missing", durationMs };
+        }
+        return { status: "ok", durationMs, evidence };
+    }
+    catch (error) {
+        return {
+            status: "error",
+            durationMs: Date.now() - startedAt,
+            error: {
+                code: isAppError(error) ? error.code : "ERR_PROBE_FAILED",
+                detail: error instanceof Error ? error.message : String(error)
+            }
+        };
+    }
+}
+async function probeGradleReadable(projectPath) {
+    const startedAt = Date.now();
+    const propertiesPath = resolve(projectPath, "gradle.properties");
+    try {
+        const propsExists = await pathExists(propertiesPath);
+        let propsRead = false;
+        if (propsExists) {
+            await readFile(propertiesPath, "utf8");
+            propsRead = true;
+        }
+        const buildScriptCandidates = [
+            "build.gradle",
+            "build.gradle.kts",
+            "settings.gradle",
+            "settings.gradle.kts"
+        ];
+        const buildScripts = [];
+        for (const candidate of buildScriptCandidates) {
+            if (await pathExists(resolve(projectPath, candidate))) {
+                buildScripts.push(candidate);
+            }
+        }
+        const durationMs = Date.now() - startedAt;
+        if (!propsExists && buildScripts.length === 0) {
+            return { status: "missing", durationMs };
+        }
+        return {
+            status: "ok",
+            durationMs,
+            ...(propsRead ? { propertiesPath } : {}),
+            buildScripts
+        };
+    }
+    catch (error) {
+        return {
+            status: "error",
+            durationMs: Date.now() - startedAt,
+            error: {
+                code: isAppError(error) ? error.code : "ERR_GRADLE_READ_FAILED",
+                detail: error instanceof Error ? error.message : String(error)
+            }
+        };
+    }
+}
+async function probeLoomCacheFound(projectPath) {
+    const startedAt = Date.now();
+    try {
+        const roots = buildVersionSourceSearchRoots(projectPath);
+        for (const root of roots) {
+            if (await pathExists(root)) {
+                return {
+                    status: "ok",
+                    durationMs: Date.now() - startedAt,
+                    cachePath: root
+                };
+            }
+        }
+        return { status: "missing", durationMs: Date.now() - startedAt };
+    }
+    catch (error) {
+        return {
+            status: "error",
+            durationMs: Date.now() - startedAt,
+            error: {
+                code: isAppError(error) ? error.code : "ERR_LOOM_PROBE_FAILED",
+                detail: error instanceof Error ? error.message : String(error)
+            }
+        };
+    }
+}
+async function probeMinecraftArtifactResolved(artifactProbe, args, stageEmitter) {
+    const startedAt = Date.now();
+    // Stage notification kept outside the probe's try block: a telemetry
+    // failure must not be classified as ERR_ARTIFACT_PROBE_FAILED.
+    try {
+        await stageEmitter?.("validate-project:artifact-probe", {
+            version: args.version,
+            mapping: args.mapping ?? "obfuscated",
+            projectPath: args.projectPath,
+            scope: args.scope ?? null
+        });
+    }
+    catch {
+        // swallow telemetry failure
+    }
+    try {
+        const output = await artifactProbe({
+            target: { kind: "version", value: args.version },
+            mapping: args.mapping,
+            sourcePriority: args.sourcePriority,
+            projectPath: args.projectPath,
+            scope: args.scope,
+            preferProjectVersion: args.preferProjectVersion
+        });
+        return {
+            status: "ok",
+            durationMs: Date.now() - startedAt,
+            artifactId: output.artifactId,
+            mapping: output.mappingApplied,
+            ...(Array.isArray(output.warnings) && output.warnings.length > 0
+                ? { warnings: output.warnings }
+                : {})
+        };
+    }
+    catch (error) {
+        return {
+            status: "error",
+            durationMs: Date.now() - startedAt,
+            error: {
+                code: isAppError(error) ? error.code : "ERR_ARTIFACT_PROBE_FAILED",
+                detail: error instanceof Error ? error.message : String(error)
+            }
+        };
+    }
+}
+function downstreamSkipReason(report, upstream) {
+    for (const key of upstream) {
+        const entry = report[key];
+        if (entry.status !== "ok") {
+            return { status: "skipped" };
+        }
+    }
+    return undefined;
+}
+function buildValidationEntryWithCounts(upstream, discoveredCount, errorCount, counts, durationMs) {
+    // Real validator outcomes win over upstream skip when validators ran.
+    // The artifact probe is informational; its failure must not erase real counts.
+    if (discoveredCount > 0 || errorCount > 0) {
+        if (errorCount > 0) {
+            return { status: "error", durationMs, counts };
+        }
+        return { status: "ok", durationMs, counts };
+    }
+    if (upstream) {
+        return upstream;
+    }
+    return { status: "missing", durationMs };
+}
+function projectTaskEntry(entry, detail, include) {
+    const fullDetail = detail !== "summary" && include.includes("workspace");
+    if (fullDetail) {
+        return entry;
+    }
+    const slim = { status: entry.status };
+    if (entry.error) {
+        slim.error = entry.error;
+    }
+    if (entry.warnings && entry.warnings.length > 0) {
+        slim.warnings = entry.warnings;
+    }
+    return slim;
+}
+function projectTaskStatusReport(report, detail, include) {
+    const projected = {};
+    for (const key of TASK_KEYS) {
+        projected[key] = projectTaskEntry(report[key], detail, include);
+    }
+    return projected;
+}
+export async function runUpstreamProbes(projectPath) {
+    const workspace = await probeWorkspaceDetected(projectPath);
+    const loom = await probeLoomCacheFound(projectPath);
+    let gradle;
+    if (workspace.status !== "ok") {
+        gradle = { status: "skipped" };
+    }
+    else {
+        gradle = await probeGradleReadable(projectPath);
+    }
+    return { workspace, gradle, loom };
+}
+export async function buildEarlyTasksForBlocked(projectPath, detail, include, discovery) {
+    if (VALIDATE_PROJECT_TASKS_OFF) {
+        return undefined;
+    }
+    const { workspace, gradle, loom } = await runUpstreamProbes(projectPath);
+    const minecraftArtifactResolved = {
+        status: "skipped"
+    };
+    const validatedSkipped = { status: "skipped" };
+    const buildValidatorEntry = (discoveredCount) => {
+        if (workspace.status !== "ok" || gradle.status !== "ok") {
+            return validatedSkipped;
+        }
+        if (minecraftArtifactResolved.status !== "ok") {
+            return validatedSkipped;
+        }
+        return discoveredCount === 0 || discoveredCount === undefined
+            ? { status: "missing" }
+            : validatedSkipped;
+    };
+    const report = {
+        "workspace.detected": workspace,
+        "gradle.readable": gradle,
+        "loom.cache.found": loom,
+        "minecraft.artifact.resolved": minecraftArtifactResolved,
+        "mixins.validated": buildValidatorEntry(discovery?.mixinDiscoveryCount),
+        "accessWideners.validated": buildValidatorEntry(discovery?.awDiscoveryCount),
+        "accessTransformers.validated": buildValidatorEntry(discovery?.atDiscoveryCount)
+    };
+    return projectTaskStatusReport(report, detail, include);
+}
+export async function buildFullTaskStatusReport(deps, args) {
+    if (VALIDATE_PROJECT_TASKS_OFF) {
+        return undefined;
+    }
+    const { workspace, gradle, loom } = await runUpstreamProbes(args.projectPath);
+    let minecraftArtifactResolved;
+    if (workspace.status !== "ok" || gradle.status !== "ok") {
+        minecraftArtifactResolved = { status: "skipped" };
+    }
+    else if (deps.probeMinecraftArtifact ?? deps.resolveArtifact) {
+        const artifactProbe = deps.probeMinecraftArtifact ?? deps.resolveArtifact;
+        minecraftArtifactResolved = await probeMinecraftArtifactResolved(artifactProbe, {
+            version: args.resolvedVersion,
+            mapping: args.mapping,
+            sourcePriority: args.sourcePriority,
+            projectPath: args.projectPath,
+            scope: args.scope,
+            preferProjectVersion: args.preferProjectVersion
+        }, args.stageEmitter);
+    }
+    else {
+        minecraftArtifactResolved = { status: "skipped" };
+    }
+    const upstreamSkip = downstreamSkipReason({
+        "workspace.detected": workspace,
+        "gradle.readable": gradle,
+        "minecraft.artifact.resolved": minecraftArtifactResolved
+    }, ["workspace.detected", "gradle.readable", "minecraft.artifact.resolved"]);
+    const mixinsValidated = buildValidationEntryWithCounts(upstreamSkip, args.mixinDiscoveryCount, args.mixinCaughtErrors, args.mixinCounts, args.mixinDurationMs);
+    const accessWidenersValidated = buildValidationEntryWithCounts(upstreamSkip, args.awDiscoveryCount, args.awCaughtErrors, args.awCounts, args.awDurationMs);
+    const accessTransformersValidated = buildValidationEntryWithCounts(upstreamSkip, args.atDiscoveryCount, args.atCaughtErrors, args.atCounts, args.atDurationMs);
+    const report = {
+        "workspace.detected": workspace,
+        "gradle.readable": gradle,
+        "loom.cache.found": loom,
+        "minecraft.artifact.resolved": minecraftArtifactResolved,
+        "mixins.validated": mixinsValidated,
+        "accessWideners.validated": accessWidenersValidated,
+        "accessTransformers.validated": accessTransformersValidated
+    };
+    return projectTaskStatusReport(report, args.detail, args.include);
+}
+//# sourceMappingURL=internal.js.map

package/dist/entry-tools/validate-project-service.d.ts

@@ -1,4 +1,52 @@
 import { z } from "zod";
+import type { StageEmitter } from "../stage-emitter.js";
+import type { SourceMapping } from "../types.js";
+import { type ValidateProjectDeps } from "./validate-project/internal.js";
+export type TaskStatus = "ok" | "skipped" | "missing" | "error";
+type TaskEntryBase = {
+    status: TaskStatus;
+    durationMs?: number;
+    error?: {
+        code: string;
+        detail: string;
+    };
+    warnings?: string[];
+};
+export type TaskStatusReport = {
+    "workspace.detected": TaskEntryBase & {
+        evidence?: string[];
+    };
+    "gradle.readable": TaskEntryBase & {
+        propertiesPath?: string;
+        buildScripts?: string[];
+    };
+    "loom.cache.found": TaskEntryBase & {
+        cachePath?: string;
+    };
+    "minecraft.artifact.resolved": TaskEntryBase & {
+        artifactId?: string;
+        mapping?: SourceMapping;
+    };
+    "mixins.validated": TaskEntryBase & {
+        counts?: {
+            ok: number;
+            partial: number;
+            invalid: number;
+        };
+    };
+    "accessWideners.validated": TaskEntryBase & {
+        counts?: {
+            ok: number;
+            invalid: number;
+        };
+    };
+    "accessTransformers.validated": TaskEntryBase & {
+        counts?: {
+            ok: number;
+            invalid: number;
+        };
+    };
+};
 export declare const validateProjectShape: {
     task: z.ZodEnum<["project-summary", "mixin", "access-widener", "access-transformer"]>;
     subject: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
@@ -397,7 +445,7 @@ export declare const validateProjectSchema: z.ZodEffects<z.ZodObject<{
     preferProjectMapping: boolean;
     treatInfoAsWarning: boolean;
     includeIssues: boolean;
-    task: "mixin" | "access-widener" | "access-transformer" | "project-summary";
+    task: "mixin" | "project-summary" | "access-widener" | "access-transformer";
     subject: {
         kind: "workspace";
         projectPath: string;
@@ -439,20 +487,20 @@ export declare const validateProjectSchema: z.ZodEffects<z.ZodObject<{
             mode: "path";
         };
     };
-    mapping?: "intermediary" | "mojang" | "yarn" | "obfuscated" | undefined;
     version?: string | undefined;
-    scope?: "loader" | "merged" | "vanilla" | undefined;
+    mapping?: "obfuscated" | "mojang" | "intermediary" | "yarn" | undefined;
+    scope?: "vanilla" | "merged" | "loader" | undefined;
     sourcePriority?: "loom-first" | "maven-first" | undefined;
     sourceRoots?: string[] | undefined;
     preferProjectVersion?: boolean | undefined;
     warningMode?: "full" | "aggregated" | undefined;
     warningCategoryFilter?: ("mapping" | "parse" | "validation" | "configuration" | "resolution")[] | undefined;
-    atNamespace?: "mojang" | "obfuscated" | "srg" | undefined;
     configPaths?: string[] | undefined;
+    atNamespace?: "obfuscated" | "mojang" | "srg" | undefined;
     detail?: "full" | "summary" | "standard" | undefined;
     include?: string[] | undefined;
 }, {
-    task: "mixin" | "access-widener" | "access-transformer" | "project-summary";
+    task: "mixin" | "project-summary" | "access-widener" | "access-transformer";
     subject: {
         kind: "workspace";
         projectPath: string;
@@ -494,9 +542,9 @@ export declare const validateProjectSchema: z.ZodEffects<z.ZodObject<{
             mode: "path";
         };
     };
-    mapping?: "intermediary" | "mojang" | "yarn" | "obfuscated" | undefined;
     version?: string | undefined;
-    scope?: "loader" | "merged" | "vanilla" | undefined;
+    mapping?: "obfuscated" | "mojang" | "intermediary" | "yarn" | undefined;
+    scope?: "vanilla" | "merged" | "loader" | undefined;
     sourcePriority?: "loom-first" | "maven-first" | undefined;
     sourceRoots?: string[] | undefined;
     preferProjectVersion?: boolean | undefined;
@@ -508,8 +556,8 @@ export declare const validateProjectSchema: z.ZodEffects<z.ZodObject<{
     warningCategoryFilter?: ("mapping" | "parse" | "validation" | "configuration" | "resolution")[] | undefined;
     treatInfoAsWarning?: boolean | undefined;
     includeIssues?: boolean | undefined;
-    atNamespace?: "mojang" | "obfuscated" | "srg" | undefined;
     configPaths?: string[] | undefined;
+    atNamespace?: "obfuscated" | "mojang" | "srg" | undefined;
     detail?: "full" | "summary" | "standard" | undefined;
     include?: string[] | undefined;
 }>, {
@@ -519,7 +567,7 @@ export declare const validateProjectSchema: z.ZodEffects<z.ZodObject<{
     preferProjectMapping: boolean;
     treatInfoAsWarning: boolean;
     includeIssues: boolean;
-    task: "mixin" | "access-widener" | "access-transformer" | "project-summary";
+    task: "mixin" | "project-summary" | "access-widener" | "access-transformer";
     subject: {
         kind: "workspace";
         projectPath: string;
@@ -561,20 +609,20 @@ export declare const validateProjectSchema: z.ZodEffects<z.ZodObject<{
             mode: "path";
         };
     };
-    mapping?: "intermediary" | "mojang" | "yarn" | "obfuscated" | undefined;
     version?: string | undefined;
-    scope?: "loader" | "merged" | "vanilla" | undefined;
+    mapping?: "obfuscated" | "mojang" | "intermediary" | "yarn" | undefined;
+    scope?: "vanilla" | "merged" | "loader" | undefined;
     sourcePriority?: "loom-first" | "maven-first" | undefined;
     sourceRoots?: string[] | undefined;
     preferProjectVersion?: boolean | undefined;
     warningMode?: "full" | "aggregated" | undefined;
     warningCategoryFilter?: ("mapping" | "parse" | "validation" | "configuration" | "resolution")[] | undefined;
-    atNamespace?: "mojang" | "obfuscated" | "srg" | undefined;
     configPaths?: string[] | undefined;
+    atNamespace?: "obfuscated" | "mojang" | "srg" | undefined;
     detail?: "full" | "summary" | "standard" | undefined;
     include?: string[] | undefined;
 }, {
-    task: "mixin" | "access-widener" | "access-transformer" | "project-summary";
+    task: "mixin" | "project-summary" | "access-widener" | "access-transformer";
     subject: {
         kind: "workspace";
         projectPath: string;
@@ -616,9 +664,9 @@ export declare const validateProjectSchema: z.ZodEffects<z.ZodObject<{
             mode: "path";
         };
     };
-    mapping?: "intermediary" | "mojang" | "yarn" | "obfuscated" | undefined;
     version?: string | undefined;
-    scope?: "loader" | "merged" | "vanilla" | undefined;
+    mapping?: "obfuscated" | "mojang" | "intermediary" | "yarn" | undefined;
+    scope?: "vanilla" | "merged" | "loader" | undefined;
     sourcePriority?: "loom-first" | "maven-first" | undefined;
     sourceRoots?: string[] | undefined;
     preferProjectVersion?: boolean | undefined;
@@ -630,42 +678,14 @@ export declare const validateProjectSchema: z.ZodEffects<z.ZodObject<{
     warningCategoryFilter?: ("mapping" | "parse" | "validation" | "configuration" | "resolution")[] | undefined;
     treatInfoAsWarning?: boolean | undefined;
     includeIssues?: boolean | undefined;
-    atNamespace?: "mojang" | "obfuscated" | "srg" | undefined;
     configPaths?: string[] | undefined;
+    atNamespace?: "obfuscated" | "mojang" | "srg" | undefined;
     detail?: "full" | "summary" | "standard" | undefined;
     include?: string[] | undefined;
 }>;
 export type ValidateProjectInput = z.infer<typeof validateProjectSchema>;
-type ValidateProjectDeps = {
-    validateMixin: (input: Record<string, unknown>) => Promise<Record<string, unknown> & {
-        warnings?: string[];
-    }>;
-    validateAccessWidener: (input: {
-        content: string;
-        version: string;
-        mapping?: "obfuscated" | "mojang" | "intermediary" | "yarn";
-        sourcePriority?: "loom-first" | "maven-first";
-        projectPath?: string;
-        scope?: "vanilla" | "merged" | "loader";
-        preferProjectVersion?: boolean;
-    }) => Promise<Record<string, unknown> & {
-        warnings?: string[];
-    }>;
-    validateAccessTransformer?: (input: {
-        content: string;
-        version: string;
-        atNamespace?: "srg" | "mojang" | "obfuscated";
-        sourcePriority?: "loom-first" | "maven-first";
-        projectPath?: string;
-        scope?: "vanilla" | "merged" | "loader";
-        preferProjectVersion?: boolean;
-    }) => Promise<Record<string, unknown> & {
-        warnings?: string[];
-    }>;
-    discoverMixins: (projectPath: string, configPaths?: string[]) => Promise<string[]>;
-    discoverAccessWideners: (projectPath: string) => Promise<string[]>;
-    discoverAccessTransformers?: (projectPath: string) => Promise<string[]>;
-    detectProjectMinecraftVersion?: (projectPath: string) => Promise<string | undefined>;
+export type ValidateProjectExecuteOptions = {
+    stageEmitter?: StageEmitter;
 };
 export declare function discoverWorkspaceMixins(projectPath: string, configPaths?: string[]): Promise<string[]>;
 export declare function discoverWorkspaceAccessWideners(projectPath: string): Promise<string[]>;
@@ -673,7 +693,7 @@ export declare function discoverWorkspaceAccessTransformers(projectPath: string)
 export declare class ValidateProjectService {
     private readonly deps;
     constructor(deps: ValidateProjectDeps);
-    execute(input: ValidateProjectInput): Promise<Record<string, unknown> & {
+    execute(input: ValidateProjectInput, options?: ValidateProjectExecuteOptions): Promise<Record<string, unknown> & {
         warnings?: string[];
     }>;
 }