ragcode-context-engine 0.1.0

package/dist/src/retrieval/query-matching.d.ts

@@ -0,0 +1,22 @@
+import type { CodeChunk, SymbolNode } from "../core/types.js";
+export interface QueryMatchProfile {
+    queryTerms: string[];
+    queryTermVariants: string[];
+    expandedTerms: string[];
+    expandedSymbolNames: string[];
+    ftsTerms: string[];
+}
+export interface TextMatchScore {
+    score: number;
+    matchedQueryTerms: number;
+    matchedExpandedTerms: number;
+    matchedSymbolName?: string;
+    reason: string;
+}
+export declare function buildQueryMatchProfile(query: string, symbols?: SymbolNode[]): QueryMatchProfile;
+export declare function scoreChunkText(chunk: CodeChunk, profile: QueryMatchProfile): TextMatchScore | undefined;
+export declare function scoreSymbolText(symbol: SymbolNode, profile: QueryMatchProfile): TextMatchScore | undefined;
+export declare function tokenizeQuery(query: string): string[];
+export declare function splitIdentifier(value: string): string[];
+export declare function normalizeIdentifier(value: string): string;
+export declare function textContainsTerm(text: string, term: string): boolean;

package/dist/src/retrieval/query-matching.js

@@ -0,0 +1,166 @@
+import snowball from "snowball-stemmers";
+const englishStemmer = snowball.newStemmer("english");
+export function buildQueryMatchProfile(query, symbols = []) {
+    const queryTerms = tokenizeQuery(query);
+    const queryTermVariants = expandTermVariants(queryTerms);
+    const expandedSymbolNames = matchingSymbolNames(queryTermVariants, symbols);
+    const expandedTerms = [...new Set(expandedSymbolNames.map(normalizeIdentifier).filter(Boolean))];
+    return {
+        queryTerms,
+        queryTermVariants,
+        expandedTerms,
+        expandedSymbolNames,
+        ftsTerms: [...new Set([...queryTerms, ...expandedTerms])]
+    };
+}
+export function scoreChunkText(chunk, profile) {
+    const text = searchableChunkText(chunk);
+    const matchedQueryTerms = countQueryTermMatches(text, profile.queryTerms);
+    const matchedExpandedTerms = countMatches(text, profile.expandedTerms);
+    const symbolScore = chunk.symbolName ? scoreSymbolName(chunk.symbolName, profile.queryTermVariants) : undefined;
+    if (matchedQueryTerms === 0 && matchedExpandedTerms === 0 && !symbolScore)
+        return undefined;
+    const queryCoverage = profile.queryTerms.length > 0 ? matchedQueryTerms / profile.queryTerms.length : 0;
+    const expansionScore = Math.min(0.45, matchedExpandedTerms * 0.15);
+    const symbolBoost = symbolScore ? 0.85 * symbolScore.coverage : 0;
+    const reasons = [`Matched ${matchedQueryTerms}/${profile.queryTerms.length} query term(s)`];
+    if (symbolScore)
+        reasons.push(`symbol expansion matched ${symbolScore.name}`);
+    else if (matchedExpandedTerms > 0)
+        reasons.push(`matched ${matchedExpandedTerms} expanded symbol term(s)`);
+    return {
+        score: queryCoverage + expansionScore + symbolBoost,
+        matchedQueryTerms,
+        matchedExpandedTerms,
+        matchedSymbolName: symbolScore?.name,
+        reason: reasons.join("; ")
+    };
+}
+export function scoreSymbolText(symbol, profile) {
+    const text = searchableSymbolText(symbol);
+    const matchedQueryTerms = countQueryTermMatches(text, profile.queryTerms);
+    const matchedExpandedTerms = countMatches(text, profile.expandedTerms);
+    const symbolScore = scoreSymbolName(symbol.name, profile.queryTermVariants);
+    if (matchedQueryTerms === 0 && matchedExpandedTerms === 0 && !symbolScore)
+        return undefined;
+    const queryCoverage = profile.queryTerms.length > 0 ? matchedQueryTerms / profile.queryTerms.length : 0;
+    const symbolBoost = symbolScore ? 1.2 * symbolScore.coverage : 0;
+    const expansionScore = Math.min(0.4, matchedExpandedTerms * 0.15);
+    return {
+        score: queryCoverage + symbolBoost + expansionScore,
+        matchedQueryTerms,
+        matchedExpandedTerms,
+        matchedSymbolName: symbolScore?.name,
+        reason: symbolScore ? `Symbol expansion match: ${symbol.name}` : `Symbol match: ${symbol.name}`
+    };
+}
+export function tokenizeQuery(query) {
+    const tokens = [];
+    for (const rawPart of query.split(/[^a-z0-9_./:-]+/i)) {
+        const part = rawPart.trim();
+        if (!part)
+            continue;
+        tokens.push(part.toLowerCase());
+        if (isCamelOrPascalIdentifier(part))
+            tokens.push(...splitIdentifier(part));
+    }
+    return [...new Set(tokens)];
+}
+export function splitIdentifier(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+        .split(/[^a-z0-9]+/i)
+        .map((part) => part.trim().toLowerCase())
+        .filter(Boolean);
+}
+export function normalizeIdentifier(value) {
+    return splitIdentifier(value).join("");
+}
+export function textContainsTerm(text, term) {
+    if (!term)
+        return false;
+    if (!/^[a-z0-9]+$/i.test(term))
+        return text.includes(term.toLowerCase());
+    const escaped = term.toLowerCase().replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pluralPattern = term.endsWith("y")
+        ? `(?:${escaped}|${term.slice(0, -1).toLowerCase().replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}ies)`
+        : `${escaped}(?:s|es)?`;
+    return new RegExp(`(^|[^a-z0-9])${pluralPattern}([^a-z0-9]|$)`).test(text);
+}
+function isCamelOrPascalIdentifier(value) {
+    return !/[._/:-]/.test(value) && /(?:[a-z0-9][A-Z]|[A-Z]{2,}[a-z])/.test(value);
+}
+function searchableChunkText(chunk) {
+    return searchableText([chunk.filePath, chunk.symbolName, chunk.content]);
+}
+function searchableSymbolText(symbol) {
+    return searchableText([symbol.name, symbol.filePath, symbol.signature]);
+}
+function searchableText(parts) {
+    const raw = parts.filter(Boolean).join("\n");
+    return `${raw}\n${splitIdentifier(raw).join(" ")}`.toLowerCase();
+}
+function matchingSymbolNames(queryTermVariants, symbols) {
+    const queryTerms = new Set(queryTermVariants);
+    const matches = [];
+    for (const symbol of symbols) {
+        if (symbol.kind === "file")
+            continue;
+        const parts = splitIdentifier(symbol.name);
+        if (parts.length < 2)
+            continue;
+        const variants = parts.map((part) => expandTermVariants([part]));
+        const matchedParts = variants.filter((partVariants) => partVariants.some((part) => queryTerms.has(part))).length;
+        const requiredParts = Math.min(2, parts.length);
+        if (matchedParts < requiredParts)
+            continue;
+        matches.push({ name: symbol.name, score: matchedParts / parts.length });
+    }
+    return [...new Map(matches
+            .sort((a, b) => b.score - a.score || a.name.localeCompare(b.name))
+            .slice(0, 48)
+            .map((match) => [match.name, match.name])).values()];
+}
+function scoreSymbolName(name, queryTermVariants) {
+    const queryTerms = new Set(queryTermVariants);
+    const parts = splitIdentifier(name);
+    if (parts.length < 2)
+        return undefined;
+    const matchedParts = parts.filter((part) => expandTermVariants([part]).some((variant) => queryTerms.has(variant))).length;
+    const requiredParts = Math.min(2, parts.length);
+    if (matchedParts < requiredParts)
+        return undefined;
+    return { name, coverage: matchedParts / parts.length };
+}
+function expandTermVariants(terms) {
+    const variants = new Set();
+    for (const term of terms) {
+        variants.add(term);
+        const stem = stemTerm(term);
+        if (stem && stem !== term)
+            variants.add(stem);
+    }
+    return [...variants];
+}
+function stemTerm(term) {
+    if (!/^[a-z]+$/i.test(term))
+        return undefined;
+    return englishStemmer.stem(term.toLowerCase());
+}
+function countMatches(text, terms) {
+    let count = 0;
+    for (const term of terms) {
+        if (textContainsTerm(text, term))
+            count += 1;
+    }
+    return count;
+}
+function countQueryTermMatches(text, terms) {
+    let count = 0;
+    for (const term of terms) {
+        if (expandTermVariants([term]).some((variant) => textContainsTerm(text, variant)))
+            count += 1;
+    }
+    return count;
+}

