@adhisang/minecraft-modding-mcp 1.1.0 → 1.2.0

package/dist/mod-decompile-service.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { readFileSync, writeFileSync } from "node:fs";
+import { isAbsolute, join, resolve as resolvePath } from "node:path";
 import { createError, ERROR_CODES } from "./errors.js";
 import { log } from "./logger.js";
 import { decompileBinaryJar } from "./decompiler/vineflower.js";
@@ -76,11 +76,42 @@ export class ModDecompileService {
                 details: { className, jarPath, availableCount: files.length }
             });
         }
-        const content = readFileSync(join(outputDir, matched), "utf8");
+        const fullContent = readFileSync(join(outputDir, matched), "utf8");
+        const totalLines = fullContent.split("\n").length;
+        let content = fullContent;
+        let truncated;
+        let charsTruncated;
+        let outputFilePath;
+        // Apply maxLines truncation
+        if (input.maxLines != null && input.maxLines > 0) {
+            const lines = content.split("\n");
+            if (lines.length > input.maxLines) {
+                content = lines.slice(0, input.maxLines).join("\n");
+                truncated = true;
+            }
+        }
+        // Apply maxChars truncation
+        if (input.maxChars != null && input.maxChars > 0 && content.length > input.maxChars) {
+            content = content.slice(0, input.maxChars);
+            charsTruncated = true;
+            truncated = true;
+        }
+        // Write to outputFile if specified (after maxLines/maxChars truncation, if any)
+        if (input.outputFile) {
+            const outPath = isAbsolute(input.outputFile)
+                ? input.outputFile
+                : resolvePath(input.outputFile);
+            writeFileSync(outPath, content, "utf8");
+            outputFilePath = outPath;
+            content = `[Written to ${outPath}]`;
+        }
         return {
             className: filePathToClassName(matched),
             content,
-            totalLines: content.split("\n").length,
+            totalLines,
+            truncated,
+            charsTruncated,
+            outputFilePath,
             modId: analysis.modId,
             warnings
         };
