@adhisang/minecraft-modding-mcp 1.0.0

package/dist/source-resolver.js

@@ -0,0 +1,274 @@
+import { readdirSync } from "node:fs";
+import { basename, dirname, join, resolve as resolvePath } from "node:path";
+import { createError, ERROR_CODES } from "./errors.js";
+import { buildRemoteBinaryUrls, buildRemoteSourceUrls, hasExistingJar, parseCoordinate, normalizedCoordinateValue } from "./maven-resolver.js";
+import { defaultDownloadPath, downloadToCache } from "./repo-downloader.js";
+import { artifactSignatureFromFile, normalizeJarPath } from "./path-resolver.js";
+import { stableArtifactId } from "./config.js";
+import { listJavaEntries } from "./source-jar-reader.js";
+function readStatsSignature(filePath) {
+    const stats = artifactSignatureFromFile(filePath);
+    return stats.signature;
+}
+async function hasJavaSources(jarPath) {
+    if (!hasExistingJar(jarPath)) {
+        return false;
+    }
+    const entries = await listJavaEntries(jarPath);
+    return entries.length > 0;
+}
+function resolveExactJarSourceCandidate(inputJarPath) {
+    const directory = dirname(inputJarPath);
+    const jarName = basename(inputJarPath);
+    const base = jarName.endsWith(".jar") ? jarName.slice(0, -4) : jarName;
+    return join(directory, `${base}-sources.jar`);
+}
+function listAdjacentJarSourceCandidates(inputJarPath) {
+    const directory = dirname(inputJarPath);
+    const exact = resolveExactJarSourceCandidate(inputJarPath);
+    const candidates = new Set();
+    try {
+        for (const file of readdirSync(directory)) {
+            if (file.toLowerCase().endsWith("-sources.jar")) {
+                const candidate = join(directory, file);
+                if (candidate !== inputJarPath && candidate !== exact) {
+                    candidates.add(candidate);
+                }
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    return [...candidates];
+}
+function resolveLocalCoordinateCandidates(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 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)) {
+            existing.add(candidate);
+        }
+    }
+    return [...existing];
+}
+function resolveRemoteBinaryCandidate(coordinate, repos) {
+    return buildRemoteBinaryUrls(repos, coordinate);
+}
+function artifactIdForJar(inputKind, artifactPath, signature, suffix) {
+    return stableArtifactId([inputKind, artifactPath, signature, suffix ?? "source"]);
+}
+function artifactIdForCoordinate(coordinate, source, signature) {
+    return stableArtifactId(["coord", coordinate, source, signature]);
+}
+function resolvedAtNow() {
+    return new Date().toISOString();
+}
+export async function resolveSourceTarget(input, options, explicitConfig) {
+    const repos = options.preferredRepos?.length ? options.preferredRepos : explicitConfig.sourceRepos;
+    let sawRemoteRepoFailure = false;
+    if (input.kind === "jar") {
+        const resolvedJarPath = normalizeJarPath(input.value);
+        const binarySignature = readStatsSignature(resolvedJarPath);
+        const exactSourceJarPath = resolveExactJarSourceCandidate(resolvedJarPath);
+        const adjacentSourceCandidates = listAdjacentJarSourceCandidates(resolvedJarPath);
+        const maybeAdjacentSourceCandidates = adjacentSourceCandidates.length > 0 ? adjacentSourceCandidates : undefined;
+        if (await hasJavaSources(resolvedJarPath)) {
+            return {
+                artifactId: artifactIdForJar("jar", resolvedJarPath, binarySignature),
+                artifactSignature: binarySignature,
+                origin: "local-jar",
+                binaryJarPath: resolvedJarPath,
+                sourceJarPath: resolvedJarPath,
+                adjacentSourceCandidates: maybeAdjacentSourceCandidates,
+                isDecompiled: false,
+                resolvedAt: resolvedAtNow()
+            };
+        }
+        if (await hasJavaSources(exactSourceJarPath)) {
+            const sourceSignature = readStatsSignature(exactSourceJarPath);
+            return {
+                artifactId: artifactIdForJar("jar", exactSourceJarPath, sourceSignature),
+                artifactSignature: sourceSignature,
+                origin: "local-jar",
+                binaryJarPath: resolvedJarPath,
+                sourceJarPath: exactSourceJarPath,
+                adjacentSourceCandidates: maybeAdjacentSourceCandidates,
+                isDecompiled: false,
+                resolvedAt: resolvedAtNow()
+            };
+        }
+        if (!options.allowDecompile) {
+            throw createError({
+                code: ERROR_CODES.SOURCE_NOT_FOUND,
+                message: `No source jar was found for "${input.value}" and decompile is disabled.`,
+                details: {
+                    jarPath: resolvedJarPath,
+                    adjacentSourceCandidates: maybeAdjacentSourceCandidates
+                }
+            });
+        }
+        return {
+            artifactId: artifactIdForJar("jar", resolvedJarPath, `${binarySignature}:decompile`),
+            artifactSignature: `${binarySignature}:decompile`,
+            origin: "decompiled",
+            binaryJarPath: resolvedJarPath,
+            adjacentSourceCandidates: maybeAdjacentSourceCandidates,
+            isDecompiled: true,
+            resolvedAt: resolvedAtNow()
+        };
+    }
+    if (input.kind !== "coordinate") {
+        throw createError({
+            code: ERROR_CODES.INVALID_INPUT,
+            message: `Unsupported input kind "${input.kind}".`,
+            details: { input }
+        });
+    }
+    const coordinate = normalizedCoordinateValue(input.value);
+    const isTransientFailure = (statusCode) => statusCode === undefined || statusCode >= 500 || statusCode === 429;
+    for (const candidate of resolveLocalCoordinateCandidates(explicitConfig.localM2Path, coordinate)) {
+        if (await hasJavaSources(candidate)) {
+            const signature = readStatsSignature(candidate);
+            return {
+                artifactId: artifactIdForCoordinate(coordinate, "local-m2", signature),
+                artifactSignature: signature,
+                origin: "local-m2",
+                sourceJarPath: candidate,
+                coordinate,
+                isDecompiled: false,
+                resolvedAt: resolvedAtNow()
+            };
+        }
+    }
+    const remoteSourceUrls = buildRemoteSourceUrls(repos, coordinate);
+    for (let index = 0; index < remoteSourceUrls.length; index++) {
+        const sourceUrl = remoteSourceUrls[index];
+        const hasNextAttempt = index < remoteSourceUrls.length - 1;
+        try {
+            const download = await downloadToCache(sourceUrl, defaultDownloadPath(explicitConfig.cacheDir, sourceUrl), {
+                retries: explicitConfig.fetchRetries,
+                timeoutMs: explicitConfig.fetchTimeoutMs
+            });
+            if (!download.ok || !download.path || !(await hasJavaSources(download.path))) {
+                const transient = download.ok
+                    ? false
+                    : download.statusCode !== 404 && isTransientFailure(download.statusCode);
+                sawRemoteRepoFailure = sawRemoteRepoFailure || transient;
+                if (hasNextAttempt && transient) {
+                    options.onRepoFailover?.({
+                        stage: "source",
+                        repoUrl: sourceUrl,
+                        statusCode: download.statusCode,
+                        reason: download.ok ? "downloaded-no-sources" : "download-failed",
+                        attempt: index + 1,
+                        totalAttempts: remoteSourceUrls.length
+                    });
+                }
+                continue;
+            }
+            const signature = `${download.contentLength ?? 0}:${download.etag ?? ""}:${download.lastModified ?? ""}`;
+            return {
+                artifactId: artifactIdForCoordinate(coordinate, "remote-repo", signature),
+                artifactSignature: signature,
+                origin: "remote-repo",
+                sourceJarPath: download.path,
+                coordinate,
+                repoUrl: sourceUrl,
+                isDecompiled: false,
+                resolvedAt: resolvedAtNow()
+            };
+        }
+        catch (caughtError) {
+            sawRemoteRepoFailure = true;
+            if (hasNextAttempt) {
+                options.onRepoFailover?.({
+                    stage: "source",
+                    repoUrl: sourceUrl,
+                    reason: caughtError instanceof Error ? caughtError.message : "download-error",
+                    attempt: index + 1,
+                    totalAttempts: remoteSourceUrls.length
+                });
+            }
+        }
+    }
+    if (!options.allowDecompile) {
+        throw createError({
+            code: sawRemoteRepoFailure ? ERROR_CODES.REPO_FETCH_FAILED : ERROR_CODES.SOURCE_NOT_FOUND,
+            message: sawRemoteRepoFailure
+                ? `No source jar was found for "${coordinate}" and repository fetches were unstable.`
+                : `No source jar was found for "${coordinate}" and decompile is disabled.`,
+            details: { coordinate }
+        });
+    }
+    const binaryCandidates = resolveRemoteBinaryCandidate(coordinate, repos);
+    for (let index = 0; index < binaryCandidates.length; index++) {
+        const binaryUrl = binaryCandidates[index];
+        const hasNextAttempt = index < binaryCandidates.length - 1;
+        try {
+            const downloaded = await downloadToCache(binaryUrl, defaultDownloadPath(explicitConfig.cacheDir, binaryUrl), {
+                retries: explicitConfig.fetchRetries,
+                timeoutMs: explicitConfig.fetchTimeoutMs
+            });
+            if (!downloaded.ok || !downloaded.path) {
+                const transient = downloaded.ok
+                    ? false
+                    : downloaded.statusCode !== 404 && isTransientFailure(downloaded.statusCode);
+                sawRemoteRepoFailure = sawRemoteRepoFailure || transient;
+                if (hasNextAttempt && transient) {
+                    options.onRepoFailover?.({
+                        stage: "binary",
+                        repoUrl: binaryUrl,
+                        statusCode: downloaded.statusCode,
+                        reason: downloaded.ok ? "downloaded-no-binary" : "download-failed",
+                        attempt: index + 1,
+                        totalAttempts: binaryCandidates.length
+                    });
+                }
+                continue;
+            }
+            const signature = readStatsSignature(downloaded.path);
+            return {
+                artifactId: artifactIdForCoordinate(coordinate, "decompiled", signature),
+                artifactSignature: signature,
+                origin: "decompiled",
+                binaryJarPath: downloaded.path,
+                coordinate,
+                repoUrl: binaryUrl,
+                isDecompiled: true,
+                resolvedAt: resolvedAtNow()
+            };
+        }
+        catch (caughtError) {
+            sawRemoteRepoFailure = true;
+            if (hasNextAttempt) {
+                options.onRepoFailover?.({
+                    stage: "binary",
+                    repoUrl: binaryUrl,
+                    reason: caughtError instanceof Error ? caughtError.message : "download-error",
+                    attempt: index + 1,
+                    totalAttempts: binaryCandidates.length
+                });
+            }
+        }
+    }
+    throw createError({
+        code: sawRemoteRepoFailure ? ERROR_CODES.REPO_FETCH_FAILED : ERROR_CODES.SOURCE_NOT_FOUND,
+        message: sawRemoteRepoFailure
+            ? `No source or binary artifact was found for "${coordinate}" due to unstable repository responses.`
+            : `No source or binary artifact was found for "${coordinate}".`,
+        details: { coordinate }
+    });
+}
+//# sourceMappingURL=source-resolver.js.map