package/dist/src/retrieval/query-planner.d.ts

@@ -0,0 +1,5 @@
+import type { ContextMode, SearchHit } from "../core/types.js";
+export type ResolvedContextMode = Exclude<ContextMode, "auto">;
+export declare function resolveContextMode(query: string, explicit: ContextMode | undefined): ResolvedContextMode;
+export declare function applyModeBoost(hit: SearchHit, mode: ResolvedContextMode, query?: string): SearchHit;
+export declare function nextQueriesForMode(query: string, mode: ResolvedContextMode): string[];

package/dist/src/retrieval/query-planner.js

@@ -0,0 +1,77 @@
+import { classifyEvidencePath, isExplicitSupportingEvidenceQuery } from "./path-classification.js";
+const MODE_KEYWORDS = {
+    debug: ["error", "bug", "fail", "failure", "stack", "trace", "exception", "crash", "log", "fix"],
+    feature: ["add", "create", "implement", "feature", "ui", "api", "route", "flow"],
+    refactor: ["refactor", "cleanup", "rename", "move", "simplify", "replace", "migrate"],
+    review: ["review", "diff", "risk", "regression", "test", "pr"],
+    explain: ["explain", "how", "why", "architecture", "overview", "onboard", "understand"]
+};
+export function resolveContextMode(query, explicit) {
+    if (explicit && explicit !== "auto")
+        return explicit;
+    const queryTokens = new Set(query.toLowerCase().split(/[^a-z0-9]+/i).filter(Boolean));
+    let best = { mode: "explain", score: 0 };
+    for (const [mode, words] of Object.entries(MODE_KEYWORDS)) {
+        const score = words.filter((word) => queryTokens.has(word)).length;
+        if (score > best.score)
+            best = { mode, score };
+    }
+    return best.mode;
+}
+export function applyModeBoost(hit, mode, query = "") {
+    const text = `${hit.chunk.filePath}\n${hit.chunk.symbolName ?? ""}\n${hit.chunk.content}`.toLowerCase();
+    const explicitSupportingQuery = isExplicitSupportingEvidenceQuery(query);
+    const evidenceKind = classifyEvidencePath(hit.chunk.filePath);
+    let boost = 0;
+    if (mode === "debug") {
+        boost += containsAny(text, ["error", "catch", "throw", "log", "trace", "exception"]) ? 0.35 : 0;
+    }
+    else if (mode === "feature") {
+        boost += containsAny(text, ["route", "handler", "component", "service", "controller", "store"]) ? 0.3 : 0;
+    }
+    else if (mode === "refactor") {
+        boost += containsAny(text, ["export", "interface", "type", "class", "function"]) ? 0.25 : 0;
+    }
+    else if (mode === "review") {
+        boost += containsAny(text, ["test", "spec", "assert", "expect", "mock"]) ? 0.3 : 0;
+    }
+    else if (mode === "explain") {
+        boost += containsAny(text, ["readme", "architecture", "index", "main", "server"]) ? 0.2 : 0;
+    }
+    if ((mode === "feature" || mode === "refactor" || mode === "explain") && !explicitSupportingQuery) {
+        if (evidenceKind === "implementation") {
+            boost += 0.25;
+        }
+        else {
+            const penalty = evidenceKind === "test" ? 0.65 : 0.55;
+            boost -= penalty;
+        }
+    }
+    if (boost === 0)
+        return hit;
+    const score = Math.max(0, hit.score + boost);
+    return {
+        ...hit,
+        score,
+        scoreBreakdown: {
+            ...hit.scoreBreakdown,
+            modeBoost: (hit.scoreBreakdown?.modeBoost ?? 0) + boost,
+            final: score
+        },
+        reason: `${hit.reason}; ${mode} mode boost`
+    };
+}
+export function nextQueriesForMode(query, mode) {
+    if (mode === "debug")
+        return [`owner chain for ${query}`, `related tests for ${query}`, `error handling around ${query}`];
+    if (mode === "feature")
+        return [`entry points for ${query}`, `state and API owners for ${query}`, `tests for ${query}`];
+    if (mode === "refactor")
+        return [`callers of ${query}`, `impact analysis for ${query}`, `public exports for ${query}`];
+    if (mode === "review")
+        return [`changed files impact`, `related tests`, `risk hotspots`];
+    return [`module overview for ${query}`, `key symbols for ${query}`, `main execution flow for ${query}`];
+}
+function containsAny(text, needles) {
+    return needles.some((needle) => text.includes(needle));
+}

