@adhisang/minecraft-modding-mcp 1.2.0 → 2.0.0

package/dist/source-resolver.js

@@ -1,5 +1,6 @@
 import { readdirSync } from "node:fs";
 import { basename, dirname, join, resolve as resolvePath } from "node:path";
+import { homedir } from "node:os";
 import { createError, ERROR_CODES } from "./errors.js";
 import { buildRemoteBinaryUrls, buildRemoteSourceUrls, hasExistingJar, parseCoordinate, normalizedCoordinateValue } from "./maven-resolver.js";
 import { defaultDownloadPath, downloadToCache } from "./repo-downloader.js";
@@ -23,6 +24,16 @@ function resolveExactJarSourceCandidate(inputJarPath) {
     const base = jarName.endsWith(".jar") ? jarName.slice(0, -4) : jarName;
     return join(directory, `${base}-sources.jar`);
 }
+function resolveSiblingBinaryJarCandidate(inputJarPath) {
+    const directory = dirname(inputJarPath);
+    const jarName = basename(inputJarPath);
+    if (!jarName.endsWith("-sources.jar")) {
+        return undefined;
+    }
+    const binaryName = `${jarName.slice(0, -"-sources.jar".length)}.jar`;
+    const candidate = join(directory, binaryName);
+    return hasExistingJar(candidate) ? candidate : undefined;
+}
 function listAdjacentJarSourceCandidates(inputJarPath) {
     const directory = dirname(inputJarPath);
     const exact = resolveExactJarSourceCandidate(inputJarPath);
@@ -59,6 +70,68 @@ function resolveLocalCoordinateCandidates(localM2Path, coordinate) {
     }
     return [...existing];
 }
