@adhisang/minecraft-modding-mcp 1.2.1 → 2.1.0

package/dist/json-rpc-framing.d.ts

@@ -0,0 +1,22 @@
+import { type JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+export type FramingMode = "unknown" | "line" | "content-length";
+export type ConcreteFramingMode = Exclude<FramingMode, "unknown">;
+export type ParsedJsonRpcFrame = {
+    message: JSONRPCMessage;
+    mode: ConcreteFramingMode;
+};
+export declare function encodeJsonRpcMessage(message: JSONRPCMessage, mode: ConcreteFramingMode): Buffer;
+export declare class JsonRpcFrameReader {
+    private mode;
+    private buffer;
+    get currentMode(): FramingMode;
+    reset(): void;
+    clear(): void;
+    processChunk(chunk: Buffer, handlers: {
+        onFrame: (frame: ParsedJsonRpcFrame) => void;
+        onError: (error: Error) => void;
+    }): void;
+    private detectMode;
+    private readLineDelimitedMessage;
+    private readContentLengthMessage;
+}

package/dist/json-rpc-framing.js

@@ -0,0 +1,168 @@
+import { JSONRPCMessageSchema } from "@modelcontextprotocol/sdk/types.js";
+function findHeaderBoundary(buffer) {
+    const crlfBoundary = buffer.indexOf("\r\n\r\n");
+    if (crlfBoundary !== -1) {
+        return { index: crlfBoundary, delimiterBytes: 4 };
+    }
+    const lfBoundary = buffer.indexOf("\n\n");
+    if (lfBoundary !== -1) {
+        return { index: lfBoundary, delimiterBytes: 2 };
+    }
+    return undefined;
+}
+function parseJsonRpcMessage(json) {
+    return JSONRPCMessageSchema.parse(JSON.parse(json));
+}
+function asError(value) {
+    return value instanceof Error ? value : new Error(String(value));
+}
+export function encodeJsonRpcMessage(message, mode) {
+    const json = JSON.stringify(message);
+    return Buffer.from(mode === "content-length"
+        ? `Content-Length: ${Buffer.byteLength(json, "utf8")}\r\n\r\n${json}`
+        : `${json}\n`, "utf8");
+}
+export class JsonRpcFrameReader {
+    mode = "unknown";
+    buffer = Buffer.alloc(0);
+    get currentMode() {
+        return this.mode;
+    }
+    reset() {
+        this.mode = "unknown";
+    }
+    clear() {
+        this.mode = "unknown";
+        this.buffer = Buffer.alloc(0);
+    }
+    processChunk(chunk, handlers) {
+        if (chunk.length === 0) {
+            return;
+        }
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        while (true) {
+            try {
+                if (this.mode === "unknown") {
+                    const detected = this.detectMode();
+                    if (!detected) {
+                        return;
+                    }
+                    this.mode = detected;
+                    continue;
+                }
+                const modeBefore = this.mode;
+                const message = this.mode === "content-length"
+                    ? this.readContentLengthMessage()
+                    : this.readLineDelimitedMessage();
+                if (!message) {
+                    if (this.mode !== modeBefore) {
+                        continue;
+                    }
+                    return;
+                }
+                handlers.onFrame({
+                    message,
+                    mode: this.mode
+                });
+            }
+            catch (caughtError) {
+                this.mode = "unknown";
+                handlers.onError(asError(caughtError));
+            }
+        }
+    }
+    detectMode() {
+        while (this.buffer.length > 0) {
+            if (this.buffer[0] === 0x0a) {
+                this.buffer = this.buffer.subarray(1);
+                continue;
+            }
+            if (this.buffer.length >= 2 && this.buffer[0] === 0x0d && this.buffer[1] === 0x0a) {
+                this.buffer = this.buffer.subarray(2);
+                continue;
+            }
+            break;
+        }
+        if (this.buffer.length === 0) {
+            return undefined;
+        }
+        const prefix = this.buffer
+            .subarray(0, Math.min(this.buffer.length, 32))
+            .toString("utf8")
+            .toLowerCase();
+        if (prefix.startsWith("content-length")) {
+            return "content-length";
+        }
+        const firstNewline = this.buffer.indexOf(0x0a);
+        if (firstNewline === -1) {
+            return undefined;
+        }
+        const firstLine = this.buffer.subarray(0, firstNewline).toString("utf8").replace(/\r$/, "");
+        if (/^\s*content-length\s*:/i.test(firstLine)) {
+            return "content-length";
+        }
+        return "line";
+    }
+    readLineDelimitedMessage() {
+        while (true) {
+            const newlineIndex = this.buffer.indexOf(0x0a);
+            if (newlineIndex === -1) {
+                return undefined;
+            }
+            const line = this.buffer.subarray(0, newlineIndex).toString("utf8").replace(/\r$/, "");
+            this.buffer = this.buffer.subarray(newlineIndex + 1);
+            if (line.trim().length === 0) {
+                continue;
+            }
+            if (/^\s*content-length\s*:/i.test(line)) {
+                const separator = this.buffer.length > 0 && this.buffer[0] === 0x0d ? "\r\n" : "\n";
+                this.buffer = Buffer.concat([Buffer.from(`${line}${separator}`, "utf8"), this.buffer]);
+                this.mode = "content-length";
+                return undefined;
+            }
+            return parseJsonRpcMessage(line);
+        }
+    }
+    readContentLengthMessage() {
+        const headerBoundary = findHeaderBoundary(this.buffer);
+        if (!headerBoundary) {
+            return undefined;
+        }
+        const headersRaw = this.buffer.subarray(0, headerBoundary.index).toString("utf8");
+        const headerLines = headersRaw
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+        let contentLength;
+        for (const headerLine of headerLines) {
+            const separatorIndex = headerLine.indexOf(":");
+            if (separatorIndex === -1) {
+                this.buffer = this.buffer.subarray(headerBoundary.index + headerBoundary.delimiterBytes);
+                throw new Error(`Malformed header line: ${headerLine}`);
+            }
+            const headerName = headerLine.slice(0, separatorIndex).trim().toLowerCase();
+            const headerValue = headerLine.slice(separatorIndex + 1).trim();
+            if (headerName === "content-length") {
+                const parsed = Number.parseInt(headerValue, 10);
+                if (!Number.isFinite(parsed) || parsed < 0) {
+                    this.buffer = this.buffer.subarray(headerBoundary.index + headerBoundary.delimiterBytes);
+                    throw new Error(`Invalid Content-Length header value: ${headerValue}`);
+                }
+                contentLength = parsed;
+            }
+        }
+        if (contentLength === undefined) {
+            this.buffer = this.buffer.subarray(headerBoundary.index + headerBoundary.delimiterBytes);
+            throw new Error("Missing Content-Length header.");
+        }
+        const messageStart = headerBoundary.index + headerBoundary.delimiterBytes;
+        const frameEnd = messageStart + contentLength;
+        if (this.buffer.length < frameEnd) {
+            return undefined;
+        }
+        const body = this.buffer.subarray(messageStart, frameEnd).toString("utf8");
+        this.buffer = this.buffer.subarray(frameEnd);
+        return parseJsonRpcMessage(body);
+    }
+}
+//# sourceMappingURL=json-rpc-framing.js.map

package/dist/mapping-pipeline-service.d.ts

@@ -12,7 +12,7 @@ export interface MappingPipelineResult {
 /**
  * Mapping pipeline for v0.3.
  * Current implementation enforces explicit guarantees:
- * - official: always pass-through
+ * - obfuscated: always pass-through
  * - mojang: requires source-backed artifact; decompile-only artifacts are rejected
  */
 export declare function applyMappingPipeline(input: MappingPipelineInput): MappingPipelineResult;

package/dist/mapping-pipeline-service.js

@@ -2,14 +2,14 @@ import { createError, ERROR_CODES } from "./errors.js";
 /**
  * Mapping pipeline for v0.3.
  * Current implementation enforces explicit guarantees:
- * - official: always pass-through
+ * - obfuscated: always pass-through
  * - mojang: requires source-backed artifact; decompile-only artifacts are rejected
  */
 export function applyMappingPipeline(input) {
     const transformChain = [];
     const qualityFlags = [];
-    if (input.requestedMapping === "official") {
-        transformChain.push("mapping:official-pass-through");
+    if (input.requestedMapping === "obfuscated") {
+        transformChain.push("mapping:obfuscated-pass-through");
         if (input.resolved.isDecompiled) {
             qualityFlags.push("decompiled");
         }
@@ -17,7 +17,7 @@ export function applyMappingPipeline(input) {
             qualityFlags.push("source-backed");
         }
         return {
-            mappingApplied: "official",
+            mappingApplied: "obfuscated",
             qualityFlags,
             transformChain
         };
@@ -43,9 +43,17 @@ export function applyMappingPipeline(input) {
                 requestedMapping: input.requestedMapping,
                 target: input.target,
                 origin: input.resolved.origin,
+                artifactOrigin: input.resolved.origin,
                 binaryJarPath: input.resolved.binaryJarPath,
                 sourceJarPath: input.resolved.sourceJarPath,
-                nextAction: "Provide a source-backed artifact (source jar) or use mapping=official."
+                nextAction: "Provide a source-backed artifact (source jar) or use mapping=obfuscated.",
+                suggestedCall: {
+                    tool: "resolve-artifact",
+                    params: {
+                        target: input.target,
+                        mapping: "obfuscated"
+                    }
+                }
             }
         });
     }

package/dist/mapping-service.d.ts

@@ -46,6 +46,8 @@ export type SymbolResolutionOutput = {
     status: SymbolResolutionStatus;
     resolvedSymbol?: SymbolReference;
     candidates: Array<SymbolReference & Pick<MappingLookupCandidate, "matchKind" | "confidence">>;
+    candidateCount: number;
+    candidatesTruncated?: boolean;
     warnings: string[];
     provenance?: MappingLookupProvenance;
     ambiguityReasons?: string[];
@@ -56,6 +58,7 @@ export type FindMappingInput = {
     name: string;
     owner?: string;
     descriptor?: string;
+    signatureMode?: "exact" | "name-only";
     sourceMapping: SourceMapping;
     targetMapping: SourceMapping;
     sourcePriority?: MappingSourcePriority;
@@ -63,6 +66,7 @@ export type FindMappingInput = {
         ownerHint?: string;
         descriptorHint?: string;
     };
+    maxCandidates?: number;
 };
 export type FindMappingOutput = SymbolResolutionOutput;
 export type EnsureMappingAvailableInput = {
@@ -78,13 +82,13 @@ export type EnsureMappingAvailableOutput = {
 };
 export type ResolveMethodMappingExactInput = {
     version: string;
-    kind: SymbolQueryKind;
     name: string;
-    owner?: string;
-    descriptor?: string;
+    owner: string;
+    descriptor: string;
     sourceMapping: SourceMapping;
     targetMapping: SourceMapping;
     sourcePriority?: MappingSourcePriority;
+    maxCandidates?: number;
 };
 export type ResolveMethodMappingExactOutput = SymbolResolutionOutput;
 export type ClassApiMatrixKind = "class" | "field" | "method";
@@ -94,6 +98,7 @@ export type ClassApiMatrixInput = {
     classNameMapping: SourceMapping;
     sourcePriority?: MappingSourcePriority;
     includeKinds?: ClassApiMatrixKind[];
+    maxRows?: number;
 };
 export type ClassApiMatrixEntry = {
     symbol: string;
@@ -104,7 +109,7 @@ export type ClassApiMatrixEntry = {
 export type ClassApiMatrixRow = {
     kind: ClassApiMatrixKind;
     descriptor?: string;
-    official?: ClassApiMatrixEntry;
+    obfuscated?: ClassApiMatrixEntry;
     mojang?: ClassApiMatrixEntry;
     intermediary?: ClassApiMatrixEntry;
     yarn?: ClassApiMatrixEntry;
@@ -116,6 +121,8 @@ export type ClassApiMatrixOutput = {
     classNameMapping: SourceMapping;
     classIdentity: Partial<Record<SourceMapping, string>>;
     rows: ClassApiMatrixRow[];
+    rowCount: number;
+    rowsTruncated?: boolean;
     warnings: string[];
     ambiguousRowCount?: number;
 };
@@ -129,6 +136,7 @@ export type SymbolExistenceInput = {
     sourcePriority?: MappingSourcePriority;
     nameMode?: "fqcn" | "auto";
     signatureMode?: "exact" | "name-only";
+    maxCandidates?: number;
 };
 export type SymbolExistenceOutput = SymbolResolutionOutput;
 export declare class MappingService {