package/dist/src/retrieval/ranking-signals.d.ts

@@ -0,0 +1,19 @@
+import type { EdgeKind, SearchHit } from "../core/types.js";
+import type { ResolvedContextMode } from "./query-planner.js";
+import type { TopologyDistance } from "./topology-distance.js";
+export interface RankingSignalInput {
+    hit: SearchHit;
+    mode: ResolvedContextMode;
+    query: string;
+    distance?: TopologyDistance;
+    hasStructuralSeeds: boolean;
+}
+export interface RankingSignalResult {
+    score: number;
+    adjustment: number;
+    reason?: string;
+}
+export declare function applyRankingSignals(input: RankingSignalInput): RankingSignalResult;
+export declare function graphProximityScore(hops: number): number;
+export declare function edgeKindBoost(kinds: EdgeKind[]): number;
+export declare function edgeKindWeight(kind: EdgeKind): number;

package/dist/src/retrieval/ranking-signals.js

@@ -0,0 +1,97 @@
+import { classifyEvidencePath, isExplicitTestQuery, isTestPath } from "./path-classification.js";
+export function applyRankingSignals(input) {
+    const reasons = [];
+    let adjustment = 0;
+    const distance = primaryDistanceFor(input);
+    if (distance) {
+        const proximity = graphProximityScore(distance.hops) * 1.6;
+        const edgeBoost = edgeKindBoost(distance.edgeKinds);
+        adjustment += proximity + edgeBoost;
+        reasons.push(graphReason(distance, proximity + edgeBoost));
+    }
+    else if (input.hasStructuralSeeds && disconnectedPenaltyApplies(input.hit)) {
+        const penalty = isTestPath(input.hit.chunk.filePath) ? 0.15 : 0.25;
+        adjustment -= penalty;
+        reasons.push(`graph disconnected from structural seeds (-${penalty.toFixed(2)})`);
+    }
+    const testAdjustment = testModeAdjustment(input);
+    if (testAdjustment !== 0) {
+        adjustment += testAdjustment;
+        reasons.push(testAdjustment > 0
+            ? `test relevance boost (+${testAdjustment.toFixed(2)})`
+            : `test default demotion (${testAdjustment.toFixed(2)})`);
+    }
+    return {
+        score: Math.max(0, input.hit.score + adjustment),
+        adjustment,
+        reason: reasons.length > 0 ? `graph rerank: ${reasons.join("; ")}` : undefined
+    };
+}
+export function graphProximityScore(hops) {
+    if (hops <= 0)
+        return 1;
+    if (hops === 1)
+        return 0.82;
+    if (hops === 2)
+        return 0.52;
+    if (hops === 3)
+        return 0.24;
+    return 0;
+}
+export function edgeKindBoost(kinds) {
+    if (kinds.length === 0)
+        return 0;
+    return Math.max(...kinds.map(edgeKindWeight)) * 0.42;
+}
+export function edgeKindWeight(kind) {
+    if (kind === "calls" || kind === "calls_api" || kind === "routes_to" || kind === "handles_event" || kind === "handles_webhook")
+        return 1;
+    if (kind === "tested_by")
+        return 0.9;
+    if (kind === "uses_middleware")
+        return 0.85;
+    if (kind === "imports" || kind === "exports")
+        return 0.75;
+    if (kind === "reads_from" || kind === "writes_to" || kind === "references")
+        return 0.55;
+    if (kind === "contains")
+        return 0.2;
+    return 0.15;
+}
+function graphReason(distance, boost) {
+    if (distance.hops === 0) {
+        const via = unique(distance.edgeKinds).slice(0, 2).join("/");
+        return via ? `structural seed via ${via} (+${boost.toFixed(2)})` : `structural seed (+${boost.toFixed(2)})`;
+    }
+    const via = unique(distance.edgeKinds).slice(0, 3).join("/");
+    return `graph proximity ${distance.hops} hop${distance.hops === 1 ? "" : "s"}${via ? ` via ${via}` : ""} (+${boost.toFixed(2)})`;
+}
+function testModeAdjustment(input) {
+    if (!isTestPath(input.hit.chunk.filePath))
+        return 0;
+    const explicitTestQuery = isExplicitTestQuery(input.query);
+    if ((input.mode === "review" || input.mode === "debug" || explicitTestQuery) && input.distance)
+        return 0.45;
+    if (!explicitTestQuery && input.mode !== "review" && input.mode !== "debug")
+        return -0.25;
+    return 0;
+}
+function primaryDistanceFor(input) {
+    if (!input.distance)
+        return undefined;
+    if (!isTestPath(input.hit.chunk.filePath))
+        return input.distance;
+    if (input.mode === "review" || input.mode === "debug" || isExplicitTestQuery(input.query))
+        return input.distance;
+    return undefined;
+}
+function disconnectedPenaltyApplies(hit) {
+    if (classifyEvidencePath(hit.chunk.filePath) !== "implementation")
+        return true;
+    if (hit.chunk.language === "markdown" || hit.chunk.language === "json")
+        return true;
+    return hit.source === "semantic" || hit.source === "keyword";
+}
+function unique(values) {
+    return [...new Set(values)];
+}

