@adhisang/minecraft-modding-mcp 1.1.1 → 1.2.1

package/dist/mixin-validator.js

@@ -44,6 +44,58 @@ export function suggestSimilar(name, candidates, maxDistance = 3, maxResults = 3
     return scored.slice(0, maxResults).map((s) => s.candidate);
 }
 /* ------------------------------------------------------------------ */
+/*  Method reference helpers                                           */
+/* ------------------------------------------------------------------ */
+/**
+ * Strip owner prefix (`Lowner;`) and JVM descriptor (`(...)V`) from a
+ * Mixin method reference, returning just the method name.
+ *
+ * Examples:
+ *   "playerTouch(Lnet/minecraft/world/entity/player/Player;)V" → "playerTouch"
+ *   "Lnet/minecraft/SomeClass;tick(I)V"                        → "tick"
+ *   "<init>"                                                    → "<init>"
+ *   "<init>()V"                                                 → "<init>"
+ *   "tick"                                                      → "tick"
+ */
+function stripOwnerPrefix(ref) {
+    if (!ref.startsWith("L"))
+        return ref;
+    const ownerEnd = ref.indexOf(";");
+    if (ownerEnd === -1)
+        return ref;
+    const parenIdx = ref.indexOf("(");
+    // Owner prefixes appear before the descriptor, e.g. Lpkg/Class;method(I)V.
+    // If ';' appears inside the descriptor, this is not an owner prefix.
+    if (parenIdx !== -1 && ownerEnd > parenIdx)
+        return ref;
+    return ref.substring(ownerEnd + 1);
+}
+export function extractMethodName(ref) {
+    let s = stripOwnerPrefix(ref);
+    // Remove descriptor: everything from '(' onwards
+    const parenIdx = s.indexOf("(");
+    if (parenIdx !== -1) {
+        s = s.substring(0, parenIdx);
+    }
+    return s;
+}
+/**
+ * Extract the JVM descriptor portion from a method reference, if present.
+ *
+ * Examples:
+ *   "playerTouch(Lnet/minecraft/world/entity/player/Player;)V" → "(Lnet/minecraft/world/entity/player/Player;)V"
+ *   "tick"                                                      → undefined
+ */
+export function extractMethodDescriptor(ref) {
+    // After stripping optional owner prefix, find '('
+    const s = stripOwnerPrefix(ref);
+    const parenIdx = s.indexOf("(");
+    if (parenIdx !== -1) {
+        return s.substring(parenIdx);
+    }
+    return undefined;
+}
+/* ------------------------------------------------------------------ */
 /*  Mixin validation                                                   */
 /* ------------------------------------------------------------------ */
 function allMethodNames(members) {
@@ -55,49 +107,133 @@ function allMethodNames(members) {
 function allFieldNames(members) {
     return members.fields.map((m) => m.name);
 }
-function allMemberNames(members) {
-    return [...allMethodNames(members), ...allFieldNames(members)];
+function computeFalsePositiveRisk(healthReport, resolutionPath, issueConfidence) {
+    if (!healthReport)
+        return undefined;
+    if (healthReport.overallHealthy === false) {
+        if (resolutionPath === "source-signature-unavailable" ||
+            resolutionPath === "target-mapping-failed" ||
+            resolutionPath === "member-remap-failed")
+            return "high";
+        if (issueConfidence === "uncertain")
+            return "medium";
+        return "medium";
+    }
+    if (healthReport.memberRemapAvailable === false) {
+        if (resolutionPath === "member-remap-failed")
+            return "high";
+        if (issueConfidence === "uncertain")
+            return "medium";
+    }
+    return undefined;
 }
-function validateInjection(inj, targetMembers, targetNames, issues) {
+function computeConfidenceScore(healthReport, provenance, remapFailureCount) {
+    let score = 100;
+    if (healthReport) {
+        if (!healthReport.overallHealthy)
+            score -= 30;
+        if (!healthReport.tinyMappingsAvailable)
+            score -= 20;
+        if (!healthReport.memberRemapAvailable)
+            score -= 15;
+    }
+    if (provenance?.scopeFallback)
+        score -= 10;
+    if (provenance && provenance.requestedMapping !== provenance.mappingApplied)
+        score -= 15;
+    score -= Math.min(remapFailureCount * 2, 20);
+    return Math.max(score, 0);
+}
+function validateInjection(inj, targetMembers, targetNames, issues, resolvedMembers, confidence, confidenceReason, remapFailedMembers, signatureFailedTargets, healthReport) {
     for (const targetName of targetNames) {
         const members = targetMembers.get(targetName);
         if (!members)
             continue;
         const methodNames = allMethodNames(members);
-        // Support method references like "<init>" and simple names
-        const methodRef = inj.method.replace(/<init>/g, "<init>");
-        if (!methodNames.includes(methodRef)) {
-            const suggestions = suggestSimilar(methodRef, methodNames);
+        // Strip owner prefix and JVM descriptor from the method reference
+        const methodName = extractMethodName(inj.method);
+        if (!methodNames.includes(methodName)) {
+            const suggestions = suggestSimilar(methodName, methodNames);
+            const descriptor = extractMethodDescriptor(inj.method);
+            const descriptorHint = descriptor ? ` (descriptor: ${descriptor})` : "";
+            // Determine if this is a remap artifact or signature unavailability
+            const isRemapFailed = remapFailedMembers?.get(targetName)?.has(methodName);
+            const isSigFailed = signatureFailedTargets?.has(targetName);
+            const issueConfidence = isRemapFailed ? "uncertain" : confidence;
+            const issueConfidenceReason = isRemapFailed
+                ? `Member remap from official→mapping failed; name mismatch may be a remap artifact, not a true missing member.`
+                : confidenceReason;
+            const resolutionPath = isRemapFailed
+                ? "member-remap-failed"
+                : isSigFailed ? "source-signature-unavailable" : undefined;
+            const memberDegraded = isRemapFailed && healthReport?.memberRemapAvailable === false;
             issues.push({
-                severity: "error",
+                severity: memberDegraded ? "warning" : "error",
                 kind: "method-not-found",
                 annotation: `@${inj.annotation}`,
                 target: `${targetName}#${inj.method}`,
-                message: `Method "${inj.method}" not found in target class "${targetName}".`,
+                message: `Method "${methodName}" not found in target class "${targetName}".${descriptorHint}${memberDegraded ? " (infrastructure degraded; may be false positive)" : ""}`,
                 suggestions: suggestions.length > 0 ? suggestions : undefined,
-                line: inj.line
+                line: inj.line,
+                confidence: issueConfidence,
+                confidenceReason: issueConfidenceReason,
+                resolutionPath,
+                falsePositiveRisk: computeFalsePositiveRisk(healthReport, resolutionPath, issueConfidence)
+            });
+            resolvedMembers.push({
+                annotation: `@${inj.annotation}`,
+                name: methodName,
+                line: inj.line,
+                status: "not-found"
+            });
+        }
+        else {
+            resolvedMembers.push({
+                annotation: `@${inj.annotation}`,
+                name: methodName,
+                line: inj.line,
+                resolvedTo: `${targetName}#${methodName}`,
+                status: "resolved"
             });
         }
     }
 }
-function validateShadow(shadow, targetMembers, targetNames, issues) {
+function validateShadow(shadow, targetMembers, targetNames, issues, resolvedMembers, confidence, confidenceReason, remapFailedMembers, signatureFailedTargets, healthReport) {
     for (const targetName of targetNames) {
         const members = targetMembers.get(targetName);
         if (!members)
             continue;
+        const isRemapFailed = remapFailedMembers?.get(targetName)?.has(shadow.name);
+        const isSigFailed = signatureFailedTargets?.has(targetName);
+        const issueConfidence = isRemapFailed ? "uncertain" : confidence;
+        const issueConfidenceReason = isRemapFailed
+            ? `Member remap from official→mapping failed; name mismatch may be a remap artifact, not a true missing member.`
+            : confidenceReason;
+        const resolutionPath = isRemapFailed
+            ? "member-remap-failed"
+            : isSigFailed ? "source-signature-unavailable" : undefined;
+        const memberDegraded = isRemapFailed && healthReport?.memberRemapAvailable === false;
         if (shadow.kind === "field") {
             const fieldNames = allFieldNames(members);
             if (!fieldNames.includes(shadow.name)) {
                 const suggestions = suggestSimilar(shadow.name, fieldNames);
                 issues.push({
-                    severity: "error",
+                    severity: memberDegraded ? "warning" : "error",
                     kind: "field-not-found",
                     annotation: "@Shadow",
                     target: `${targetName}#${shadow.name}`,
-                    message: `Field "${shadow.name}" not found in target class "${targetName}".`,
+                    message: `Field "${shadow.name}" not found in target class "${targetName}" (${fieldNames.length} field(s) available).${memberDegraded ? " (infrastructure degraded; may be false positive)" : ""}`,
                     suggestions: suggestions.length > 0 ? suggestions : undefined,
-                    line: shadow.line
+                    line: shadow.line,
+                    confidence: issueConfidence,
+                    confidenceReason: issueConfidenceReason,
+                    resolutionPath,
+                    falsePositiveRisk: computeFalsePositiveRisk(healthReport, resolutionPath, issueConfidence)
                 });
+                resolvedMembers.push({ annotation: "@Shadow", name: shadow.name, line: shadow.line, status: "not-found" });
+            }
+            else {
+                resolvedMembers.push({ annotation: "@Shadow", name: shadow.name, line: shadow.line, resolvedTo: `${targetName}#${shadow.name}`, status: "resolved" });
             }
         }
         else {
@@ -105,83 +241,370 @@ function validateShadow(shadow, targetMembers, targetNames, issues) {
             if (!methodNames.includes(shadow.name)) {
                 const suggestions = suggestSimilar(shadow.name, methodNames);
                 issues.push({
-                    severity: "error",
+                    severity: memberDegraded ? "warning" : "error",
                     kind: "method-not-found",
                     annotation: "@Shadow",
                     target: `${targetName}#${shadow.name}`,
-                    message: `Method "${shadow.name}" not found in target class "${targetName}".`,
+                    message: `Method "${shadow.name}" not found in target class "${targetName}" (${methodNames.length} method(s) available).${memberDegraded ? " (infrastructure degraded; may be false positive)" : ""}`,
                     suggestions: suggestions.length > 0 ? suggestions : undefined,
-                    line: shadow.line
+                    line: shadow.line,
+                    confidence: issueConfidence,
+                    confidenceReason: issueConfidenceReason,
+                    resolutionPath,
+                    falsePositiveRisk: computeFalsePositiveRisk(healthReport, resolutionPath, issueConfidence)
                 });
+                resolvedMembers.push({ annotation: "@Shadow", name: shadow.name, line: shadow.line, status: "not-found" });
+            }
+            else {
+                resolvedMembers.push({ annotation: "@Shadow", name: shadow.name, line: shadow.line, resolvedTo: `${targetName}#${shadow.name}`, status: "resolved" });
             }
         }
     }
 }
-function validateAccessor(accessor, targetMembers, targetNames, issues) {
+function validateAccessor(accessor, targetMembers, targetNames, issues, resolvedMembers, confidence, confidenceReason, remapFailedMembers, signatureFailedTargets, healthReport) {
     for (const targetName of targetNames) {
         const members = targetMembers.get(targetName);
         if (!members)
             continue;
-        const allNames = allMemberNames(members);
-        if (!allNames.includes(accessor.targetName)) {
-            const suggestions = suggestSimilar(accessor.targetName, allNames);
+        const candidateNames = accessor.annotation === "Invoker"
+            ? allMethodNames(members)
+            : allFieldNames(members);
+        if (!candidateNames.includes(accessor.targetName)) {
+            const isRemapFailed = remapFailedMembers?.get(targetName)?.has(accessor.targetName);
+            const isSigFailed = signatureFailedTargets?.has(targetName);
+            const issueConfidence = isRemapFailed ? "uncertain" : confidence;
+            const issueConfidenceReason = isRemapFailed
+                ? `Member remap from official→mapping failed; name mismatch may be a remap artifact, not a true missing member.`
+                : confidenceReason;
+            const resolutionPath = isRemapFailed
+                ? "member-remap-failed"
+                : isSigFailed ? "source-signature-unavailable" : undefined;
+            const memberDegraded = isRemapFailed && healthReport?.memberRemapAvailable === false;
+            const suggestions = suggestSimilar(accessor.targetName, candidateNames);
+            const inferenceHint = accessor.targetName !== accessor.name
+                ? ` (inferred "${accessor.targetName}" from "${accessor.name}" via prefix removal)`
+                : "";
             issues.push({
-                severity: "error",
+                severity: memberDegraded ? "warning" : "error",
                 kind: accessor.annotation === "Invoker" ? "method-not-found" : "field-not-found",
                 annotation: `@${accessor.annotation}`,
                 target: `${targetName}#${accessor.targetName}`,
-                message: `Target "${accessor.targetName}" (inferred from "${accessor.name}") not found in class "${targetName}".`,
+                message: `Target "${accessor.targetName}" not found in class "${targetName}".${inferenceHint}${memberDegraded ? " (infrastructure degraded; may be false positive)" : ""}`,
                 suggestions: suggestions.length > 0 ? suggestions : undefined,
-                line: accessor.line
+                line: accessor.line,
+                confidence: issueConfidence,
+                confidenceReason: issueConfidenceReason,
+                resolutionPath,
+                falsePositiveRisk: computeFalsePositiveRisk(healthReport, resolutionPath, issueConfidence)
             });
+            resolvedMembers.push({ annotation: `@${accessor.annotation}`, name: accessor.targetName, line: accessor.line, status: "not-found" });
+        }
+        else {
+            resolvedMembers.push({ annotation: `@${accessor.annotation}`, name: accessor.targetName, line: accessor.line, resolvedTo: `${targetName}#${accessor.targetName}`, status: "resolved" });
         }
     }
 }
-export function validateParsedMixin(parsed, targetMembers, warnings) {
+export function validateParsedMixin(parsed, targetMembers, warnings, provenance, confidence, mappingFailedTargets, explain, remapFailedMembers, signatureFailedTargets, suggestedCallContext, warningMode, healthReport, symbolExistsButSignatureFailed) {
     const issues = [];
     const targetNames = parsed.targets.map((t) => t.className);
+    const confidenceReason = confidence === "uncertain"
+        ? `Mapping fallback: requested "${provenance?.requestedMapping}" but applied "${provenance?.mappingApplied}".`
+        : confidence === "likely"
+            ? "Some members could not be remapped."
+            : undefined;
+    const resolvedMembers = [];
     // Check target classes exist
     for (const target of parsed.targets) {
         if (!targetMembers.has(target.className)) {
-            issues.push({
-                severity: "error",
-                kind: "target-not-found",
-                annotation: "@Mixin",
-                target: target.className,
-                message: `Target class "${target.className}" not found in game jar.`
-            });
+            if (mappingFailedTargets?.has(target.className)) {
+                // Mapping failure — report as warning with distinct kind
+                issues.push({
+                    severity: "warning",
+                    kind: "target-mapping-failed",
+                    annotation: "@Mixin",
+                    target: target.className,
+                    message: `Could not map target class "${target.className}" to official namespace; class may still exist under a different mapping.`,
+                    confidence: "uncertain",
+                    confidenceReason: `Mapping from "${provenance?.requestedMapping}" to official failed for this class.`,
+                    category: "mapping",
+                    resolutionPath: "target-mapping-failed",
+                    falsePositiveRisk: healthReport?.overallHealthy === false ? "high" : "medium"
+                });
+            }
+            else if (symbolExistsButSignatureFailed?.has(target.className)) {
+                // Symbol exists in mapping graph but getSignature failed — tool limitation, not code issue
+                issues.push({
+                    severity: "warning",
+                    kind: "target-not-found",
+                    annotation: "@Mixin",
+                    target: target.className,
+                    message: `Target class "${target.className}" exists in mapping data but could not be loaded from game jar (tool limitation). Members not validated.`,
+                    confidence: "uncertain",
+                    confidenceReason: "Class exists in mapping graph but bytecode signature extraction failed.",
+                    category: "resolution",
+                    resolutionPath: "source-signature-unavailable",
+                    issueOrigin: "tool_issue",
+                    falsePositiveRisk: "high"
+                });
+                // Skip member validation for this target — add skipped entries for each declared member
+                for (const inj of parsed.injections) {
+                    const methodName = extractMethodName(inj.method);
+                    resolvedMembers.push({
+                        annotation: `@${inj.annotation}`,
+                        name: methodName,
+                        line: inj.line,
+                        status: "skipped"
+                    });
+                }
+                for (const shadow of parsed.shadows) {
+                    resolvedMembers.push({
+                        annotation: "@Shadow",
+                        name: shadow.name,
+                        line: shadow.line,
+                        status: "skipped"
+                    });
+                }
+                for (const accessor of parsed.accessors) {
+                    resolvedMembers.push({
+                        annotation: `@${accessor.annotation}`,
+                        name: accessor.targetName,
+                        line: accessor.line,
+                        status: "skipped"
+                    });
+                }
+            }
+            else if (signatureFailedTargets?.has(target.className)) {
+                const degraded = healthReport?.overallHealthy === false;
+                issues.push({
+                    severity: degraded ? "warning" : "error",
+                    kind: "target-not-found",
+                    annotation: "@Mixin",
+                    target: target.className,
+                    message: `Target class "${target.className}" not found in game jar.${degraded ? " (infrastructure degraded; may be false positive)" : ""}`,
+                    confidence: degraded ? "uncertain" : confidence,
+                    confidenceReason: degraded
+                        ? "Mapping infrastructure is degraded; result may be inaccurate."
+                        : confidenceReason,
+                    category: "resolution",
+                    resolutionPath: "source-signature-unavailable",
+                    falsePositiveRisk: degraded ? "high" : undefined
+                });
+            }
+            else {
+                issues.push({
+                    severity: "error",
+                    kind: "target-not-found",
+                    annotation: "@Mixin",
+                    target: target.className,
+                    message: `Target class "${target.className}" not found in game jar.`,
+                    confidence,
+                    confidenceReason,
+                    category: "validation",
+                    resolutionPath: "target-class-missing"
+                });
+            }
         }
     }
     // Only validate members against targets that were resolved
     const resolvedTargetNames = targetNames.filter((t) => targetMembers.has(t));
     for (const inj of parsed.injections) {
-        validateInjection(inj, targetMembers, resolvedTargetNames, issues);
+        validateInjection(inj, targetMembers, resolvedTargetNames, issues, resolvedMembers, confidence, confidenceReason, remapFailedMembers, signatureFailedTargets, healthReport);
     }
     for (const shadow of parsed.shadows) {
-        validateShadow(shadow, targetMembers, resolvedTargetNames, issues);
+        validateShadow(shadow, targetMembers, resolvedTargetNames, issues, resolvedMembers, confidence, confidenceReason, remapFailedMembers, signatureFailedTargets, healthReport);
     }
     for (const accessor of parsed.accessors) {
-        validateAccessor(accessor, targetMembers, resolvedTargetNames, issues);
+        validateAccessor(accessor, targetMembers, resolvedTargetNames, issues, resolvedMembers, confidence, confidenceReason, remapFailedMembers, signatureFailedTargets, healthReport);
+    }
+    // Add parse warnings — escalate @Accessor/@Invoker/@Shadow parse failures to issues
+    for (const pw of parsed.parseWarnings) {
+        if (/@(Accessor|Invoker|Shadow)\b/.test(pw)) {
+            const annotation = pw.includes("@Accessor") ? "@Accessor"
+                : pw.includes("@Invoker") ? "@Invoker" : "@Shadow";
+            issues.push({
+                severity: "warning",
+                kind: "unknown-annotation",
+                annotation,
+                target: parsed.className,
+                message: pw,
+                confidence: "uncertain",
+                confidenceReason: "Parser could not extract member declaration; the annotation may be valid.",
+                category: "parse",
+                issueOrigin: "parser_limitation",
+                falsePositiveRisk: "high"
+            });
+        }
+        else {
+            warnings.push(pw);
+        }
+    }
+    // Contradiction detection: if some same-annotation members resolved OK but parse failed for others, note it
+    const resolvedAnnotations = new Set(resolvedMembers.filter((m) => m.status === "resolved").map((m) => m.annotation));
+    for (const issue of issues) {
+        if (issue.category === "parse" && resolvedAnnotations.has(issue.annotation)) {
+            issue.message += " (Note: other members with the same annotation resolved successfully.)";
+        }
     }
-    // Add parse warnings
-    warnings.push(...parsed.parseWarnings);
     const errorCount = issues.filter((i) => i.severity === "error").length;
     const warningCount = issues.filter((i) => i.severity === "warning").length;
+    const definiteErrors = issues.filter((i) => i.severity === "error" && i.confidence !== "uncertain").length;
+    const uncertainErrors = issues.filter((i) => i.severity === "error" && i.confidence === "uncertain").length;
+    const resolutionErrors = issues.filter((i) => i.resolutionPath != null).length;
+    const parseWarningCount = issues.filter((i) => i.category === "parse").length;
+    // Assign category and issueOrigin to issues that don't have them yet
+    for (const issue of issues) {
+        if (!issue.category) {
+            issue.category = issue.resolutionPath ? "resolution" : "validation";
+        }
+        if (!issue.issueOrigin) {
+            if (issue.category === "parse") {
+                issue.issueOrigin = "parser_limitation";
+            }
+            else {
+                const toolPaths = ["target-mapping-failed", "member-remap-failed", "source-signature-unavailable"];
+                issue.issueOrigin = issue.resolutionPath && toolPaths.includes(issue.resolutionPath)
+                    ? "tool_issue"
+                    : "code_issue";
+            }
+        }
+    }
+    // Enrich issues with explanations and suggested calls when explain=true
+    if (explain) {
+        const version = provenance?.version;
+        const mapping = provenance?.requestedMapping;
+        // Build context fields to spread into suggestedCall params
+        const ctx = {};
+        if (suggestedCallContext?.scope)
+            ctx.scope = suggestedCallContext.scope;
+        if (suggestedCallContext?.sourcePriority)
+            ctx.sourcePriority = suggestedCallContext.sourcePriority;
+        if (suggestedCallContext?.projectPath)
+            ctx.projectPath = suggestedCallContext.projectPath;
+        if (suggestedCallContext?.mapping)
+            ctx.mapping = suggestedCallContext.mapping;
+        for (const issue of issues) {
+            switch (issue.kind) {
+                case "target-not-found":
+                    issue.explanation = `The class "${issue.target}" was not found in the game jar. It may be misspelled, from a different version, or use a different mapping namespace.`;
+                    if (version && mapping) {
+                        issue.suggestedCall = {
+                            tool: "check-symbol-exists",
+                            params: { kind: "class", name: issue.target, version, sourceMapping: mapping, nameMode: "auto", ...ctx }
+                        };
+                    }
+                    break;
+                case "target-mapping-failed":
+                    issue.explanation = `Mapping lookup failed for "${issue.target}". The class may exist under a different name in the target namespace.`;
+                    if (version && mapping) {
+                        issue.suggestedCall = {
+                            tool: "check-symbol-exists",
+                            params: { kind: "class", name: issue.target, version, sourceMapping: mapping, nameMode: "auto", ...ctx }
+                        };
+                    }
+                    break;
+                case "method-not-found": {
+                    const parts = issue.target.split("#");
+                    const className = parts[0] ?? issue.target;
+                    issue.explanation = `The method was not found in the target class. It may be named differently in the current mapping, or might not exist in this version.`;
+                    if (version) {
+                        issue.suggestedCall = {
+                            tool: "get-class-source",
+                            params: { className, targetKind: "version", targetValue: version, ...(mapping ? { mapping } : {}), mode: "metadata", ...ctx }
+                        };
+                    }
+                    break;
+                }
+                case "field-not-found": {
+                    const parts = issue.target.split("#");
+                    const ownerName = parts[0] ?? issue.target;
+                    const fieldName = parts[1] ?? issue.target;
+                    issue.explanation = `The field "${fieldName}" was not found in the target class. Verify the field name matches the expected mapping namespace.`;
+                    if (version && mapping) {
+                        issue.suggestedCall = {
+                            tool: "check-symbol-exists",
+                            params: { kind: "field", owner: ownerName, name: fieldName, version, sourceMapping: mapping, ...ctx }
+                        };
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    // Build structuredWarnings — classify by severity and category
+    const MAPPING_WARNING_RE = /(?:mapping|remap|fallback|could not map)/i;
+    const CONFIG_WARNING_RE = /(?:version|gradle|jar\b|properties|project)/i;
+    const PARSE_WARNING_RE = /(?:could not parse|parse\s+warning|missing method attribute)/i;
+    const structuredWarnings = warnings.map((msg) => ({
+        severity: MAPPING_WARNING_RE.test(msg) ? "warning" : PARSE_WARNING_RE.test(msg) ? "warning" : "info",
+        message: msg,
+        category: MAPPING_WARNING_RE.test(msg) ? "mapping"
+            : PARSE_WARNING_RE.test(msg) ? "parse"
+                : CONFIG_WARNING_RE.test(msg) ? "configuration"
+                    : "validation"
+    }));
+    // Warning aggregation mode
+    let aggregatedWarnings;
+    let outputWarnings = warnings;
+    let outputStructuredWarnings = structuredWarnings.length > 0 ? structuredWarnings : undefined;
+    if (warningMode === "aggregated" && structuredWarnings.length > 0) {
+        const groupMap = new Map();
+        for (const sw of structuredWarnings) {
+            const cat = sw.category ?? "validation";
+            const existing = groupMap.get(cat);
+            if (existing) {
+                existing.count++;
+                if (existing.samples.length < 2) {
+                    existing.samples.push(sw.message);
+                }
+            }
+            else {
+                groupMap.set(cat, { count: 1, samples: [sw.message] });
+            }
+        }
+        aggregatedWarnings = [...groupMap.entries()].map(([category, { count, samples }]) => ({
+            category,
+            count,
+            samples
+        }));
+        outputWarnings = [];
+        outputStructuredWarnings = undefined;
+    }
+    // Compute confidence score
+    const remapFailureCount = provenance?.remapFailures ?? 0;
+    const confidenceScore = healthReport
+        ? computeConfidenceScore(healthReport, provenance, remapFailureCount)
+        : undefined;
+    // Build quick summary
+    const total = parsed.injections.length + parsed.shadows.length + parsed.accessors.length;
+    const quickSummary = issues.length === 0
+        ? `${total} member(s) validated successfully.`
+        : `${definiteErrors} error(s), ${uncertainErrors} uncertain, ${warningCount} warning(s).`;
     return {
         className: parsed.className,
         targets: targetNames,
         priority: parsed.priority,
-        valid: errorCount === 0,
+        valid: definiteErrors === 0,
         issues,
         summary: {
             injections: parsed.injections.length,
             shadows: parsed.shadows.length,
             accessors: parsed.accessors.length,
-            total: parsed.injections.length + parsed.shadows.length + parsed.accessors.length,
+            total,
             errors: errorCount,
-            warnings: warningCount
+            warnings: warningCount,
+            definiteErrors,
+            uncertainErrors,
+            resolutionErrors,
+            parseWarnings: parseWarningCount
         },
-        warnings
+        provenance,
+        warnings: outputWarnings,
+        structuredWarnings: outputStructuredWarnings,
+        aggregatedWarnings,
+        resolvedMembers: resolvedMembers.length > 0 ? resolvedMembers : undefined,
+        toolHealth: healthReport,
+        confidenceScore,
+        quickSummary
     };
 }
 /* ------------------------------------------------------------------ */

package/dist/mod-analyzer.d.ts

@@ -1,4 +1,5 @@
 export type ModLoader = "fabric" | "quilt" | "forge" | "neoforge" | "unknown";
+export type ModJarKind = "binary" | "source" | "mixed";
 export interface ModDependency {
     modId: string;
     versionRange?: string;
@@ -6,6 +7,7 @@ export interface ModDependency {
 }
 export interface ModAnalysisResult {
     loader: ModLoader;
+    jarKind: ModJarKind;
     modId?: string;
     modName?: string;
     modVersion?: string;

package/dist/mod-analyzer.js

@@ -277,8 +277,14 @@ export async function analyzeModJar(jarPath, options) {
     }
     // Class counting
     const classEntries = entries.filter((e) => e.endsWith(".class"));
+    const javaEntries = entries.filter((e) => e.endsWith(".java"));
     const classCount = classEntries.length;
     const classes = options?.includeClasses ? classEntries : undefined;
+    const jarKind = classEntries.length > 0 && javaEntries.length > 0
+        ? "mixed"
+        : javaEntries.length > 0
+            ? "source"
+            : "binary";
     // Detect loader and parse metadata
     let loader = "unknown";
     let metadata = {};
@@ -338,6 +344,7 @@ export async function analyzeModJar(jarPath, options) {
     }
     return {
         loader,
+        jarKind,
         ...metadata,
         classCount,
         ...(classes !== undefined ? { classes } : {})

package/dist/mod-decompile-service.d.ts

@@ -21,11 +21,17 @@ export type DecompileModJarOutput = {
 export type GetModClassSourceInput = {
     jarPath: string;
     className: string;
+    maxLines?: number;
+    maxChars?: number;
+    outputFile?: string;
 };
 export type GetModClassSourceOutput = {
     className: string;
     content: string;
     totalLines: number;
+    truncated?: boolean;
+    charsTruncated?: boolean;
+    outputFilePath?: string;
     modId?: string;
     warnings: string[];
 };