package/dist/source-service.d.ts

@@ -0,0 +1,404 @@
+import { type ResponseContext as ExplorerResponseContext, type SignatureMember } from "./minecraft-explorer-service.js";
+import { type MixinValidationResult, 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 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";
+import { type DecompileModJarInput, type DecompileModJarOutput, type GetModClassSourceInput, type GetModClassSourceOutput } from "./mod-decompile-service.js";
+import { type SearchModSourceInput, type SearchModSourceOutput } from "./mod-search-service.js";
+export type ResolveArtifactInput = {
+    target: SourceTargetInput;
+    mapping?: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
+    allowDecompile?: boolean;
+};
+export type ResolveArtifactOutput = {
+    artifactId: string;
+    origin: "local-jar" | "local-m2" | "remote-repo" | "decompiled";
+    isDecompiled: boolean;
+    resolvedSourceJarPath?: string;
+    adjacentSourceCandidates?: string[];
+    binaryJarPath?: string;
+    coordinate?: string;
+    version?: string;
+    requestedMapping: SourceMapping;
+    mappingApplied: SourceMapping;
+    provenance: ArtifactProvenance;
+    qualityFlags: string[];
+    repoUrl?: string;
+    warnings: string[];
+};
+type SymbolKind = "class" | "interface" | "enum" | "record" | "method" | "field";
+type SearchIntent = "symbol" | "text" | "path";
+type SearchMatch = "exact" | "prefix" | "contains" | "regex";
+export type SearchScope = {
+    packagePrefix?: string;
+    fileGlob?: string;
+    symbolKind?: SymbolKind;
+};
+export type SearchInclude = {
+    snippetLines?: number;
+    includeDefinition?: boolean;
+    includeOneHop?: boolean;
+};
+export type SearchResultSymbol = {
+    symbolKind: SymbolKind;
+    symbolName: string;
+    qualifiedName?: string;
+    line: number;
+};
+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 SearchClassSourceInput = {
+    artifactId: string;
+    query: string;
+    intent?: SearchIntent;
+    match?: SearchMatch;
+    scope?: SearchScope;
+    include?: SearchInclude;
+    limit?: number;
+    cursor?: string;
+};
+export type SearchClassSourceOutput = {
+    hits: SearchSourceHit[];
+    relations?: SearchRelation[];
+    nextCursor?: string;
+    totalApprox: number;
+    mappingApplied: SourceMapping;
+};
+export type GetArtifactFileInput = {
+    artifactId: string;
+    filePath: string;
+    maxBytes?: number;
+};
+export type GetArtifactFileOutput = {
+    filePath: string;
+    content: string;
+    contentBytes: number;
+    truncated: boolean;
+    mappingApplied: SourceMapping;
+};
+export type ListArtifactFilesInput = {
+    artifactId: string;
+    prefix?: string;
+    limit?: number;
+    cursor?: string;
+};
+export type ListArtifactFilesOutput = {
+    items: string[];
+    nextCursor?: string;
+    mappingApplied: SourceMapping;
+};
+export type FindMappingInput = MappingFindMappingInput;
+export type FindMappingOutput = MappingFindMappingOutput;
+export type ResolveMethodMappingExactInput = MappingResolveMethodMappingExactInput;
+export type ResolveMethodMappingExactOutput = MappingResolveMethodMappingExactOutput;
+export type GetClassApiMatrixInput = MappingClassApiMatrixInput;
+export type GetClassApiMatrixOutput = MappingClassApiMatrixOutput;
+export type CheckSymbolExistsInput = MappingSymbolExistenceInput;
+export type CheckSymbolExistsOutput = MappingSymbolExistenceOutput;
+export type WorkspaceSymbolKind = "class" | "field" | "method";
+export type ResolveWorkspaceSymbolInput = {
+    projectPath: string;
+    version: string;
+    kind: WorkspaceSymbolKind;
+    name: string;
+    owner?: string;
+    descriptor?: string;
+    sourceMapping: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
+};
+export type ResolveWorkspaceSymbolOutput = MappingSymbolResolutionOutput & {
+    workspaceDetection: WorkspaceCompileMappingOutput;
+};
+export type GetClassSourceInput = {
+    artifactId?: string;
+    target?: SourceTargetInput;
+    className: string;
+    mapping?: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
+    allowDecompile?: boolean;
+    startLine?: number;
+    endLine?: number;
+    maxLines?: number;
+};
+export type GetClassSourceOutput = {
+    className: string;
+    sourceText: string;
+    totalLines: number;
+    returnedRange: {
+        start: number;
+        end: number;
+    };
+    truncated: boolean;
+    origin: ResolvedSourceArtifact["origin"];
+    artifactId: string;
+    requestedMapping: SourceMapping;
+    mappingApplied: SourceMapping;
+    provenance: ArtifactProvenance;
+    qualityFlags: string[];
+    warnings: string[];
+};
+type MemberAccess = "public" | "all";
+export type GetClassMembersInput = {
+    artifactId?: string;
+    target?: SourceTargetInput;
+    className: string;
+    mapping?: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
+    allowDecompile?: boolean;
+    access?: MemberAccess;
+    includeSynthetic?: boolean;
+    includeInherited?: boolean;
+    memberPattern?: string;
+    maxMembers?: number;
+};
+export type GetClassMembersOutput = {
+    className: string;
+    members: {
+        constructors: SignatureMember[];
+        fields: SignatureMember[];
+        methods: SignatureMember[];
+    };
+    counts: {
+        constructors: number;
+        fields: number;
+        methods: number;
+        total: number;
+    };
+    truncated: boolean;
+    context: ExplorerResponseContext;
+    origin: ResolvedSourceArtifact["origin"];
+    artifactId: string;
+    requestedMapping: SourceMapping;
+    mappingApplied: SourceMapping;
+    provenance: ArtifactProvenance;
+    qualityFlags: string[];
+    warnings: string[];
+};
+export type TraceSymbolLifecycleInput = {
+    symbol: string;
+    descriptor?: string;
+    fromVersion?: string;
+    toVersion?: string;
+    mapping?: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
+    includeSnapshots?: boolean;
+    maxVersions?: number;
+    includeTimeline?: boolean;
+};
+export type TraceSymbolLifecycleTimelineEntry = {
+    version: string;
+    exists: boolean;
+    reason?: "class-not-found" | "descriptor-mismatch" | "unresolved";
+};
+export type TraceSymbolLifecycleOutput = {
+    query: {
+        className: string;
+        methodName: string;
+        descriptor?: string;
+        mapping: SourceMapping;
+    };
+    range: {
+        fromVersion: string;
+        toVersion: string;
+        scannedCount: number;
+    };
+    presence: {
+        firstSeen?: string;
+        lastSeen?: string;
+        missingBetween: string[];
+        existsNow: boolean;
+    };
+    timeline?: TraceSymbolLifecycleTimelineEntry[];
+    warnings: string[];
+};
+type DiffClassChange = "added" | "removed" | "present_in_both" | "absent_in_both";
+type DiffMemberChangedField = "accessFlags" | "isSynthetic" | "javaSignature" | "jvmDescriptor";
+export type DiffMember = SignatureMember;
+export type DiffMemberChange = {
+    key: string;
+    from: DiffMember;
+    to: DiffMember;
+    changed: DiffMemberChangedField[];
+};
+export type DiffClassMemberDelta = {
+    added: DiffMember[];
+    removed: DiffMember[];
+    modified: DiffMemberChange[];
+};
+export type DiffClassSignaturesInput = {
+    className: string;
+    fromVersion: string;
+    toVersion: string;
+    mapping?: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
+};
+export type DiffClassSignaturesOutput = {
+    query: {
+        className: string;
+        fromVersion: string;
+        toVersion: string;
+        mapping: SourceMapping;
+    };
+    range: {
+        fromVersion: string;
+        toVersion: string;
+    };
+    classChange: DiffClassChange;
+    constructors: DiffClassMemberDelta;
+    methods: DiffClassMemberDelta;
+    fields: DiffClassMemberDelta;
+    summary: {
+        constructors: {
+            added: number;
+            removed: number;
+            modified: number;
+        };
+        methods: {
+            added: number;
+            removed: number;
+            modified: number;
+        };
+        fields: {
+            added: number;
+            removed: number;
+            modified: number;
+        };
+        total: {
+            added: number;
+            removed: number;
+            modified: number;
+        };
+    };
+    warnings: string[];
+};
+export type IndexArtifactInput = {
+    artifactId: string;
+    force?: boolean;
+};
+type IndexRebuildReason = "force" | "missing_meta" | "schema_mismatch" | "signature_mismatch" | "already_current";
+export type IndexArtifactOutput = {
+    artifactId: string;
+    reindexed: boolean;
+    reason: IndexRebuildReason;
+    counts: {
+        files: number;
+        symbols: number;
+        ftsRows: number;
+    };
+    indexedAt: string;
+    durationMs: number;
+    mappingApplied: SourceMapping;
+};
+export type ValidateMixinInput = {
+    source: string;
+    version: string;
+    mapping?: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
+};
+export type ValidateMixinOutput = MixinValidationResult;
+export type ValidateAccessWidenerInput = {
+    content: string;
+    version: string;
+    mapping?: SourceMapping;
+    sourcePriority?: MappingSourcePriority;
+};
+export type ValidateAccessWidenerOutput = AccessWidenerValidationResult;
+export declare class SourceService {
+    private readonly config;
+    private readonly db;
+    private readonly artifactsRepo;
+    private readonly filesRepo;
+    private readonly indexMetaRepo;
+    private readonly symbolsRepo;
+    private readonly metrics;
+    private readonly versionService;
+    private readonly mappingService;
+    private readonly workspaceMappingService;
+    private readonly explorerService;
+    private readonly registryService;
+    private readonly versionDiffService;
+    private readonly modDecompileService;
+    private readonly modSearchService;
+    constructor(explicitConfig?: Config, metrics?: RuntimeMetrics);
+    resolveArtifact(input: ResolveArtifactInput): Promise<ResolveArtifactOutput>;
+    searchClassSource(input: SearchClassSourceInput): Promise<SearchClassSourceOutput>;
+    getArtifactFile(input: GetArtifactFileInput): Promise<GetArtifactFileOutput>;
+    listArtifactFiles(input: ListArtifactFilesInput): Promise<ListArtifactFilesOutput>;
+    listVersions(input?: ListVersionsInput): Promise<ListVersionsOutput>;
+    getRegistryData(input: GetRegistryDataInput): Promise<GetRegistryDataOutput>;
+    compareVersions(input: CompareVersionsInput): Promise<CompareVersionsOutput>;
+    decompileModJar(input: DecompileModJarInput): Promise<DecompileModJarOutput>;
+    getModClassSource(input: GetModClassSourceInput): Promise<GetModClassSourceOutput>;
+    searchModSource(input: SearchModSourceInput): Promise<SearchModSourceOutput>;
+    findMapping(input: FindMappingInput): Promise<FindMappingOutput>;
+    resolveMethodMappingExact(input: ResolveMethodMappingExactInput): Promise<ResolveMethodMappingExactOutput>;
+    getClassApiMatrix(input: GetClassApiMatrixInput): Promise<GetClassApiMatrixOutput>;
+    checkSymbolExists(input: CheckSymbolExistsInput): Promise<CheckSymbolExistsOutput>;
+    resolveWorkspaceSymbol(input: ResolveWorkspaceSymbolInput): Promise<ResolveWorkspaceSymbolOutput>;
+    traceSymbolLifecycle(input: TraceSymbolLifecycleInput): Promise<TraceSymbolLifecycleOutput>;
+    diffClassSignatures(input: DiffClassSignaturesInput): Promise<DiffClassSignaturesOutput>;
+    getClassSource(input: GetClassSourceInput): Promise<GetClassSourceOutput>;
+    getClassMembers(input: GetClassMembersInput): Promise<GetClassMembersOutput>;
+    validateMixin(input: ValidateMixinInput): Promise<ValidateMixinOutput>;
+    validateAccessWidener(input: ValidateAccessWidenerInput): Promise<ValidateAccessWidenerOutput>;
+    getRuntimeMetrics(): RuntimeMetricSnapshot;
+    indexArtifact(input: IndexArtifactInput): Promise<IndexArtifactOutput>;
+    private searchSymbolIntent;
+    private searchTextIntentIndexed;
+    private searchPathIntentIndexed;
+    private searchTextIntent;
+    private searchPathIntent;
+    private findSymbolHits;
+    private loadScopedFilePaths;
+    private indexedCandidateLimit;
+    private indexedCandidateLimitForMatch;
+    private resolveClassFilePath;
+    private findNearestSymbolForLine;
+    private findNearestSymbolFromList;
+    private buildOneHopRelations;
+    private buildProvenance;
+    private buildFallbackProvenance;
+    private resolveToOfficialClassName;
+    private resolveToOfficialMemberName;
+    private remapSignatureMembers;
+    private fallbackArtifactSignature;
+    private resolveIndexRebuildReason;
+    private toResolvedArtifact;
+    private rebuildAndPersistArtifactIndex;
+    private buildRebuiltArtifactData;
+    getArtifact(artifactId: string): ArtifactRow;
+    private ingestIfNeeded;
+    private loadFromSourceJar;
+    private hasAnyFiles;
+    private enforceCacheLimits;
+    private refreshCacheMetrics;
+}
+export {};