package/dist/src/retrieval/topology-distance.d.ts

@@ -0,0 +1,21 @@
+import type { EdgeKind, GraphEdge, SymbolNode } from "../core/types.js";
+export interface FileNeighbor {
+    filePath: string;
+    kind: EdgeKind;
+}
+export interface FileGraph {
+    adjacency: Map<string, FileNeighbor[]>;
+    incidentKinds: Map<string, EdgeKind[]>;
+}
+export interface TopologyDistance {
+    hops: number;
+    edgeKinds: EdgeKind[];
+    path: string[];
+}
+export interface TopologyDistanceOptions {
+    projectId?: string;
+    maxHops?: number;
+}
+export declare function buildFileGraph(symbols: SymbolNode[], edges: GraphEdge[], projectId?: string): FileGraph;
+export declare function computeTopologyDistances(graph: FileGraph, seedFiles: string[], candidateFiles: Iterable<string>, options?: TopologyDistanceOptions): Map<string, TopologyDistance>;
+export declare function graphDegree(graph: FileGraph, filePath: string): number;

package/dist/src/retrieval/topology-distance.js

@@ -0,0 +1,116 @@
+export function buildFileGraph(symbols, edges, projectId) {
+    const scopedSymbols = projectId ? symbols.filter((symbol) => symbol.projectId === projectId) : symbols;
+    const symbolById = new Map(scopedSymbols.map((symbol) => [symbol.id, symbol]));
+    const adjacency = new Map();
+    const incidentKinds = new Map();
+    for (const edge of edges) {
+        if (projectId && edge.projectId !== projectId)
+            continue;
+        const sourceFile = endpointFile(edge, symbolById, "source");
+        const targetFile = endpointFile(edge, symbolById, "target");
+        if (!sourceFile && !targetFile)
+            continue;
+        if (sourceFile)
+            addIncidentKind(incidentKinds, sourceFile, edge.kind);
+        if (targetFile)
+            addIncidentKind(incidentKinds, targetFile, edge.kind);
+        if (!sourceFile || !targetFile || sourceFile === targetFile)
+            continue;
+        addNeighbor(adjacency, sourceFile, { filePath: targetFile, kind: edge.kind });
+        addNeighbor(adjacency, targetFile, { filePath: sourceFile, kind: edge.kind });
+    }
+    return { adjacency, incidentKinds };
+}
+export function computeTopologyDistances(graph, seedFiles, candidateFiles, options = {}) {
+    const maxHops = options.maxHops ?? 3;
+    const candidates = new Set(candidateFiles);
+    const distances = new Map();
+    const visited = new Map();
+    const queue = [];
+    for (const filePath of unique(seedFiles)) {
+        if (!graph.incidentKinds.has(filePath) && !graph.adjacency.has(filePath))
+            continue;
+        const seedDistance = {
+            hops: 0,
+            edgeKinds: strongestKinds(graph.incidentKinds.get(filePath) ?? []),
+            path: [filePath]
+        };
+        visited.set(filePath, seedDistance);
+        queue.push(seedDistance);
+        if (candidates.has(filePath))
+            distances.set(filePath, seedDistance);
+    }
+    for (let cursor = 0; cursor < queue.length; cursor += 1) {
+        const current = queue[cursor];
+        const currentFile = current.path[current.path.length - 1];
+        if (!currentFile || current.hops >= maxHops)
+            continue;
+        for (const neighbor of graph.adjacency.get(currentFile) ?? []) {
+            const nextDistance = {
+                hops: current.hops + 1,
+                edgeKinds: [...current.edgeKinds, neighbor.kind],
+                path: [...current.path, neighbor.filePath]
+            };
+            const existing = visited.get(neighbor.filePath);
+            if (existing && compareDistance(existing, nextDistance) <= 0)
+                continue;
+            visited.set(neighbor.filePath, nextDistance);
+            queue.push(nextDistance);
+            if (candidates.has(neighbor.filePath))
+                distances.set(neighbor.filePath, nextDistance);
+        }
+    }
+    return distances;
+}
+export function graphDegree(graph, filePath) {
+    return (graph.adjacency.get(filePath)?.length ?? 0) + (graph.incidentKinds.get(filePath)?.length ?? 0);
+}
+function endpointFile(edge, symbolById, endpoint) {
+    const symbol = symbolById.get(endpoint === "source" ? edge.sourceId : edge.targetId);
+    if (symbol)
+        return symbol.filePath;
+    const metadataKey = endpoint === "source" ? "sourceFile" : "targetFile";
+    const metadataValue = edge.metadata?.[metadataKey];
+    return typeof metadataValue === "string" ? metadataValue : undefined;
+}
+function addNeighbor(adjacency, from, neighbor) {
+    const neighbors = adjacency.get(from) ?? [];
+    if (!neighbors.some((existing) => existing.filePath === neighbor.filePath && existing.kind === neighbor.kind)) {
+        neighbors.push(neighbor);
+        adjacency.set(from, neighbors);
+    }
+}
+function addIncidentKind(incidentKinds, filePath, kind) {
+    const kinds = incidentKinds.get(filePath) ?? [];
+    if (!kinds.includes(kind)) {
+        kinds.push(kind);
+        incidentKinds.set(filePath, kinds);
+    }
+}
+function compareDistance(a, b) {
+    if (a.hops !== b.hops)
+        return a.hops - b.hops;
+    return maxEdgeWeight(b.edgeKinds) - maxEdgeWeight(a.edgeKinds);
+}
+function maxEdgeWeight(kinds) {
+    return Math.max(0, ...kinds.map(edgeKindStrength));
+}
+function strongestKinds(kinds) {
+    return [...kinds].sort((a, b) => edgeKindStrength(b) - edgeKindStrength(a)).slice(0, 3);
+}
+function edgeKindStrength(kind) {
+    if (kind === "calls" || kind === "calls_api" || kind === "routes_to" || kind === "handles_event" || kind === "handles_webhook")
+        return 1;
+    if (kind === "uses_middleware")
+        return 0.9;
+    if (kind === "imports" || kind === "exports" || kind === "tested_by")
+        return 0.8;
+    if (kind === "reads_from" || kind === "writes_to" || kind === "references")
+        return 0.6;
+    if (kind === "contains")
+        return 0.25;
+    return 0.2;
+}
+function unique(values) {
+    return [...new Set(values)];
+}

package/dist/src/reuse/reuse-detector.d.ts

@@ -0,0 +1,12 @@
+import type { CodeChunk, GraphEdge, OwnerCandidate, ReuseCandidateReport, SearchHit, SymbolNode } from "../core/types.js";
+export interface ReuseDetectorInput {
+    query: string;
+    hits: SearchHit[];
+    owners: OwnerCandidate[];
+    symbols: SymbolNode[];
+    edges: GraphEdge[];
+    chunks: CodeChunk[];
+    limit?: number;
+    reuseGuard?: boolean;
+}
+export declare function buildReuseCandidateReport(input: ReuseDetectorInput): ReuseCandidateReport;