@@ -100,6 +131,7 @@ export class ModDecompileService {
         catch {
             analysis = {
                 loader: "unknown",
+                jarKind: "binary",
                 classCount: 0
             };
             warnings.push("Could not extract mod metadata from JAR.");

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

@@ -25,4 +25,5 @@ export declare class ModSearchService {
     private readonly modDecompileService;
     constructor(modDecompileService: ModDecompileService);
     searchModSource(input: SearchModSourceInput): Promise<SearchModSourceOutput>;
+    private searchSourceJarEntriesDirect;
 }

package/dist/mod-search-service.js

@@ -3,6 +3,8 @@ import { join } from "node:path";
 import { createError, ERROR_CODES } from "./errors.js";
 import { log } from "./logger.js";
 import { validateAndNormalizeJarPath } from "./path-resolver.js";
+import { analyzeModJar } from "./mod-analyzer.js";
+import { iterateJavaEntriesAsUtf8 } from "./source-jar-reader.js";
 const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 200;
 const MAX_QUERY_LENGTH = 200;
@@ -76,6 +78,33 @@ export class ModSearchService {
             warnings.push(`limit was clamped to ${MAX_LIMIT} from ${requestedLimit}.`);
         }
         const startedAt = Date.now();
+        const jarAnalysis = await analyzeModJar(jarPath);
+        if (jarAnalysis.jarKind === "source") {
+            warnings.push("Detected source jar; searching Java entries directly without decompilation.");
+            const directResult = await this.searchSourceJarEntriesDirect({
+                jarPath,
+                query,
+                searchType,
+                limit,
+                regex
+            });
+            warnings.push(...directResult.warnings);
+            log("info", "mod-search.done", {
+                jarPath,
+                query,
+                searchType,
+                hitCount: directResult.hits.length,
+                durationMs: Date.now() - startedAt
+            });
+            return {
+                query,
+                searchType,
+                hits: directResult.hits,
+                totalHits: directResult.totalHits,
+                truncated: directResult.truncated,
+                warnings
+            };
+        }
         const decompileResult = await this.modDecompileService.decompileModJar({ jarPath });
         const outputDir = decompileResult.outputDir;
         warnings.push(...decompileResult.warnings);
@@ -159,6 +188,73 @@ export class ModSearchService {
             warnings
         };
     }
+    async searchSourceJarEntriesDirect(input) {
+        const warnings = [];
+        const hits = [];
+        let totalHits = 0;
+        let reachedLimit = false;
+        for await (const entry of iterateJavaEntriesAsUtf8(input.jarPath)) {
+            if (hits.length >= input.limit) {
+                reachedLimit = true;
+                break;
+            }
+            const filePath = entry.filePath;
+            const className = filePathToClassName(filePath);
+            if (input.searchType === "class" || input.searchType === "all") {
+                const simpleClassName = className.split(".").pop() ?? className;
+                input.regex.lastIndex = 0;
+                if (input.regex.test(simpleClassName)) {
+                    totalHits += 1;
+                    if (hits.length < input.limit) {
+                        hits.push({
+                            type: "class",
+                            name: className,
+                            file: filePath
+                        });
+                    }
+                    if (input.searchType === "class") {
+                        continue;
+                    }
+                }
+            }
+            if (input.searchType === "method" ||
+                input.searchType === "field" ||
+                input.searchType === "content" ||
+                input.searchType === "all") {
+                const lines = entry.content.split("\n");
+                for (let i = 0; i < lines.length; i++) {
+                    if (hits.length >= input.limit) {
+                        reachedLimit = true;
+                        break;
+                    }
+                    input.regex.lastIndex = 0;
+                    if (!input.regex.test(lines[i])) {
+                        continue;
+                    }
+                    const lineType = classifyLine(lines[i]);
+                    if (input.searchType !== "all" && input.searchType !== lineType) {
+                        continue;
+                    }
+                    totalHits += 1;
+                    if (hits.length < input.limit) {
+                        hits.push({
+                            type: lineType,
+                            name: lineType === "content" ? className : extractSymbolName(lines[i], lineType),
+                            file: filePath,
+                            line: i + 1,
+                            context: extractContext(lines, i)
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            hits,
+            totalHits,
+            truncated: reachedLimit,
+            warnings
+        };
+    }
 }
 function extractSymbolName(line, type) {
     const trimmed = line.trim();

package/dist/search-hit-accumulator.d.ts

@@ -25,6 +25,7 @@ export interface SearchCursorPayload {
 export interface SearchHitAccumulator {
     add(hit: SearchSourceHit): void;
     setTotalApproxOverride(count: number): void;
+    currentCount(): number;
     finalize(): {
         page: SearchSourceHit[];
         nextCursorHit?: SearchSourceHit;

package/dist/search-hit-accumulator.js

@@ -137,6 +137,9 @@ export function createSearchHitAccumulator(limit, cursor) {
         setTotalApproxOverride(count) {
             totalApproxOverride = Math.max(0, Math.trunc(count));
         },
+        currentCount() {
+            return heap.length;
+        },
         finalize() {
             // Sort heap contents by scoreHitOrder (best first)
             const sorted = heap.slice().sort(scoreHitOrder);

package/dist/source-resolver.js

@@ -51,10 +51,6 @@ function resolveLocalCoordinateCandidates(localM2Path, coordinate) {
     const direct = resolvePath(baseDir, `${base}${classifierSuffix}-sources.jar`);
     const fallback = resolvePath(baseDir, `${base}-sources.jar`);
     const candidates = [direct, fallback];
-    if (parsed.classifier) {
-        const prefix = `${parsed.artifactId}-${parsed.version}-${parsed.classifier}`;
-        candidates.push(resolvePath(baseDir, `${base}-${prefix}-sources.jar`));
-    }
     const existing = new Set();
     for (const candidate of candidates) {
         if (hasExistingJar(candidate)) {

package/dist/source-service.d.ts

@@ -1,9 +1,9 @@
 import { type ResponseContext as ExplorerResponseContext, type SignatureMember } from "./minecraft-explorer-service.js";
-import { type MixinValidationResult, type AccessWidenerValidationResult } from "./mixin-validator.js";
+import { type MixinValidationResult, type MappingHealthReport, type AccessWidenerValidationResult } from "./mixin-validator.js";
 import { type ClassApiMatrixInput as MappingClassApiMatrixInput, type ClassApiMatrixOutput as MappingClassApiMatrixOutput, type FindMappingInput as MappingFindMappingInput, type FindMappingOutput as MappingFindMappingOutput, type ResolveMethodMappingExactInput as MappingResolveMethodMappingExactInput, type ResolveMethodMappingExactOutput as MappingResolveMethodMappingExactOutput, type SymbolResolutionOutput as MappingSymbolResolutionOutput, type SymbolExistenceInput as MappingSymbolExistenceInput, type SymbolExistenceOutput as MappingSymbolExistenceOutput } from "./mapping-service.js";
 import { RuntimeMetrics, type RuntimeMetricSnapshot } from "./observability.js";
 import { type WorkspaceCompileMappingOutput } from "./workspace-mapping-service.js";
-import type { ArtifactProvenance, ArtifactRow, Config, MappingSourcePriority, ResolvedSourceArtifact, SourceMapping, SourceTargetInput } from "./types.js";
+import type { ArtifactProvenance, ArtifactRow, ArtifactScope, Config, MappingSourcePriority, ResolvedSourceArtifact, SourceMapping, SourceTargetInput } from "./types.js";
 import { type ListVersionsInput, type ListVersionsOutput } from "./version-service.js";
 import { type GetRegistryDataInput, type GetRegistryDataOutput } from "./registry-service.js";
 import { type CompareVersionsInput, type CompareVersionsOutput } from "./version-diff-service.js";
@@ -14,6 +14,10 @@ export type ResolveArtifactInput = {
     mapping?: SourceMapping;
     sourcePriority?: MappingSourcePriority;
     allowDecompile?: boolean;
+    projectPath?: string;
+    scope?: ArtifactScope;
+    preferProjectVersion?: boolean;
+    strictVersion?: boolean;
 };
 export type ResolveArtifactOutput = {
     artifactId: string;
@@ -30,6 +34,7 @@ export type ResolveArtifactOutput = {
     qualityFlags: string[];
     repoUrl?: string;
     warnings: string[];
+    sampleEntries?: string[];
 };
 type SymbolKind = "class" | "interface" | "enum" | "record" | "method" | "field";
 type SearchIntent = "symbol" | "text" | "path";
@@ -75,6 +80,7 @@ export type SearchRelation = {
     };
     relation: "calls" | "uses-type" | "imports";
 };
+export type QueryMode = "auto" | "token" | "literal";
 export type SearchClassSourceInput = {
     artifactId: string;
     query: string;
@@ -82,6 +88,7 @@ export type SearchClassSourceInput = {
     match?: SearchMatch;
     scope?: SearchScope;
     include?: SearchInclude;
+    queryMode?: QueryMode;
     limit?: number;
     cursor?: string;
 };
@@ -137,19 +144,28 @@ export type ResolveWorkspaceSymbolInput = {
 export type ResolveWorkspaceSymbolOutput = MappingSymbolResolutionOutput & {
     workspaceDetection: WorkspaceCompileMappingOutput;
 };
+export type SourceMode = "metadata" | "snippet" | "full";
 export type GetClassSourceInput = {
     artifactId?: string;
     target?: SourceTargetInput;
     className: string;
+    mode?: SourceMode;
     mapping?: SourceMapping;
     sourcePriority?: MappingSourcePriority;
     allowDecompile?: boolean;
+    projectPath?: string;
+    scope?: ArtifactScope;
+    preferProjectVersion?: boolean;
+    strictVersion?: boolean;
     startLine?: number;
     endLine?: number;
     maxLines?: number;
+    maxChars?: number;
+    outputFile?: string;
 };
 export type GetClassSourceOutput = {
     className: string;
+    mode: SourceMode;
     sourceText: string;
     totalLines: number;
     returnedRange: {
@@ -157,12 +173,30 @@ export type GetClassSourceOutput = {
         end: number;
     };
     truncated: boolean;
+    charsTruncated?: boolean;
     origin: ResolvedSourceArtifact["origin"];
     artifactId: string;
     requestedMapping: SourceMapping;
     mappingApplied: SourceMapping;
     provenance: ArtifactProvenance;
     qualityFlags: string[];
+    outputFile?: string;
+    warnings: string[];
+};
+export type FindClassInput = {
+    className: string;
+    artifactId: string;
+    limit?: number;
+};
+export type FindClassMatch = {
+    qualifiedName: string;
+    filePath: string;
+    line: number;
+    symbolKind: string;
+};
+export type FindClassOutput = {
+    matches: FindClassMatch[];
+    total: number;
     warnings: string[];
 };
 type MemberAccess = "public" | "all";
@@ -178,6 +212,10 @@ export type GetClassMembersInput = {
     includeInherited?: boolean;
     memberPattern?: string;
     maxMembers?: number;
+    projectPath?: string;
+    scope?: ArtifactScope;
+    preferProjectVersion?: boolean;
+    strictVersion?: boolean;
 };
 export type GetClassMembersOutput = {
     className: string;
@@ -318,12 +356,56 @@ export type IndexArtifactOutput = {
     mappingApplied: SourceMapping;
 };
 export type ValidateMixinInput = {
-    source: string;
+    source?: string;
+    sourcePath?: string;
+    sourcePaths?: string[];
+    mixinConfigPath?: string | string[];
+    sourceRoot?: string;
+    sourceRoots?: string[];
     version: string;
     mapping?: SourceMapping;
     sourcePriority?: MappingSourcePriority;
+    scope?: ArtifactScope;
+    projectPath?: string;
+    preferProjectVersion?: boolean;
+    minSeverity?: "error" | "warning" | "all";
+    hideUncertain?: boolean;
+    explain?: boolean;
+    warningMode?: "full" | "aggregated";
+    preferProjectMapping?: boolean;
+    reportMode?: "compact" | "full";
+    warningCategoryFilter?: ("mapping" | "configuration" | "validation" | "resolution" | "parse")[];
+    treatInfoAsWarning?: boolean;
+};
+export type ValidateMixinBatchResult = {
+    sourcePath: string;
+    result?: MixinValidationResult;
+    error?: string;
+};
+export type ValidateMixinBatchIssueSummaryItem = {
+    kind: string;
+    confidence: string;
+    category: string;
+    count: number;
+    sampleTargets: string[];
+};
+export type ValidateMixinBatchOutput = {
+    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;
 };
-export type ValidateMixinOutput = MixinValidationResult;
+export type ValidateMixinOutput = MixinValidationResult | ValidateMixinBatchOutput;
 export type ValidateAccessWidenerInput = {
     content: string;
     version: string;
@@ -348,6 +430,8 @@ export declare class SourceService {
     private readonly modDecompileService;
     private readonly modSearchService;
     constructor(explicitConfig?: Config, metrics?: RuntimeMetrics);
+    private discoverVersionSourceJar;
+    private buildVersionSourceRecoveryCommand;
     resolveArtifact(input: ResolveArtifactInput): Promise<ResolveArtifactOutput>;
     searchClassSource(input: SearchClassSourceInput): Promise<SearchClassSourceOutput>;
     getArtifactFile(input: GetArtifactFileInput): Promise<GetArtifactFileOutput>;
@@ -365,9 +449,11 @@ export declare class SourceService {
     resolveWorkspaceSymbol(input: ResolveWorkspaceSymbolInput): Promise<ResolveWorkspaceSymbolOutput>;
     traceSymbolLifecycle(input: TraceSymbolLifecycleInput): Promise<TraceSymbolLifecycleOutput>;
     diffClassSignatures(input: DiffClassSignaturesInput): Promise<DiffClassSignaturesOutput>;
+    findClass(input: FindClassInput): FindClassOutput;
     getClassSource(input: GetClassSourceInput): Promise<GetClassSourceOutput>;
     getClassMembers(input: GetClassMembersInput): Promise<GetClassMembersOutput>;
     validateMixin(input: ValidateMixinInput): Promise<ValidateMixinOutput>;
+    private validateMixinBatch;
     validateAccessWidener(input: ValidateAccessWidenerInput): Promise<ValidateAccessWidenerOutput>;
     getRuntimeMetrics(): RuntimeMetricSnapshot;
     indexArtifact(input: IndexArtifactInput): Promise<IndexArtifactOutput>;
@@ -380,6 +466,7 @@ export declare class SourceService {
     private loadScopedFilePaths;
     private indexedCandidateLimit;
     private indexedCandidateLimitForMatch;
+    private extractClassMetadata;
     private resolveClassFilePath;
     private findNearestSymbolForLine;
     private findNearestSymbolFromList;