cgraphx 1.4.1 → 2.0.0

package/dist/search/impact.js

@@ -1,646 +0,0 @@
-"use strict";
-/**
- * Impact analysis — transitive callers + type references for a method.
- *
- * Spec input (per `docs/features/2026-07-01-impact-command/spec.md`, drafted
- * from clarify-requirements):
- *   - Replace the existing indexed-DB `cgraphx impact` command (CLI surface only;
- *     the graph API `CodeGraph.getImpactRadius` stays for the MCP server until
- *     that's separately deprecated).
- *   - Input: `Class#method` or `file:line` (same as `calls --from`).
- *   - Output: transitive callers (BFS up to depth N) + type references to the
- *     enclosing class (import / extends / implements / field / param / local /
- *     cast / annotation / generic). All SNR-ranked, tiered-budget output.
- *
- * Isolation: lives entirely under `src/search/`, imports nothing from
- * `src/graph/`, `src/resolution/`, `src/db/`, `src/mcp/`, or `src/extraction/`
- * (beyond the grammar loader). When the indexed pipeline is eventually removed,
- * this file is untouched.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.searchCallSites = void 0;
-exports.computeImpactCallSiteSnr = computeImpactCallSiteSnr;
-exports.computeImpactSnrBreakdown = computeImpactSnrBreakdown;
-exports.searchImpact = searchImpact;
-exports.applyImpactTieredBudget = applyImpactTieredBudget;
-exports.formatImpactResult = formatImpactResult;
-const fs_1 = require("fs");
-const path = __importStar(require("path"));
-const grammars_1 = require("../extraction/grammars");
-const call_sites_1 = require("./call-sites");
-const ast_helpers_1 = require("./ast-helpers");
-// Re-export for callers-mode reuse
-var call_sites_2 = require("./call-sites");
-Object.defineProperty(exports, "searchCallSites", { enumerable: true, get: function () { return call_sites_2.searchCallSites; } });
-// ---------------------------------------------------------------------------
-// SNR scoring for type references
-// ---------------------------------------------------------------------------
-/**
- * SNR score a type reference. The signal here is "how directly does this
- * reference propagate a change to the method".
- *
- *   extends/implements  → +50  (subclass MUST implement/inherit the method)
- *   field               → +35  (field is reached via the method's class)
- *   param/local/return  → +25  (typed usage; method change might affect callers)
- *   annotation          → +20  (annotation processor might break)
- *   cast                → +15  (runtime cast; weakly affected)
- *   generic             → +10  (e.g. List<Foo>; least affected by method change)
- *   import              → +5   (might be unused or fully unrelated)
- *   other               → +10
- */
-function computeTypeRefSnr(ref) {
-    switch (ref.kind) {
-        case 'extends': return 50;
-        case 'implements': return 50;
-        case 'field': return 35;
-        case 'param': return 25;
-        case 'local': return 25;
-        case 'return': return 25;
-        case 'annotation': return 20;
-        case 'cast': return 15;
-        case 'generic': return 10;
-        case 'import': return 5;
-        case 'other': return 10;
-    }
-}
-/**
- * SNR score a transitive caller. Reuses computeSnrScore for the call-site
- * itself, then applies hop-distance decay (hop 1 = 1.0, hop 2 = 0.6,
- * hop 3 = 0.36, ...). Direct callers always outrank indirect ones.
- */
-function computeImpactCallSiteSnr(site) {
-    const base = (0, call_sites_1.computeSnrScore)(site);
-    const decay = Math.pow(0.6, site.hopDistance - 1);
-    return Math.round(base * decay);
-}
-function computeImpactSnrBreakdown(site) {
-    const baseBd = (0, call_sites_1.computeSnrBreakdown)(site);
-    const decayMultiplier = Math.pow(0.6, site.hopDistance - 1);
-    return {
-        base: baseBd.total,
-        decayMultiplier,
-        total: Math.round(baseBd.total * decayMultiplier),
-        matchedRules: baseBd.matchedRules,
-        receiver: baseBd.receiver,
-        method: baseBd.method,
-    };
-}
-/**
- * Format an impact SNR breakdown for the `--explain` flag. Hop 1 (decay 1.0)
- * collapses to the plain breakdown; deeper hops show `base × decay = total`.
- */
-function formatImpactSnrBreakdown(site) {
-    const bd = computeImpactSnrBreakdown(site);
-    // At hop 1 (decay 1.0) the base equals the total, so the multiplier is
-    // noise — show the plain call-site breakdown instead.
-    if (site.hopDistance === 1) {
-        return (0, call_sites_1.formatSnrBreakdown)(site);
-    }
-    // Deeper hops: strip the trailing `= <total>` from the call-site breakdown
-    // (that's the pre-decay base) and append the hop multiplier.
-    const baseFull = (0, call_sites_1.formatSnrBreakdown)(site);
-    const baseStr = baseFull.replace(/\s*=\s*-?\d+$/, '').trim();
-    const decayPct = `${Math.round(bd.decayMultiplier * 100)}%`;
-    return `${baseStr} × ${decayPct} hop${site.hopDistance} = ${bd.total}`;
-}
-// ---------------------------------------------------------------------------
-// Main entry
-// ---------------------------------------------------------------------------
-async function searchImpact(projectRoot, symbol, options = {}) {
-    const { depth = 2, topPerHop = 20, topTypeRefs = 15, budget = 6000, languages = ['java', 'kotlin'], excludeDirs = [], } = options;
-    await (0, grammars_1.loadGrammarsForLanguages)(languages);
-    const excludeSet = new Set([...call_sites_1.DEFAULT_EXCLUDE_DIRS, ...excludeDirs]);
-    // 1. Resolve symbol → method_declaration AST node + enclosing class name
-    const resolved = await (0, call_sites_1.resolveMethodSymbol)(projectRoot, symbol, languages);
-    const classNode = (0, call_sites_1.findEnclosingClassType)(resolved.methodNode);
-    const enclosingClass = classNode?.childForFieldName('name')?.text ??
-        resolved.methodQualifiedName.split('#')[0] ??
-        null;
-    // 2. BFS transitive callers
-    const { callers, depthReached } = await findTransitiveCallers(projectRoot, {
-        methodName: resolved.methodNode.childForFieldName('name')?.text ?? '',
-        className: enclosingClass ?? '',
-        filePath: resolved.file,
-        methodNode: resolved.methodNode,
-    }, depth, { topPerHop, languages, excludeDirs: excludeSet });
-    // 3. Type references scan (only if we resolved an enclosing class)
-    const typeReferences = enclosingClass
-        ? await scanTypeReferences(projectRoot, enclosingClass, languages, excludeSet)
-        : [];
-    // 4. SNR scoring
-    for (const c of callers) {
-        c.snrScore = computeImpactCallSiteSnr(c);
-    }
-    for (const r of typeReferences) {
-        r.snrScore = computeTypeRefSnr(r);
-    }
-    // 5. Sort + top-K
-    callers.sort(compareByImpactSnr);
-    const callersKept = callers.slice(0, topPerHop * Math.max(depthReached, 1));
-    const callersPrunedByTopPerHop = callers.length - callersKept.length;
-    typeReferences.sort((a, b) => b.snrScore - a.snrScore || a.line - b.line);
-    const typeRefsKept = typeReferences.slice(0, topTypeRefs);
-    const typeRefsPrunedByTopK = typeReferences.length - typeRefsKept.length;
-    // 6. Tiered budget — two-list allocation: callers first, then type refs
-    const { tieredCallers, tieredTypeRefs, truncatedByBudget } = applyImpactTieredBudget(callersKept, typeRefsKept, budget, { forceRecommended: options.withSnippet ?? false, forceOptional: options.full ?? false });
-    return {
-        symbol,
-        methodQualifiedName: resolved.methodQualifiedName,
-        enclosingClass,
-        filePath: path.relative(projectRoot, resolved.file).replace(/\\/g, '/'),
-        startLine: resolved.methodNode.startPosition.row + 1,
-        endLine: resolved.methodNode.endPosition.row + 1,
-        depthReached,
-        totalCallers: callers.length,
-        totalTypeRefFiles: new Set(typeReferences.map((r) => r.filePath)).size,
-        totalTypeRefs: typeReferences.length,
-        callers: tieredCallers,
-        typeReferences: tieredTypeRefs,
-        omitted: {
-            callersPrunedByTopPerHop,
-            typeRefsPrunedByTopK,
-            truncatedByBudget,
-        },
-    };
-}
-/**
- * BFS over callers. For each method, find all callsites via `searchCallSites`
- * (calls callers mode), then recurse on each unique containing method.
- *
- * Cycle detection: a visited Set<string> keyed `Class#method`. If a caller
- * is already visited, skip — prevents infinite loops on recursion (A calls B,
- * B calls A).
- *
- * The hop-level topK (`topPerHop`) caps how many callers we surface per hop
- * to bound the output. Lower-signal callers (noise) get pruned.
- */
-async function findTransitiveCallers(projectRoot, start, maxDepth, options) {
-    // Lazy import — searchCallSites pulls grammars, which we already loaded
-    const { searchCallSites } = await Promise.resolve().then(() => __importStar(require('./call-sites')));
-    const visited = new Set();
-    const visitedCallsites = new Set(); // dedup by `${filePath}:${line}`
-    const startKey = `${start.className}#${start.methodName}`;
-    visited.add(startKey);
-    // Queue carries className + methodName so we can filter searchCallSites
-    // results to only those whose containingClass matches — without this filter,
-    // common method names like `create` / `get` / `process` pull in hundreds of
-    // unrelated callsites and drown the BFS in noise (the method-name-ambiguity
-    // problem).
-    const queue = [
-        { methodName: start.methodName, expectedClass: start.className || null, hop: 0 },
-    ];
-    const allCallers = [];
-    let depthReached = 0;
-    while (queue.length > 0) {
-        const { methodName, expectedClass, hop } = queue.shift();
-        if (hop >= maxDepth)
-            continue;
-        depthReached = Math.max(depthReached, hop + 1);
-        // Find callers of methodName across the project
-        const result = await searchCallSites(projectRoot, methodName, {
-            languages: options.languages,
-            excludeDirs: [...options.excludeDirs],
-            topK: options.topPerHop * 2, // pull more, we'll filter + dedupe
-        });
-        // Filter to callsites whose containingClass matches what we expect — BUT
-        // only from hop 2 onwards. At hop 1 we want ALL callers of the start
-        // method (the start method's class doesn't constrain who calls it).
-        // From hop 2: each queued entry's expectedClass is the prior-hop caller's
-        // containingClass, so filtering keeps only callsites that live INSIDE
-        // that class — i.e., callers of that specific Class#method, not every
-        // method of the same name across the project. Without this, common names
-        // (`create`/`get`/`process`) pull in hundreds of unrelated callsites.
-        const filtered = (hop >= 1 && expectedClass)
-            ? result.callSites.filter((s) => s.containingClass === expectedClass)
-            : result.callSites;
-        // Pull top-K per hop. Dedupe by (filePath, line) across ALL hops — BFS
-        // can reach the same callsite via multiple paths (A→B→C and A→D→C both
-        // land on C), but we only want to surface C once at its shallowest hop.
-        // Also skip self-calls (callsite inside a method we've already visited
-        // from) — these are the method calling its own name on a different
-        // receiver (e.g., `orderClient.sceneCommit()` inside
-        // `CustomerOrderServiceImpl#sceneCommit`), not a real caller.
-        const takenThisHop = filtered.slice(0, options.topPerHop);
-        for (const site of takenThisHop) {
-            const callsiteKey = `${site.filePath}:${site.line}`;
-            if (visitedCallsites.has(callsiteKey))
-                continue;
-            const callerKey = site.containingClass && site.containingMethod
-                ? `${site.containingClass}#${site.containingMethod}`
-                : null;
-            if (callerKey && visited.has(callerKey))
-                continue; // self-call or already-covered
-            visitedCallsites.add(callsiteKey);
-            const impactSite = {
-                ...site,
-                hopDistance: hop + 1,
-            };
-            allCallers.push(impactSite);
-            // Recurse on each unique containing method (Class#method)
-            if (callerKey) {
-                visited.add(callerKey);
-                queue.push({
-                    methodName: site.containingMethod,
-                    expectedClass: site.containingClass,
-                    hop: hop + 1,
-                });
-            }
-        }
-    }
-    return { callers: allCallers, depthReached };
-}
-// ---------------------------------------------------------------------------
-// Type references scan
-// ---------------------------------------------------------------------------
-/**
- * Walk all source files looking for type_identifier nodes matching `className`.
- * For each match, classify the kind (extends/implements/field/param/...) by
- * looking at the AST parent chain.
- *
- * Fast text pre-filter: skip files that don't contain `className` as text.
- */
-async function scanTypeReferences(projectRoot, className, languages, excludeDirs) {
-    const refs = [];
-    const files = await (0, call_sites_1.listJavaFamilyFiles)(projectRoot, excludeDirs);
-    for (const file of files) {
-        let content;
-        try {
-            content = await fs_1.promises.readFile(file, 'utf-8');
-        }
-        catch {
-            continue;
-        }
-        // Fast text filter — most files won't mention this class
-        if (!content.includes(className))
-            continue;
-        const language = (0, grammars_1.detectLanguage)(file, content);
-        if (!languages.includes(language))
-            continue;
-        const parser = (0, grammars_1.getParser)(language);
-        if (!parser)
-            continue;
-        const tree = parser.parse(content);
-        if (!tree)
-            continue;
-        const relPath = path.relative(projectRoot, file).replace(/\\/g, '/');
-        (0, ast_helpers_1.walkTree)(tree.rootNode, (node) => {
-            // Java/Kotlin: type_identifier is the typical class-name node.
-            // Kotlin also uses 'user_type_name' in some contexts.
-            if (node.type !== 'type_identifier' && node.type !== 'user_type_name')
-                return;
-            if (node.text !== className)
-                return;
-            const kind = classifyTypeReference(node);
-            // For import statements, the type_identifier might be the LAST segment of
-            // a scoped_type_identifier — avoid double-counting by checking we're the
-            // last identifier in our parent chain.
-            if (kind === 'import' && isInnerSegmentOfScopedType(node))
-                return;
-            const { containingClass, containingMethod } = findEnclosingContext(node);
-            refs.push({
-                className,
-                filePath: relPath,
-                line: node.startPosition.row + 1,
-                column: node.startPosition.column,
-                kind,
-                containingClass,
-                containingMethod,
-                snippet: extractOneLine(content, node.startPosition.row),
-                snrScore: 0, // scored later
-            });
-        });
-    }
-    return refs;
-}
-/**
- * Classify a type_identifier reference by walking its parent chain.
- *
- * Tree-sitter-java AST shapes (verified empirically):
- *   import com.x.Foo;       — import_declaration > scoped_type_identifier > type_identifier
- *   class Bar extends Foo   — class_declaration > super_class > type_identifier
- *   class Bar implements F  — class_declaration > implements > interface_type_list > type_identifier
- *   private Foo foo;        — field_declaration > type > type_identifier
- *   void m(Foo x)           — formal_parameter > type > type_identifier
- *   Foo x = ...;            — local_variable_declaration > type > type_identifier
- *   (Foo) obj               — cast_expression > type > type_identifier
- *   List<Foo>               — generic_type > type_arguments > type_identifier
- *   @Foo                    — annotation > type_identifier (or qualified_name)
- *   Foo m()                 — method_declaration > type > type_identifier (return type)
- */
-function classifyTypeReference(node) {
-    // Walk up: look at parent and the closest "interesting" ancestor
-    let parent = node.parent;
-    // Direct parent checks first
-    if (parent?.type === 'annotation')
-        return 'annotation';
-    if (parent?.type === 'cast_expression')
-        return 'cast';
-    if (parent?.type === 'generic_type')
-        return 'generic';
-    // import_declaration ancestor
-    let p = node;
-    while (p) {
-        if (p.type === 'import_declaration')
-            return 'import';
-        p = p.parent;
-    }
-    // super_class / implements
-    if (parent?.type === 'super_class')
-        return 'extends';
-    if (parent?.type === 'super_interfaces' || parent?.type === 'interface_type_list')
-        return 'implements';
-    // type field of various declarations
-    if (parent?.type === 'type') {
-        const grand = parent.parent;
-        if (!grand)
-            return 'other';
-        switch (grand.type) {
-            case 'field_declaration': return 'field';
-            case 'formal_parameter': return 'param';
-            case 'local_variable_declaration':
-            case 'variable_declarator': return 'local';
-            case 'method_declaration': return 'return';
-            default: return 'other';
-        }
-    }
-    return 'other';
-}
-/**
- * True if this type_identifier is an inner segment of a scoped_type_identifier
- * (e.g., the `http` in `com.example.http.Client`). For import deduplication —
- * we only want the LAST type_identifier (the actual class name).
- */
-function isInnerSegmentOfScopedType(node) {
-    return node.parent?.type === 'scoped_type_identifier';
-}
-function findEnclosingContext(node) {
-    let containingClass = null;
-    let containingMethod = null;
-    let cur = node.parent;
-    while (cur) {
-        if (!containingClass && (cur.type === 'class_declaration' ||
-            cur.type === 'interface_declaration' ||
-            cur.type === 'enum_declaration' ||
-            cur.type === 'record_declaration')) {
-            const name = cur.childForFieldName('name')?.text ?? null;
-            if (name)
-                containingClass = name;
-        }
-        if (!containingMethod && (cur.type === 'method_declaration' ||
-            cur.type === 'constructor_declaration' ||
-            cur.type === 'compact_constructor_declaration')) {
-            const name = cur.childForFieldName('name')?.text ?? null;
-            if (name)
-                containingMethod = name;
-        }
-        if (containingClass && containingMethod)
-            break;
-        cur = cur.parent;
-    }
-    return { containingClass, containingMethod };
-}
-function extractOneLine(content, row) {
-    const lines = content.split('\n');
-    return (lines[row] ?? '').trim();
-}
-// ---------------------------------------------------------------------------
-// Sort + tiered budget
-// ---------------------------------------------------------------------------
-function compareByImpactSnr(a, b) {
-    const sa = a.snrScore ?? 0;
-    const sb = b.snrScore ?? 0;
-    if (sa !== sb)
-        return sb - sa;
-    // Lower hop distance first on tie (direct caller before indirect)
-    if (a.hopDistance !== b.hopDistance)
-        return a.hopDistance - b.hopDistance;
-    const da = a.filePath.split('/').length;
-    const db = b.filePath.split('/').length;
-    if (da !== db)
-        return da - db;
-    if (a.filePath !== b.filePath)
-        return a.filePath.localeCompare(b.filePath);
-    return a.line - b.line;
-}
-const TIER_ESSENTIAL_COST = 40;
-const TIER_RECOMMENDED_ADDITIONAL = 120;
-const TIER_OPTIONAL_ADDITIONAL = 400;
-/**
- * Two-list tiered budget: allocate budget across callers AND type references.
- * Callers get essential tier first (in SNR order), then type refs get essential
- * tier. If budget remains, recommended tier fills in SNR order across both
- * lists. Same for optional.
- */
-function applyImpactTieredBudget(callers, typeRefs, budget, opts = {}) {
-    // Pass 1: how many items fit at essential tier across both lists?
-    let count = 0;
-    let used = 0;
-    const total = callers.length + typeRefs.length;
-    for (let i = 0; i < total; i++) {
-        if (used + TIER_ESSENTIAL_COST > budget && count > 0)
-            break;
-        used += TIER_ESSENTIAL_COST;
-        count++;
-    }
-    const truncatedByBudget = total - count;
-    // Allocate essential slots in priority order: callers first (in SNR order),
-    // then type refs (in SNR order)
-    const callerCount = Math.min(callers.length, count);
-    const typeRefCount = Math.min(typeRefs.length, count - callerCount);
-    const tieredCallers = callers.slice(0, callerCount).map((c) => ({ ...c, tier: 'essential' }));
-    const tieredTypeRefs = typeRefs.slice(0, typeRefCount).map((r) => ({ ...r, tier: 'essential' }));
-    // Force flags short-circuit
-    if (opts.forceOptional) {
-        for (const c of tieredCallers)
-            c.tier = 'optional';
-        for (const r of tieredTypeRefs)
-            r.tier = 'optional';
-        return { tieredCallers, tieredTypeRefs, truncatedByBudget };
-    }
-    if (opts.forceRecommended) {
-        for (const c of tieredCallers)
-            c.tier = 'recommended';
-        for (const r of tieredTypeRefs)
-            r.tier = 'recommended';
-        return { tieredCallers, tieredTypeRefs, truncatedByBudget };
-    }
-    // Pass 2: upgrade to recommended in SNR order, callers first then type refs
-    let remaining = budget - used;
-    for (const c of tieredCallers) {
-        if (remaining >= TIER_RECOMMENDED_ADDITIONAL) {
-            c.tier = 'recommended';
-            remaining -= TIER_RECOMMENDED_ADDITIONAL;
-        }
-    }
-    for (const r of tieredTypeRefs) {
-        if (remaining >= TIER_RECOMMENDED_ADDITIONAL) {
-            r.tier = 'recommended';
-            remaining -= TIER_RECOMMENDED_ADDITIONAL;
-        }
-    }
-    // Pass 3: upgrade to optional
-    for (const c of tieredCallers) {
-        if (c.tier !== 'recommended')
-            continue;
-        if (remaining >= TIER_OPTIONAL_ADDITIONAL) {
-            c.tier = 'optional';
-            remaining -= TIER_OPTIONAL_ADDITIONAL;
-        }
-    }
-    for (const r of tieredTypeRefs) {
-        if (r.tier !== 'recommended')
-            continue;
-        if (remaining >= TIER_OPTIONAL_ADDITIONAL) {
-            r.tier = 'optional';
-            remaining -= TIER_OPTIONAL_ADDITIONAL;
-        }
-    }
-    return { tieredCallers, tieredTypeRefs, truncatedByBudget };
-}
-// ---------------------------------------------------------------------------
-// Formatter (CLI markdown)
-// ---------------------------------------------------------------------------
-function formatImpactResult(result, options) {
-    const lines = [];
-    lines.push(`**Impact of \`${result.methodQualifiedName}\`**  \`${result.filePath}:${result.startLine}-${result.endLine}\``);
-    if (result.totalCallers === 0 && result.totalTypeRefs === 0) {
-        lines.push('');
-        lines.push(`_No callers and no type references found — method appears isolated (entry point or unused)._`);
-        return lines.join('\n');
-    }
-    lines.push(`— ${result.totalCallers} caller${result.totalCallers === 1 ? '' : 's'} (BFS depth ${result.depthReached}) · ${result.totalTypeRefs} type ref${result.totalTypeRefs === 1 ? '' : 's'} to \`${result.enclosingClass ?? '(unknown class)'}\` across ${result.totalTypeRefFiles} file${result.totalTypeRefFiles === 1 ? '' : 's'}`);
-    // --- Callers section (grouped by hop) ---
-    if (result.callers.length > 0) {
-        lines.push('');
-        lines.push(`## Callers (transitive, BFS)`);
-        // Group by hop, then SNR within hop
-        const byHop = new Map();
-        for (const c of result.callers) {
-            const group = byHop.get(c.hopDistance) ?? [];
-            group.push(c);
-            byHop.set(c.hopDistance, group);
-        }
-        const hops = [...byHop.keys()].sort((a, b) => a - b);
-        for (const hop of hops) {
-            const group = byHop.get(hop).sort(compareByImpactSnr);
-            lines.push('');
-            lines.push(`### Hop ${hop}${hop === 1 ? ' — direct callers' : ` — indirect (callers of callers, depth ${hop})`}`);
-            for (const c of group) {
-                const tag = c.crossBoundary
-                    ? ` **[xBdy:${c.crossBoundary.fieldType}]**`
-                    : c.sameClassBiz
-                        ? ' **[sibling]**'
-                        : '';
-                lines.push(`- **${c.methodName}** L${c.line} \`${c.filePath}:${c.line}\`${tag}`);
-                if (c.containingClass && c.containingMethod) {
-                    lines.push(`  _in ${c.containingClass}#${c.containingMethod}_`);
-                }
-                if (c.tier === 'recommended' || c.tier === 'optional') {
-                    if (c.snippet) {
-                        const snippetLines = c.snippet.split('\n').slice(0, 2);
-                        for (const sl of snippetLines) {
-                            lines.push(`  > ${sl}`);
-                        }
-                    }
-                }
-                if (options?.explain) {
-                    lines.push(`  _score: ${formatImpactSnrBreakdown(c)}_`);
-                }
-            }
-        }
-    }
-    else {
-        lines.push('');
-        lines.push(`## Callers — none (likely entry point or RMI target)`);
-    }
-    // --- Type references section ---
-    if (result.typeReferences.length > 0) {
-        lines.push('');
-        lines.push(`## Type references to \`${result.enclosingClass}\` (ranked)`);
-        let currentKind = null;
-        for (const r of result.typeReferences) {
-            if (r.kind !== currentKind) {
-                currentKind = r.kind;
-                lines.push('');
-                lines.push(`### ${kindLabel(r.kind)}`);
-            }
-            const ctx = r.containingClass
-                ? ` _in ${r.containingClass}${r.containingMethod ? `#${r.containingMethod}` : ''}_`
-                : r.containingMethod
-                    ? ` _in #${r.containingMethod}_`
-                    : '';
-            lines.push(`- \`${r.filePath}:${r.line}\`${ctx}`);
-            if (r.tier === 'recommended' || r.tier === 'optional') {
-                if (r.snippet)
-                    lines.push(`  > ${r.snippet}`);
-            }
-            if (options?.explain) {
-                lines.push(`  _score: +${r.snrScore} ${r.kind} = ${r.snrScore}_`);
-            }
-        }
-    }
-    // Omitted summary
-    const o = result.omitted;
-    const omittedParts = [];
-    if (o.callersPrunedByTopPerHop > 0)
-        omittedParts.push(`${o.callersPrunedByTopPerHop} callers past topPerHop`);
-    if (o.typeRefsPrunedByTopK > 0)
-        omittedParts.push(`${o.typeRefsPrunedByTopK} type refs past topK`);
-    if (o.truncatedByBudget > 0)
-        omittedParts.push(`${o.truncatedByBudget} truncated by budget`);
-    if (omittedParts.length > 0) {
-        const widenHint = o.callersPrunedByTopPerHop > 0 ? '. Use `-k N` to widen' : '';
-        lines.push('');
-        lines.push(`_Omitted: ${omittedParts.join(' · ')}${widenHint}_`);
-    }
-    return lines.join('\n');
-}
-function kindLabel(kind) {
-    switch (kind) {
-        case 'extends': return 'extends (subclass)';
-        case 'implements': return 'implements (interface impl)';
-        case 'field': return 'field declarations';
-        case 'param': return 'method parameters';
-        case 'local': return 'local variables';
-        case 'return': return 'method return types';
-        case 'cast': return 'cast expressions';
-        case 'annotation': return 'annotations';
-        case 'generic': return 'generic type arguments';
-        case 'import': return 'imports';
-        case 'other': return 'other';
-    }
-}
-//# sourceMappingURL=impact.js.map