@adhisang/minecraft-modding-mcp 3.2.0 → 4.1.0

package/dist/source/cache-metrics.d.ts

@@ -0,0 +1,26 @@
+import type { SourceService } from "../source-service.js";
+export declare function hasAnyFiles(svc: SourceService, artifactId: string): boolean;
+/**
+ * Best-effort cleanup of `<cacheDir>/remapped/<artifactId>.jar` written by
+ * the binary-remap path. Called from cache-eviction so the Mojang-remapped
+ * binary jar does not outlive the artifact row that owns it. Also releases
+ * the jar's bytes from `state.cacheTotalContentBytes`. Errors are
+ * swallowed: orphaned jars remain visible to `manage-cache` under the
+ * `binary-remap` cache kind and can be reclaimed there.
+ */
+export declare function unlinkRemappedJarForArtifact(svc: SourceService, artifactId: string): void;
+/**
+ * Add the remapped jar's on-disk size to `state.cacheTotalContentBytes` so
+ * the `enforceCacheLimits` byte gate sees the jar before deciding to evict.
+ * Without this, a Mojang-remapped client jar (tens of MB) can accumulate
+ * silently while the indexed-source byte total stays below `maxCacheBytes`.
+ */
+export declare function recordRemappedJarBytes(svc: SourceService, artifactId: string, sizeBytes: number): void;
+export declare function releaseRemappedJarBytes(svc: SourceService, artifactId: string): void;
+export declare function enforceCacheLimits(svc: SourceService): void;
+export declare function refreshCacheMetrics(svc: SourceService): void;
+export declare function touchCacheMetrics(svc: SourceService, artifactId: string, updatedAt: string): void;
+export declare function upsertCacheMetrics(svc: SourceService, artifactId: string, totalContentBytes: number, updatedAt: string): void;
+export declare function removeCacheMetrics(svc: SourceService, artifactId: string, publish?: boolean): void;
+export declare function publishCacheMetrics(svc: SourceService): void;
+export declare function snapshotLruAccounting(svc: SourceService): void;

package/dist/source/cache-metrics.js