+function resolveLocalCoordinateBinaryCandidate(localM2Path, coordinate) {
+    const parsed = parseCoordinate(coordinate);
+    const groupPath = parsed.groupId.replace(/\./g, "/");
+    const baseDir = resolvePath(localM2Path, groupPath, parsed.artifactId, parsed.version);
+    const base = `${parsed.artifactId}-${parsed.version}`;
+    const classifierSuffix = parsed.classifier ? `-${parsed.classifier}` : "";
+    const candidates = [
+        resolvePath(baseDir, `${base}${classifierSuffix}.jar`),
+        ...(classifierSuffix ? [resolvePath(baseDir, `${base}.jar`)] : [])
+    ];
+    return candidates.find((candidate) => hasExistingJar(candidate));
+}
+function resolveGradleUserHome() {
+    const configured = process.env.GRADLE_USER_HOME?.trim();
+    if (configured) {
+        return configured;
+    }
+    return resolvePath(homedir(), ".gradle");
+}
+function resolveGradleCacheCoordinateCandidate(coordinate) {
+    const parsed = parseCoordinate(coordinate);
+    const baseDir = resolvePath(resolveGradleUserHome(), "caches", "modules-2", "files-2.1", parsed.groupId, parsed.artifactId, parsed.version);
+    const base = `${parsed.artifactId}-${parsed.version}`;
+    const classifierSuffix = parsed.classifier ? `-${parsed.classifier}` : "";
+    const preferredSourceNames = [
+        `${base}${classifierSuffix}-sources.jar`,
+        ...(classifierSuffix ? [`${base}-sources.jar`] : [])
+    ];
+    const preferredBinaryNames = [
+        `${base}${classifierSuffix}.jar`,
+        ...(classifierSuffix ? [`${base}.jar`] : [])
+    ];
+    let discoveredFiles = [];
+    try {
+        const hashes = readdirSync(baseDir);
+        for (const hashDir of hashes) {
+            const fullDir = join(baseDir, hashDir);
+            for (const entry of readdirSync(fullDir)) {
+                discoveredFiles.push(join(fullDir, entry));
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    discoveredFiles = discoveredFiles.filter((entry) => hasExistingJar(entry)).sort((left, right) => left.localeCompare(right));
+    const pickFirst = (candidates) => {
+        for (const fileName of candidates) {
+            const match = discoveredFiles.find((entry) => basename(entry) === fileName);
+            if (match) {
+                return match;
+            }
+        }
+        return undefined;
+    };
+    const sourceJarPath = pickFirst(preferredSourceNames);
+    const binaryJarPath = pickFirst(preferredBinaryNames);
+    if (!sourceJarPath && !binaryJarPath) {
+        return undefined;
+    }
+    return { sourceJarPath, binaryJarPath };
+}
 function resolveRemoteBinaryCandidate(coordinate, repos) {
     return buildRemoteBinaryUrls(repos, coordinate);
 }
@@ -80,19 +153,23 @@ export async function resolveSourceTarget(input, options, explicitConfig) {
         const exactSourceJarPath = resolveExactJarSourceCandidate(resolvedJarPath);
         const adjacentSourceCandidates = listAdjacentJarSourceCandidates(resolvedJarPath);
         const maybeAdjacentSourceCandidates = adjacentSourceCandidates.length > 0 ? adjacentSourceCandidates : undefined;
+        const preferBinaryOnly = options.preferBinaryOnly ?? false;
         if (await hasJavaSources(resolvedJarPath)) {
+            const siblingBinaryJarPath = resolveSiblingBinaryJarCandidate(resolvedJarPath);
+            const binaryJarPath = siblingBinaryJarPath ??
+                (basename(resolvedJarPath).endsWith("-sources.jar") ? undefined : resolvedJarPath);
             return {
                 artifactId: artifactIdForJar("jar", resolvedJarPath, binarySignature),
                 artifactSignature: binarySignature,
                 origin: "local-jar",
-                binaryJarPath: resolvedJarPath,
+                binaryJarPath,
                 sourceJarPath: resolvedJarPath,
                 adjacentSourceCandidates: maybeAdjacentSourceCandidates,
                 isDecompiled: false,
                 resolvedAt: resolvedAtNow()
             };
         }
-        if (await hasJavaSources(exactSourceJarPath)) {
+        if (!preferBinaryOnly && await hasJavaSources(exactSourceJarPath)) {
             const sourceSignature = readStatsSignature(exactSourceJarPath);
             return {
                 artifactId: artifactIdForJar("jar", exactSourceJarPath, sourceSignature),
@@ -142,12 +219,27 @@ export async function resolveSourceTarget(input, options, explicitConfig) {
                 artifactSignature: signature,
                 origin: "local-m2",
                 sourceJarPath: candidate,
+                binaryJarPath: resolveLocalCoordinateBinaryCandidate(explicitConfig.localM2Path, coordinate),
                 coordinate,
                 isDecompiled: false,
                 resolvedAt: resolvedAtNow()
             };
         }
     }
+    const gradleCacheCandidate = resolveGradleCacheCoordinateCandidate(coordinate);
+    if (gradleCacheCandidate?.sourceJarPath && (await hasJavaSources(gradleCacheCandidate.sourceJarPath))) {
+        const signature = readStatsSignature(gradleCacheCandidate.sourceJarPath);
+        return {
+            artifactId: artifactIdForCoordinate(coordinate, "local-m2", signature),
+            artifactSignature: signature,
+            origin: "local-m2",
+            sourceJarPath: gradleCacheCandidate.sourceJarPath,
+            binaryJarPath: gradleCacheCandidate.binaryJarPath,
+            coordinate,
+            isDecompiled: false,
+            resolvedAt: resolvedAtNow()
+        };
+    }
     const remoteSourceUrls = buildRemoteSourceUrls(repos, coordinate);
     for (let index = 0; index < remoteSourceUrls.length; index++) {
         const sourceUrl = remoteSourceUrls[index];

package/dist/source-service.d.ts

@@ -44,11 +44,6 @@ export type SearchScope = {
     fileGlob?: string;
     symbolKind?: SymbolKind;
 };
-export type SearchInclude = {
-    snippetLines?: number;
-    includeDefinition?: boolean;
-    includeOneHop?: boolean;
-};
 export type SearchResultSymbol = {
     symbolKind: SymbolKind;
     symbolName: string;
@@ -59,27 +54,9 @@ export type SearchSourceHit = {
     filePath: string;
     score: number;
     matchedIn: "symbol" | "path" | "content";
-    startLine: number;
-    endLine: number;
-    snippet: string;
     reasonCodes: string[];
     symbol?: SearchResultSymbol;
 };
-export type SearchRelation = {
-    fromSymbol: {
-        symbolKind: SymbolKind;
-        symbolName: string;
-        filePath: string;
-        line: number;
-    };
-    toSymbol: {
-        symbolKind: SymbolKind;
-        symbolName: string;
-        filePath: string;
-        line: number;
-    };
-    relation: "calls" | "uses-type" | "imports";
-};
 export type QueryMode = "auto" | "token" | "literal";
 export type SearchClassSourceInput = {
     artifactId: string;
@@ -87,16 +64,13 @@ export type SearchClassSourceInput = {
     intent?: SearchIntent;
     match?: SearchMatch;
     scope?: SearchScope;
-    include?: SearchInclude;
     queryMode?: QueryMode;
     limit?: number;
     cursor?: string;
 };
 export type SearchClassSourceOutput = {
     hits: SearchSourceHit[];
-    relations?: SearchRelation[];
     nextCursor?: string;
-    totalApprox: number;
     mappingApplied: SourceMapping;
 };
 export type GetArtifactFileInput = {
@@ -356,11 +330,19 @@ export type IndexArtifactOutput = {
     mappingApplied: SourceMapping;
 };
 export type ValidateMixinInput = {
-    source?: string;
-    sourcePath?: string;
-    sourcePaths?: string[];
-    mixinConfigPath?: string | string[];
-    sourceRoot?: string;
+    input: {
+        mode: "inline";
+        source: string;
+    } | {
+        mode: "path";
+        path: string;
+    } | {
+        mode: "paths";
+        paths: string[];
+    } | {
+        mode: "config";
+        configPaths: string[];
+    };
     sourceRoots?: string[];
     version: string;
     mapping?: SourceMapping;
@@ -377,8 +359,14 @@ export type ValidateMixinInput = {
     warningCategoryFilter?: ("mapping" | "configuration" | "validation" | "resolution" | "parse")[];
     treatInfoAsWarning?: boolean;
 };
+export type ValidateMixinResultSource = {
+    kind: "inline" | "path" | "config";
+    label: string;
+    path?: string;
+    configPath?: string;
+};
 export type ValidateMixinBatchResult = {
-    sourcePath: string;
+    source: ValidateMixinResultSource;
     result?: MixinValidationResult;
     error?: string;
 };
@@ -389,23 +377,22 @@ export type ValidateMixinBatchIssueSummaryItem = {
     count: number;
     sampleTargets: string[];
 };
-export type ValidateMixinBatchOutput = {
+export type ValidateMixinOutput = {
+    mode: ValidateMixinInput["input"]["mode"];
     results: ValidateMixinBatchResult[];
     summary: {
         total: number;
         valid: number;
         invalid: number;
-        /** @deprecated Use processingErrors instead */
-        errors: number;
         processingErrors: number;
         totalValidationErrors: number;
         totalValidationWarnings: number;
-        confidenceScore?: number;
     };
     issueSummary?: ValidateMixinBatchIssueSummaryItem[];
     toolHealth?: MappingHealthReport;
+    confidenceScore?: number;
+    warnings: string[];
 };
-export type ValidateMixinOutput = MixinValidationResult | ValidateMixinBatchOutput;
 export type ValidateAccessWidenerInput = {
     content: string;
     version: string;
@@ -453,7 +440,11 @@ export declare class SourceService {
     getClassSource(input: GetClassSourceInput): Promise<GetClassSourceOutput>;
     getClassMembers(input: GetClassMembersInput): Promise<GetClassMembersOutput>;
     validateMixin(input: ValidateMixinInput): Promise<ValidateMixinOutput>;
-    private validateMixinBatch;
+    private validateMixinSingle;
+    private resolveMixinInputPath;
+    private resolveMixinConfigSources;
+    private validateMixinMany;
+    private buildValidateMixinOutput;
     validateAccessWidener(input: ValidateAccessWidenerInput): Promise<ValidateAccessWidenerOutput>;
     getRuntimeMetrics(): RuntimeMetricSnapshot;
     indexArtifact(input: IndexArtifactInput): Promise<IndexArtifactOutput>;
@@ -468,13 +459,13 @@ export declare class SourceService {
     private indexedCandidateLimitForMatch;
     private extractClassMetadata;
     private resolveClassFilePath;
-    private findNearestSymbolForLine;
-    private findNearestSymbolFromList;
-    private buildOneHopRelations;
+    private resolveBinaryFallbackArtifact;
     private buildProvenance;
     private buildFallbackProvenance;
-    private resolveToOfficialClassName;
-    private resolveToOfficialMemberName;
+    private resolveClassNameForLookup;
+    private buildClassSourceNotFoundError;
+    private resolveToObfuscatedClassName;
+    private resolveToObfuscatedMemberName;
     private remapSignatureMembers;
     private fallbackArtifactSignature;
     private resolveIndexRebuildReason;