cgraphx 1.1.0 → 1.2.0

package/dist/search/impact.js

@@ -0,0 +1,646 @@
+"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