@@ -0,0 +1,172 @@
+import { existsSync, readdirSync, statSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { log } from "../logger.js";
+export function hasAnyFiles(svc, artifactId) {
+    return svc.filesRepo.listFiles(artifactId, { limit: 1 }).items.length > 0;
+}
+/**
+ * Best-effort cleanup of `<cacheDir>/remapped/<artifactId>.jar` written by
+ * the binary-remap path. Called from cache-eviction so the Mojang-remapped
+ * binary jar does not outlive the artifact row that owns it. Also releases
+ * the jar's bytes from `state.cacheTotalContentBytes`. Errors are
+ * swallowed: orphaned jars remain visible to `manage-cache` under the
+ * `binary-remap` cache kind and can be reclaimed there.
+ */
+export function unlinkRemappedJarForArtifact(svc, artifactId) {
+    releaseRemappedJarBytes(svc, artifactId);
+    const remappedJarPath = join(svc.config.cacheDir, "remapped", `${artifactId}.jar`);
+    try {
+        if (existsSync(remappedJarPath)) {
+            unlinkSync(remappedJarPath);
+        }
+    }
+    catch {
+        // ignore: orphaned jar is still reclaimable via manage-cache binary-remap kind.
+    }
+}
+/**
+ * Add the remapped jar's on-disk size to `state.cacheTotalContentBytes` so
+ * the `enforceCacheLimits` byte gate sees the jar before deciding to evict.
+ * Without this, a Mojang-remapped client jar (tens of MB) can accumulate
+ * silently while the indexed-source byte total stays below `maxCacheBytes`.
+ */
+export function recordRemappedJarBytes(svc, artifactId, sizeBytes) {
+    const normalized = Math.max(0, Math.trunc(sizeBytes));
+    const existing = svc.state.remappedJarBytes.get(artifactId) ?? 0;
+    svc.state.cacheTotalContentBytes = Math.max(0, svc.state.cacheTotalContentBytes - existing + normalized);
+    svc.state.remappedJarBytes.set(artifactId, normalized);
+    publishCacheMetrics(svc);
+}
+export function releaseRemappedJarBytes(svc, artifactId) {
+    const existing = svc.state.remappedJarBytes.get(artifactId);
+    if (!existing) {
+        return;
+    }
+    svc.state.cacheTotalContentBytes = Math.max(0, svc.state.cacheTotalContentBytes - existing);
+    svc.state.remappedJarBytes.delete(artifactId);
+    publishCacheMetrics(svc);
+}
+export function enforceCacheLimits(svc) {
+    let artifactCount = svc.state.lru.size;
+    let totalBytes = svc.state.cacheTotalContentBytes;
+    if (artifactCount <= svc.config.maxArtifacts && totalBytes <= svc.config.maxCacheBytes) {
+        return;
+    }
+    const candidates = svc.state.lru.toArray();
+    for (const candidate of candidates) {
+        const shouldEvict = artifactCount > svc.config.maxArtifacts || totalBytes > svc.config.maxCacheBytes;
+        if (!shouldEvict || artifactCount <= 1) {
+            break;
+        }
+        const artifactCountBefore = artifactCount;
+        const totalBytesBefore = totalBytes;
+        const remappedBytesForCandidate = svc.state.remappedJarBytes.get(candidate.key) ?? 0;
+        svc.filesRepo.deleteFilesForArtifact(candidate.key);
+        svc.artifactsRepo.deleteArtifact(candidate.key);
+        unlinkRemappedJarForArtifact(svc, candidate.key);
+        removeCacheMetrics(svc, candidate.key, false);
+        artifactCount = Math.max(0, artifactCount - 1);
+        totalBytes = Math.max(0, totalBytes - candidate.value.totalContentBytes - remappedBytesForCandidate);
+        svc.metrics.recordCacheEviction();
+        log("warn", "cache.evict", {
+            artifactId: candidate.key,
+            artifactCountBefore,
+            totalBytesBefore,
+            artifactBytes: candidate.value.totalContentBytes + remappedBytesForCandidate
+        });
+    }
+    publishCacheMetrics(svc);
+}
+export function refreshCacheMetrics(svc) {
+    const cacheEntries = svc.artifactsRepo.countArtifacts();
+    const totalContentBytes = svc.artifactsRepo.totalContentBytes();
+    const lruAccounting = svc.artifactsRepo.listArtifactsByLruWithContentBytes(Math.max(cacheEntries, 1));
+    svc.state.lru.clear();
+    for (const row of lruAccounting) {
+        svc.state.lru.upsert(row.artifactId, {
+            totalContentBytes: row.totalContentBytes,
+            updatedAt: row.updatedAt
+        });
+    }
+    svc.state.remappedJarBytes.clear();
+    let remappedTotal = 0;
+    const remappedDir = join(svc.config.cacheDir, "remapped");
+    if (existsSync(remappedDir)) {
+        // Only count remapped jars whose owning artifact is still in the LRU set.
+        // Orphaned jars (artifact deleted, prior unlink lost a race, externally
+        // placed) stay visible to manage-cache under the `binary-remap` kind
+        // for prune, but must not be folded into `cacheTotalContentBytes` here:
+        // enforceCacheLimits cannot evict them, so counting their bytes would
+        // force unrelated live artifacts to be evicted to chase orphan bytes.
+        const liveArtifactIds = new Set(svc.state.lru.toArray().map((entry) => entry.key));
+        try {
+            for (const entry of readdirSync(remappedDir, { withFileTypes: true })) {
+                if (!entry.isFile() || !entry.name.endsWith(".jar")) {
+                    continue;
+                }
+                const artifactId = entry.name.slice(0, -".jar".length);
+                if (!liveArtifactIds.has(artifactId)) {
+                    continue;
+                }
+                try {
+                    const fileStat = statSync(join(remappedDir, entry.name));
+                    const size = Math.max(0, Math.trunc(fileStat.size));
+                    svc.state.remappedJarBytes.set(artifactId, size);
+                    remappedTotal += size;
+                }
+                catch {
+                    // ignore stat failure on a single jar; total stays best-effort.
+                }
+            }
+        }
+        catch {
+            // ignore listing failure; remapped accounting stays empty until next remap.
+        }
+    }
+    svc.state.cacheTotalContentBytes = totalContentBytes + remappedTotal;
+    publishCacheMetrics(svc);
+}
+export function touchCacheMetrics(svc, artifactId, updatedAt) {
+    const entry = svc.state.lru.touch(artifactId);
+    if (!entry) {
+        refreshCacheMetrics(svc);
+        return;
+    }
+    entry.updatedAt = updatedAt;
+    publishCacheMetrics(svc);
+}
+export function upsertCacheMetrics(svc, artifactId, totalContentBytes, updatedAt) {
+    const normalizedBytes = Math.max(0, Math.trunc(totalContentBytes));
+    const existing = svc.state.lru.remove(artifactId);
+    if (existing) {
+        svc.state.cacheTotalContentBytes = Math.max(0, svc.state.cacheTotalContentBytes - existing.totalContentBytes + normalizedBytes);
+    }
+    else {
+        svc.state.cacheTotalContentBytes += normalizedBytes;
+    }
+    svc.state.lru.upsert(artifactId, { totalContentBytes: normalizedBytes, updatedAt });
+    publishCacheMetrics(svc);
+}
+export function removeCacheMetrics(svc, artifactId, publish = true) {
+    const existing = svc.state.lru.remove(artifactId);
+    if (!existing) {
+        refreshCacheMetrics(svc);
+        return;
+    }
+    svc.state.cacheTotalContentBytes = Math.max(0, svc.state.cacheTotalContentBytes - existing.totalContentBytes);
+    if (publish) {
+        publishCacheMetrics(svc);
+    }
+}
+export function publishCacheMetrics(svc) {
+    svc.metrics.setCacheEntries(svc.state.lru.size);
+    svc.metrics.setCacheTotalContentBytes(svc.state.cacheTotalContentBytes);
+}
+export function snapshotLruAccounting(svc) {
+    svc.metrics.setCacheArtifactByteAccountingRef(svc.state.lru.toArray().map(({ key, value }) => ({
+        artifactId: key,
+        totalContentBytes: value.totalContentBytes,
+        updatedAt: value.updatedAt
+    })));
+}
+//# sourceMappingURL=cache-metrics.js.map

package/dist/source/class-source/members-builder.d.ts

@@ -0,0 +1,34 @@
+import type { SignatureMember } from "../../minecraft-explorer-service.js";
+import type { SourceService } from "../../source-service.js";
+import type { MappingSourcePriority, SourceMapping } from "../../types.js";
+export type RemappedMembers = {
+    constructors: SignatureMember[];
+    fields: SignatureMember[];
+    methods: SignatureMember[];
+    counts: {
+        constructors: number;
+        fields: number;
+        methods: number;
+        total: number;
+    };
+};
+export type RemapMembersInput = {
+    signatureConstructors: SignatureMember[];
+    signatureFields: SignatureMember[];
+    signatureMethods: SignatureMember[];
+    version: string | undefined;
+    mappingApplied: SourceMapping;
+    requestedMapping: SourceMapping;
+    sourcePriority: MappingSourcePriority | undefined;
+    memberPattern: string | undefined;
+    warnings: string[];
+};
+export declare function remapAndCountMembers(svc: SourceService, input: RemapMembersInput): Promise<RemappedMembers>;
+export type MemberSliceResult = {
+    constructors: SignatureMember[];
+    fields: SignatureMember[];
+    methods: SignatureMember[];
+    truncated: boolean;
+    returnedTotal: number;
+};
+export declare function sliceMembersWithLimit(remapped: Omit<RemappedMembers, "counts">, totalCount: number, maxMembers: number, warnings: string[]): MemberSliceResult;

package/dist/source/class-source/members-builder.js

@@ -0,0 +1,46 @@
+export async function remapAndCountMembers(svc, input) {
+    const remap = async (members, kind) => {
+        if (input.version == null) {
+            return members;
+        }
+        const result = await svc.remapSignatureMembers(members, kind, input.version, input.mappingApplied, input.requestedMapping, input.sourcePriority, input.warnings);
+        return result.members;
+    };
+    let constructors = await remap(input.signatureConstructors, "method");
+    let fields = await remap(input.signatureFields, "field");
+    let methods = await remap(input.signatureMethods, "method");
+    if (input.requestedMapping !== input.mappingApplied && input.memberPattern) {
+        const lowerPattern = input.memberPattern.toLowerCase();
+        constructors = constructors.filter((m) => m.name.toLowerCase().includes(lowerPattern));
+        fields = fields.filter((m) => m.name.toLowerCase().includes(lowerPattern));
+        methods = methods.filter((m) => m.name.toLowerCase().includes(lowerPattern));
+    }
+    const counts = {
+        constructors: constructors.length,
+        fields: fields.length,
+        methods: methods.length,
+        total: constructors.length + fields.length + methods.length
+    };
+    return { constructors, fields, methods, counts };
+}
+export function sliceMembersWithLimit(remapped, totalCount, maxMembers, warnings) {
+    let remaining = maxMembers;
+    const takeWithinLimit = (members) => {
+        if (remaining <= 0) {
+            return [];
+        }
+        const slice = members.slice(0, remaining);
+        remaining -= slice.length;
+        return slice;
+    };
+    const constructors = takeWithinLimit(remapped.constructors);
+    const fields = takeWithinLimit(remapped.fields);
+    const methods = takeWithinLimit(remapped.methods);
+    const returnedTotal = constructors.length + fields.length + methods.length;
+    const truncated = returnedTotal < totalCount;
+    if (truncated) {
+        warnings.push(`Member list was truncated to ${returnedTotal} entries (from ${totalCount}).`);
+    }
+    return { constructors, fields, methods, truncated, returnedTotal };
+}
+//# sourceMappingURL=members-builder.js.map

package/dist/source/class-source/snippet-builder.d.ts

@@ -0,0 +1,19 @@
+import type { SourceMode } from "../../source-service.js";
+export type SnippetBuildInput = {
+    filePath: string;
+    content: string;
+    mode: SourceMode;
+    startLine: number | undefined;
+    endLine: number | undefined;
+    maxLines: number | undefined;
+    maxChars: number | undefined;
+};
+export type SnippetBuildResult = {
+    sourceText: string;
+    totalLines: number;
+    returnedStart: number;
+    returnedEnd: number;
+    truncated: boolean;
+    charsTruncated: boolean;
+};
+export declare function buildClassSourceSnippet(input: SnippetBuildInput): SnippetBuildResult;

package/dist/source/class-source/snippet-builder.js

@@ -0,0 +1,46 @@
+import * as classSourceHelpers from "../class-source-helpers.js";
+export function buildClassSourceSnippet(input) {
+    const lines = input.content.split(/\r?\n/);
+    const totalLines = lines.length;
+    let sourceText;
+    let returnedStart;
+    let returnedEnd;
+    let truncated = false;
+    let charsTruncated = false;
+    if (input.mode === "metadata") {
+        sourceText = classSourceHelpers.extractClassMetadata(input.filePath, input.content);
+        returnedStart = 1;
+        returnedEnd = totalLines;
+    }
+    else {
+        const requestedStart = input.startLine ?? 1;
+        const requestedEnd = input.endLine ?? totalLines;
+        const normalizedStart = Math.min(Math.max(1, requestedStart), Math.max(totalLines, 1));
+        const normalizedEnd = Math.min(Math.max(normalizedStart, requestedEnd), Math.max(totalLines, 1));
+        let selectedLines = lines.slice(normalizedStart - 1, normalizedEnd);
+        const clippedByRange = normalizedStart !== requestedStart || normalizedEnd !== requestedEnd;
+        let clippedByMax = false;
+        if (input.maxLines != null && selectedLines.length > input.maxLines) {
+            selectedLines = selectedLines.slice(0, input.maxLines);
+            clippedByMax = true;
+        }
+        sourceText = selectedLines.join("\n");
+        returnedStart = normalizedStart;
+        returnedEnd = normalizedStart + Math.max(0, selectedLines.length - 1);
+        truncated = clippedByRange || clippedByMax;
+    }
+    if (input.maxChars != null && sourceText.length > input.maxChars) {
+        sourceText = sourceText.slice(0, input.maxChars);
+        charsTruncated = true;
+        truncated = true;
+    }
+    return {
+        sourceText,
+        totalLines,
+        returnedStart,
+        returnedEnd,
+        truncated,
+        charsTruncated
+    };
+}
+//# sourceMappingURL=snippet-builder.js.map

package/dist/source/class-source-helpers.d.ts

@@ -0,0 +1,34 @@
+export type DecompiledMember = {
+    name: string;
+    line: number;
+    kind: "constructor" | "field" | "method";
+};
+export declare function extractClassMetadata(filePath: string, content: string): string;
+export declare function extractDecompiledMembers(className: string, filePath: string, content: string): {
+    constructors: DecompiledMember[];
+    fields: DecompiledMember[];
+    methods: DecompiledMember[];
+};
+export declare function computeLineBraceDepths(lines: string[]): number[];
+export declare function computeBraceRange(lines: string[], symbols: Array<{
+    symbolKind: string;
+    symbolName: string;
+    line: number;
+}>, simpleName: string): {
+    declarationLine: number;
+    endLine: number;
+} | undefined;
+export declare function scanBraceRange(lines: string[], declarationLine: number): {
+    declarationLine: number;
+    endLine: number;
+};
+export declare function computeNestedTypeRanges(lines: string[], symbols: Array<{
+    symbolKind: string;
+    line: number;
+}>, outerBody: {
+    declarationLine: number;
+    endLine: number;
+}): Array<{
+    declarationLine: number;
+    endLine: number;
+}>;

package/dist/source/class-source-helpers.js

@@ -0,0 +1,140 @@
+import { extractSymbolsFromSource } from "../symbols/symbol-extractor.js";
+export function extractClassMetadata(filePath, content) {
+    const lines = content.split(/\r?\n/);
+    const symbols = extractSymbolsFromSource(filePath, content);
+    const outputParts = [];
+    // Include package + import header (lines before first symbol declaration)
+    const firstSymbolLine = symbols.length > 0 ? symbols[0].line : lines.length + 1;
+    for (let i = 0; i < Math.min(firstSymbolLine - 1, lines.length); i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (trimmed.startsWith("package ") || trimmed.startsWith("import ") || trimmed === "") {
+            outputParts.push(line);
+        }
+    }
+    // Add each symbol's declaration line
+    for (const symbol of symbols) {
+        const lineIndex = symbol.line - 1;
+        if (lineIndex >= 0 && lineIndex < lines.length) {
+            const prefix = symbol.symbolKind === "class" || symbol.symbolKind === "interface" ||
+                symbol.symbolKind === "enum" || symbol.symbolKind === "record"
+                ? `\n// [${symbol.symbolKind}] line ${symbol.line}`
+                : `// [${symbol.symbolKind}] line ${symbol.line}`;
+            outputParts.push(prefix);
+            outputParts.push(lines[lineIndex]);
+        }
+    }
+    return outputParts.join("\n");
+}
+export function extractDecompiledMembers(className, filePath, content) {
+    const symbols = extractSymbolsFromSource(filePath, content);
+    const simpleName = className.split(/[.$]/).at(-1) ?? className;
+    const lines = content.split(/\r?\n/);
+    const body = computeBraceRange(lines, symbols, simpleName);
+    if (!body) {
+        return { constructors: [], fields: [], methods: [] };
+    }
+    const depths = computeLineBraceDepths(lines);
+    const baseDepth = depths[body.declarationLine - 1] ?? 0;
+    const nestedRanges = computeNestedTypeRanges(lines, symbols, body);
+    const constructors = [];
+    const fields = [];
+    const methods = [];
+    for (const symbol of symbols) {
+        if (symbol.line <= body.declarationLine || symbol.line > body.endLine) {
+            continue;
+        }
+        if (nestedRanges.some((range) => symbol.line >= range.declarationLine && symbol.line <= range.endLine)) {
+            continue;
+        }
+        const lineDepth = depths[symbol.line - 1] ?? baseDepth;
+        // Declarations directly inside the class body sit at baseDepth+1; anything
+        // deeper is a method/constructor body, an initializer block, etc.
+        if (lineDepth !== baseDepth + 1) {
+            continue;
+        }
+        if (symbol.symbolKind === "method") {
+            if (symbol.symbolName === simpleName) {
+                constructors.push({ name: "<init>", line: symbol.line, kind: "constructor" });
+            }
+            else {
+                methods.push({ name: symbol.symbolName, line: symbol.line, kind: "method" });
+            }
+        }
+        else if (symbol.symbolKind === "field") {
+            fields.push({ name: symbol.symbolName, line: symbol.line, kind: "field" });
+        }
+    }
+    return { constructors, fields, methods };
+}
+export function computeLineBraceDepths(lines) {
+    const depths = new Array(lines.length).fill(0);
+    let depth = 0;
+    for (let i = 0; i < lines.length; i += 1) {
+        // Entry depth for this line = depth observed before any brace on it.
+        depths[i] = depth;
+        const stripped = (lines[i] ?? "")
+            .replace(/\/\/.*/g, "")
+            .replace(/"(?:\\.|[^"\\])*"/g, "\"\"")
+            .replace(/'(?:\\.|[^'\\])*'/g, "''");
+        for (const char of stripped) {
+            if (char === "{") {
+                depth += 1;
+            }
+            else if (char === "}") {
+                depth -= 1;
+            }
+        }
+    }
+    return depths;
+}
+export function computeBraceRange(lines, symbols, simpleName) {
+    const classSymbol = symbols.find((symbol) => (symbol.symbolKind === "class" || symbol.symbolKind === "interface"
+        || symbol.symbolKind === "enum" || symbol.symbolKind === "record")
+        && symbol.symbolName === simpleName);
+    if (!classSymbol) {
+        return undefined;
+    }
+    return scanBraceRange(lines, classSymbol.line);
+}
+export function scanBraceRange(lines, declarationLine) {
+    let depth = 0;
+    let started = false;
+    for (let i = declarationLine - 1; i < lines.length; i += 1) {
+        const stripped = (lines[i] ?? "")
+            .replace(/\/\/.*/g, "")
+            .replace(/"(?:\\.|[^"\\])*"/g, "\"\"");
+        for (const char of stripped) {
+            if (char === "{") {
+                depth += 1;
+                started = true;
+            }
+            else if (char === "}") {
+                depth -= 1;
+                if (started && depth === 0) {
+                    return { declarationLine, endLine: i + 1 };
+                }
+            }
+        }
+    }
+    return { declarationLine, endLine: lines.length };
+}
+export function computeNestedTypeRanges(lines, symbols, outerBody) {
+    const ranges = [];
+    for (const candidate of symbols) {
+        if (candidate.symbolKind !== "class" && candidate.symbolKind !== "interface"
+            && candidate.symbolKind !== "enum" && candidate.symbolKind !== "record") {
+            continue;
+        }
+        if (candidate.line <= outerBody.declarationLine || candidate.line > outerBody.endLine) {
+            continue;
+        }
+        if (ranges.some((range) => candidate.line >= range.declarationLine && candidate.line <= range.endLine)) {
+            continue;
+        }
+        const nestedRange = scanBraceRange(lines, candidate.line);
+        ranges.push(nestedRange);
+    }
+    return ranges;
+}
+//# sourceMappingURL=class-source-helpers.js.map

