@adhisang/minecraft-modding-mcp 4.0.0 → 4.1.1

package/dist/source/descriptor-utils.d.ts

@@ -0,0 +1,6 @@
+export declare function remapJvmDescriptor(descriptor: string, classMap: Map<string, string>): string;
+export declare function rebuildJavaSignature(member: {
+    name: string;
+    ownerFqn: string;
+    accessFlags: number;
+}, remappedDescriptor: string, isField: boolean): string;

package/dist/source/descriptor-utils.js

@@ -0,0 +1,37 @@
+import { modifierPrefix, parseFieldType, parseMethodDescriptor } from "../minecraft-explorer-service.js";
+export function remapJvmDescriptor(descriptor, classMap) {
+    if (classMap.size === 0) {
+        return descriptor;
+    }
+    return descriptor.replace(/L([^;]+);/g, (match, ref) => {
+        const dotFqn = ref.replace(/\//g, ".");
+        const remapped = classMap.get(dotFqn);
+        return remapped ? `L${remapped.replace(/\./g, "/")};` : match;
+    });
+}
+export function rebuildJavaSignature(member, remappedDescriptor, isField) {
+    const modifiers = modifierPrefix(member.accessFlags, isField ? "field" : "method");
+    const prefix = modifiers ? `${modifiers} ` : "";
+    if (isField) {
+        try {
+            const { type } = parseFieldType(remappedDescriptor, 0, { allowVoid: false });
+            return `${prefix}${type} ${member.name}`.trim();
+        }
+        catch {
+            return `${prefix}${member.name}`.trim();
+        }
+    }
+    try {
+        const { args, returnType } = parseMethodDescriptor(remappedDescriptor);
+        const argStr = args.join(", ");
+        if (member.name === "<init>") {
+            const ownerSimple = member.ownerFqn.split(".").pop();
+            return `${prefix}${ownerSimple}(${argStr})`.trim();
+        }
+        return `${prefix}${returnType} ${member.name}(${argStr})`.trim();
+    }
+    catch {
+        return `${prefix}${member.name}`.trim();
+    }
+}
+//# sourceMappingURL=descriptor-utils.js.map

package/dist/source/file-access.d.ts

@@ -0,0 +1,4 @@
+import type { SourceService } from "../source-service.js";
+import type { GetArtifactFileInput, GetArtifactFileOutput, ListArtifactFilesInput, ListArtifactFilesOutput } from "../source-service.js";
+export declare function getArtifactFile(svc: SourceService, input: GetArtifactFileInput): Promise<GetArtifactFileOutput>;
+export declare function listArtifactFiles(svc: SourceService, input: ListArtifactFilesInput): Promise<ListArtifactFilesOutput>;

package/dist/source/file-access.js

@@ -0,0 +1,102 @@
+import { ERROR_CODES, createError } from "../errors.js";
+import { log } from "../logger.js";
+import { normalizeOptionalString, normalizePathStyle } from "./shared-utils.js";
+function clampLimit(limit, fallback, max) {
+    if (limit === undefined || limit === null) {
+        return fallback;
+    }
+    if (!Number.isFinite(limit) || limit <= 0) {
+        return fallback;
+    }
+    return Math.min(Math.floor(limit), max);
+}
+function truncateUtf8ToMaxBytes(content, maxBytes) {
+    if (Buffer.byteLength(content, "utf8") <= maxBytes) {
+        return content;
+    }
+    const buffer = Buffer.from(content, "utf8");
+    let cut = Math.min(maxBytes, buffer.length);
+    while (cut > 0 && (buffer[cut] & 0xc0) === 0x80) {
+        cut -= 1;
+    }
+    return buffer.slice(0, cut).toString("utf8");
+}
+export async function getArtifactFile(svc, input) {
+    const startedAt = Date.now();
+    try {
+        const artifact = svc.getArtifact(input.artifactId);
+        const row = svc.filesRepo.getFileContent(artifact.artifactId, normalizePathStyle(input.filePath));
+        if (!row) {
+            throw createError({
+                code: ERROR_CODES.FILE_NOT_FOUND,
+                message: `Source file "${input.filePath}" was not found.`,
+                details: { artifactId: input.artifactId, filePath: input.filePath }
+            });
+        }
+        const maxBytes = clampLimit(input.maxBytes, svc.config.maxContentBytes, Number.MAX_SAFE_INTEGER);
+        const fullBytes = Buffer.byteLength(row.content, "utf8");
+        const truncated = fullBytes > maxBytes;
+        const content = truncated ? truncateUtf8ToMaxBytes(row.content, maxBytes) : row.content;
+        if (truncated) {
+            log("warn", "source.get_file.truncated", {
+                artifactId: input.artifactId,
+                filePath: input.filePath,
+                maxBytes,
+                returnedBytes: Buffer.byteLength(content, "utf8"),
+                fullBytes
+            });
+        }
+        return {
+            filePath: row.filePath,
+            content,
+            contentBytes: fullBytes,
+            truncated,
+            mappingApplied: artifact.mappingApplied ?? "obfuscated",
+            returnedNamespace: artifact.mappingApplied ?? "obfuscated",
+            artifactContents: svc.buildArtifactContentsSummary({
+                origin: artifact.origin,
+                sourceJarPath: artifact.sourceJarPath,
+                isDecompiled: artifact.isDecompiled,
+                qualityFlags: artifact.qualityFlags
+            })
+        };
+    }
+    finally {
+        svc.metrics.recordDuration("get_file_duration_ms", Date.now() - startedAt);
+    }
+}
+export async function listArtifactFiles(svc, input) {
+    const startedAt = Date.now();
+    try {
+        const artifact = svc.getArtifact(input.artifactId);
+        const limit = clampLimit(input.limit, 200, 2000);
+        const warnings = [];
+        const page = svc.filesRepo.listFiles(artifact.artifactId, {
+            limit,
+            cursor: input.cursor,
+            prefix: input.prefix
+        });
+        const normalizedPrefix = normalizeOptionalString(input.prefix);
+        if (normalizedPrefix &&
+            page.items.length === 0 &&
+            (normalizedPrefix.startsWith("assets/") || normalizedPrefix.startsWith("data/"))) {
+            warnings.push("Indexed artifacts currently include Java source only; non-Java resources are not indexed. Inspect the original jar on disk if you need assets or data files.");
+        }
+        return {
+            items: page.items,
+            nextCursor: page.nextCursor,
+            mappingApplied: artifact.mappingApplied ?? "obfuscated",
+            artifactContents: svc.buildArtifactContentsSummary({
+                origin: artifact.origin,
+                sourceJarPath: artifact.sourceJarPath,
+                isDecompiled: artifact.isDecompiled,
+                qualityFlags: artifact.qualityFlags
+            }),
+            warnings
+        };
+    }
+    finally {
+        svc.metrics.recordDuration("list_files_duration_ms", Date.now() - startedAt);
+    }
+}
+//# sourceMappingURL=file-access.js.map

package/dist/source/indexer.d.ts

@@ -0,0 +1,82 @@
+import type { SourceService } from "../source-service.js";
+import type { ArtifactIndexMetaRow } from "../storage/index-meta-repo.js";
+import type { ArtifactRow, ResolvedSourceArtifact } from "../types.js";
+export declare const INDEX_SCHEMA_VERSION = 1;
+export type IndexRebuildReason = "force" | "missing_meta" | "schema_mismatch" | "signature_mismatch" | "already_current";
+export interface IndexedFileRecord {
+    filePath: string;
+    content: string;
+    contentBytes: number;
+    contentHash: string;
+}
+export interface RebuiltArtifactData {
+    files: IndexedFileRecord[];
+    symbols: Array<{
+        filePath: string;
+        symbolKind: string;
+        symbolName: string;
+        qualifiedName: string | undefined;
+        line: number;
+    }>;
+    indexedAt: string;
+    indexDurationMs: number;
+    totalContentBytes: number;
+}
+export type IndexArtifactInput = {
+    artifactId: string;
+    force?: boolean;
+};
+export type IndexArtifactOutput = {
+    artifactId: string;
+    reindexed: boolean;
+    reason: IndexRebuildReason;
+    counts: {
+        files: number;
+        symbols: number;
+        ftsRows: number;
+    };
+    indexedAt: string;
+    durationMs: number;
+    mappingApplied: import("../types.js").SourceMapping;
+};
+export declare function indexArtifact(svc: SourceService, input: IndexArtifactInput): Promise<IndexArtifactOutput>;
+export declare function fallbackArtifactSignature(artifactId: string): string;
+export declare function resolveIndexRebuildReason(input: {
+    force: boolean;
+    expectedSignature: string;
+    hasFiles: boolean;
+    meta: ArtifactIndexMetaRow | undefined;
+}): IndexRebuildReason;
+export declare function toResolvedArtifact(svc: SourceService, artifact: ArtifactRow): ResolvedSourceArtifact;
+export declare function rebuildAndPersistArtifactIndex(svc: SourceService, resolved: ResolvedSourceArtifact, reason: Exclude<IndexRebuildReason, "already_current">): Promise<RebuiltArtifactData>;
+export declare function buildRebuiltArtifactData(svc: SourceService, resolved: ResolvedSourceArtifact): Promise<RebuiltArtifactData>;
+export declare function getArtifact(svc: SourceService, artifactId: string): ArtifactRow;
+export declare function ingestIfNeeded(svc: SourceService, resolved: ResolvedSourceArtifact): Promise<void>;
+/**
+ * If the resolved artifact's transformChain promised an "obf -> mojang"
+ * binary remap, run tiny-remapper now and return the remapped jar path.
+ * Otherwise return the original binaryJarPath unchanged.
+ *
+ * Cache safety: writes to a per-attempt temp file then atomic-renames into
+ * <cacheDir>/remapped/<artifactId>.jar. A per-target inflight Promise map
+ * collapses concurrent calls so two simultaneous resolveArtifact calls for
+ * the same artifactId share one tiny-remapper run instead of racing on the
+ * same output path.
+ */
+export declare function maybeRemapBinaryForMojang(svc: SourceService, resolved: ResolvedSourceArtifact): Promise<string>;
+export declare function recordRemappedJarBytesFromDisk(svc: SourceService, artifactId: string, path: string): Promise<void>;
+/**
+ * Best-effort structural check that `path` is a non-empty file beginning with
+ * the ZIP local-file-header magic (`50 4B 03 04`). Used to drop partial /
+ * corrupt remap-cache entries before they reach Vineflower. False positives
+ * are acceptable (Vineflower will surface a clearer error); false negatives
+ * are not (a corrupt cache hit must be evicted).
+ */
+export declare function isUsableJarFile(path: string): Promise<boolean>;
+export declare function runBinaryRemap(svc: SourceService, input: {
+    version: string;
+    inputJar: string;
+    remappedDir: string;
+    remappedJarPath: string;
+}): Promise<string>;
+export declare function loadFromSourceJar(svc: SourceService, sourceJarPath: string): Promise<IndexedFileRecord[]>;