package/dist/source/class-source.d.ts

@@ -0,0 +1,42 @@
+import { type AppError } from "../errors.js";
+import type { SourceService } from "../source-service.js";
+import type { DecompiledFallback, FindClassInput, FindClassOutput, GetClassMembersInput, GetClassMembersOutput, GetClassSourceInput, GetClassSourceOutput } from "../source-service.js";
+import type { ArtifactProvenance, ArtifactScope, MappingSourcePriority, ResolvedSourceArtifact, SourceMapping } from "../types.js";
+export declare function resolveClassFilePath(svc: SourceService, artifactId: string, className: string): string | undefined;
+export declare function resolveClassNameForLookup(svc: SourceService, input: {
+    className: string;
+    version?: string;
+    sourceMapping: SourceMapping;
+    targetMapping: SourceMapping;
+    sourcePriority: MappingSourcePriority | undefined;
+    warnings: string[];
+    context: string;
+}): Promise<string>;
+export declare function buildFallbackProvenance(svc: SourceService, input: {
+    artifactId: string;
+    origin: ResolvedSourceArtifact["origin"];
+    requestedMapping: SourceMapping;
+    mappingApplied: SourceMapping;
+}): ArtifactProvenance;
+export declare function buildClassSourceNotFoundError(_svc: SourceService, input: {
+    className: string;
+    lookupClassName: string;
+    artifactId: string;
+    mappingApplied: SourceMapping;
+    requestedMapping: SourceMapping;
+    qualityFlags: string[];
+    attemptedBinaryFallback: boolean;
+    filePath?: string;
+    targetKind?: string;
+    targetValue?: string;
+    scope?: ArtifactScope;
+    projectPath?: string;
+    version?: string;
+}): AppError;
+export declare function buildDecompiledFallback(svc: SourceService, artifactId: string, lookupClassName: string, memberPattern: string | undefined, maxMembers: number): {
+    fallback: DecompiledFallback;
+    counts: NonNullable<GetClassMembersOutput["decompiledMemberCounts"]>;
+} | undefined;
+export declare function findClass(svc: SourceService, input: FindClassInput): FindClassOutput;
+export declare function getClassSource(svc: SourceService, input: GetClassSourceInput): Promise<GetClassSourceOutput>;
+export declare function getClassMembers(svc: SourceService, input: GetClassMembersInput): Promise<GetClassMembersOutput>;