@kodus/kodus-graph 0.2.9 → 0.2.11

package/dist/analysis/blast-radius.d.ts

@@ -1,2 +1,2 @@
 import type { BlastRadiusResult, GraphData } from '../graph/types';
-export declare function computeBlastRadius(graph: GraphData, changedFiles: string[], maxDepth?: number): BlastRadiusResult;
+export declare function computeBlastRadius(graph: GraphData, changedQualifiedNames: string[], maxDepth?: number, minConfidence?: number): BlastRadiusResult;

package/dist/analysis/blast-radius.js

@@ -1,30 +1,28 @@
-export function computeBlastRadius(graph, changedFiles, maxDepth = 2) {
-    // Build adjacency list from CALLS edges (callers of changed nodes)
+export function computeBlastRadius(graph, changedQualifiedNames, maxDepth = 2, minConfidence) {
+    const minConf = minConfidence ?? 0.5;
+    // Build adjacency list filtering by confidence
     const adj = new Map();
-    for (const edge of graph.edges) {
-        if (edge.kind !== 'CALLS' && edge.kind !== 'IMPORTS') {
-            continue;
-        }
-        // Reverse direction: target -> source (who calls/imports this?)
-        if (!adj.has(edge.target_qualified)) {
-            adj.set(edge.target_qualified, new Set());
+    const addEdge = (from, to) => {
+        if (!adj.has(from)) {
+            adj.set(from, new Set());
         }
-        adj.get(edge.target_qualified).add(edge.source_qualified);
-        // Forward direction too for IMPORTS
+        adj.get(from).add(to);
+    };
+    for (const edge of graph.edges) {
         if (edge.kind === 'IMPORTS') {
-            if (!adj.has(edge.source_qualified)) {
-                adj.set(edge.source_qualified, new Set());
-            }
-            adj.get(edge.source_qualified).add(edge.target_qualified);
+            // IMPORTS: no confidence filter, bidirectional
+            addEdge(edge.target_qualified, edge.source_qualified);
+            addEdge(edge.source_qualified, edge.target_qualified);
+        }
+        else if (edge.kind === 'CALLS' && (edge.confidence ?? 1.0) >= minConf) {
+            // CALLS: only edges with sufficient confidence, reverse direction
+            addEdge(edge.target_qualified, edge.source_qualified);
         }
     }
-    // Seed: all nodes in changed files
-    const changedSet = new Set(changedFiles);
-    const seeds = graph.nodes.filter((n) => changedSet.has(n.file_path)).map((n) => n.qualified_name);
-    // BFS
-    const visited = new Set(seeds);
+    // Seeds: qualified names directly (no more file-level)
+    const visited = new Set(changedQualifiedNames);
     const byDepth = {};
-    let frontier = seeds;
+    let frontier = [...changedQualifiedNames];
     for (let depth = 1; depth <= maxDepth; depth++) {
         const next = [];
         for (const node of frontier) {

package/dist/analysis/context-builder.js

@@ -18,13 +18,22 @@ export function buildContextV2(opts) {
     const newNodesInChanged = mergedGraph.nodes.filter((n) => changedSet.has(n.file_path));
     const newEdgesInChanged = mergedGraph.edges.filter((e) => changedSet.has(e.file_path));
     const structuralDiff = computeStructuralDiff(oldIndexed, newNodesInChanged, newEdgesInChanged, changedFiles);
-    const blastRadius = computeBlastRadius(mergedGraph, changedFiles, maxDepth);
+    // Extract truly changed qualified names from structural diff (added + modified + removed)
+    const trulyChangedQN = new Set([
+        ...structuralDiff.nodes.added.map((n) => n.qualified_name),
+        ...structuralDiff.nodes.modified.map((n) => n.qualified_name),
+        ...structuralDiff.nodes.removed.map((n) => n.qualified_name),
+    ]);
+    const blastRadius = computeBlastRadius(mergedGraph, [...trulyChangedQN], maxDepth, minConfidence);
     const allFlows = detectFlows(indexed, { maxDepth: 10, type: 'all' });
     const testGaps = opts.skipTests ? [] : findTestGaps(mergedGraph, changedFiles);
     const risk = computeRiskScore(mergedGraph, changedFiles, blastRadius, { skipTests: opts.skipTests });
     const inheritance = extractInheritance(indexed, changedFiles);
-    // Phase 3: Filter affected flows
-    const changedFuncSet = new Set(mergedGraph.nodes.filter((n) => changedSet.has(n.file_path) && !n.is_test).map((n) => n.qualified_name));
+    // Phase 3: Filter affected flows — only truly changed (added+modified+removed), non-test functions
+    const changedFuncSet = new Set([...trulyChangedQN].filter((qn) => {
+        const node = indexed.byQualified.get(qn);
+        return node && !node.is_test;
+    }));
     const affectedFlows = [];
     for (const flow of allFlows.flows) {
         const touches = flow.path.filter((qn) => changedFuncSet.has(qn));
@@ -39,7 +48,7 @@ export function buildContextV2(opts) {
         }
     }
     // Phase 3: Enrichment
-    const enriched = enrichChangedFunctions(indexed, changedFiles, structuralDiff, allFlows.flows, minConfidence);
+    const enriched = enrichChangedFunctions(indexed, changedFiles, structuralDiff, allFlows.flows, minConfidence, true);
     // Phase 4: Assembly
     const totalCallers = enriched.reduce((s, f) => s + f.callers.length, 0);
     const totalCallees = enriched.reduce((s, f) => s + f.callees.length, 0);

package/dist/analysis/diff.d.ts

@@ -7,9 +7,15 @@ export interface NodeChange {
     line_start: number;
     line_end: number;
 }
+export interface ContractDiff {
+    field: 'params' | 'return_type' | 'modifiers';
+    old_value: string;
+    new_value: string;
+}
 export interface ModifiedNode {
     qualified_name: string;
     changes: string[];
+    contract_diffs: ContractDiff[];
 }
 export interface DiffResult {
     changed_files: string[];

package/dist/analysis/diff.js

@@ -84,14 +84,29 @@ export function computeStructuralDiff(oldGraph, newNodes, newEdges, changedFiles
                     });
                 }
             }
+            const contractDiffs = [];
             if ((n.params || '') !== (newN.params || '')) {
                 changes.push('params');
+                contractDiffs.push({ field: 'params', old_value: n.params || '()', new_value: newN.params || '()' });
             }
             if ((n.return_type || '') !== (newN.return_type || '')) {
                 changes.push('return_type');
+                contractDiffs.push({
+                    field: 'return_type',
+                    old_value: n.return_type || 'void',
+                    new_value: newN.return_type || 'void',
+                });
+            }
+            if ((n.modifiers || '') !== (newN.modifiers || '')) {
+                changes.push('modifiers');
+                contractDiffs.push({
+                    field: 'modifiers',
+                    old_value: n.modifiers || '',
+                    new_value: newN.modifiers || '',
+                });
             }
             if (changes.length > 0) {
-                modified.push({ qualified_name: qn, changes });
+                modified.push({ qualified_name: qn, changes, contract_diffs: contractDiffs });
             }
         }
     }

package/dist/analysis/enrich.d.ts

@@ -2,4 +2,4 @@ import type { IndexedGraph } from '../graph/loader';
 import type { EnrichedFunction } from '../graph/types';
 import type { DiffResult } from './diff';
 import type { Flow } from './flows';
-export declare function enrichChangedFunctions(graph: IndexedGraph, changedFiles: string[], diff: DiffResult, allFlows: Flow[], minConfidence: number): EnrichedFunction[];
+export declare function enrichChangedFunctions(graph: IndexedGraph, changedFiles: string[], diff: DiffResult, allFlows: Flow[], minConfidence: number, onlyChanged?: boolean): EnrichedFunction[];

package/dist/analysis/enrich.js

@@ -1,8 +1,8 @@
-export function enrichChangedFunctions(graph, changedFiles, diff, allFlows, minConfidence) {
+export function enrichChangedFunctions(graph, changedFiles, diff, allFlows, minConfidence, onlyChanged = false) {
     const changedSet = new Set(changedFiles);
     // Pre-index diff results
     const addedSet = new Set(diff.nodes.added.map((n) => n.qualified_name));
-    const modifiedMap = new Map(diff.nodes.modified.map((m) => [m.qualified_name, m.changes]));
+    const modifiedMap = new Map(diff.nodes.modified.map((m) => [m.qualified_name, m]));
     // Pre-index TESTED_BY
     const testedFiles = new Set(graph.edges.filter((e) => e.kind === 'TESTED_BY').map((e) => e.source_qualified));
     // Pre-index flows by function
@@ -21,12 +21,22 @@ export function enrichChangedFunctions(graph, changedFiles, diff, allFlows, minC
         }
     }
     // Filter functions in changed files
-    const changedFunctions = graph.nodes.filter((n) => changedSet.has(n.file_path) &&
-        !n.is_test &&
-        n.kind !== 'Constructor' &&
-        n.kind !== 'Class' &&
-        n.kind !== 'Interface' &&
-        n.kind !== 'Enum');
+    const changedFunctions = graph.nodes.filter((n) => {
+        if (!changedSet.has(n.file_path)) {
+            return false;
+        }
+        if (n.is_test ||
+            n.kind === 'Constructor' ||
+            n.kind === 'Class' ||
+            n.kind === 'Interface' ||
+            n.kind === 'Enum') {
+            return false;
+        }
+        if (onlyChanged) {
+            return addedSet.has(n.qualified_name) || modifiedMap.has(n.qualified_name);
+        }
+        return true;
+    });
     return changedFunctions
         .sort((a, b) => a.file_path.localeCompare(b.file_path) || a.line_start - b.line_start)
         .map((node) => {
@@ -78,7 +88,23 @@ export function enrichChangedFunctions(graph, changedFiles, diff, allFlows, minC
         const signature = `${shortName}${params}${ret}`;
         // Diff
         const isNew = addedSet.has(node.qualified_name);
-        const diffChanges = isNew ? [] : modifiedMap.get(node.qualified_name) || [];
+        const modifiedNode = modifiedMap.get(node.qualified_name);
+        const diffChanges = isNew ? [] : modifiedNode?.changes || [];
+        const contractDiffs = isNew ? [] : (modifiedNode?.contract_diffs ?? []);
+        // Caller impact
+        let callerImpact;
+        if (contractDiffs.length > 0 && callers.length > 0) {
+            const impacts = [];
+            const paramsDiff = contractDiffs.find((d) => d.field === 'params');
+            const returnDiff = contractDiffs.find((d) => d.field === 'return_type');
+            if (paramsDiff) {
+                impacts.push(`${callers.length} callers may need param update`);
+            }
+            if (returnDiff) {
+                impacts.push(`${callers.length} callers may assume old return type`);
+            }
+            callerImpact = impacts.length > 0 ? impacts.join('; ') : undefined;
+        }
         return {
             qualified_name: node.qualified_name,
             name: node.name,
@@ -91,6 +117,8 @@ export function enrichChangedFunctions(graph, changedFiles, diff, allFlows, minC
             callees,
             has_test_coverage: testedFiles.has(node.file_path),
             diff_changes: diffChanges,
+            contract_diffs: contractDiffs,
+            caller_impact: callerImpact,
             is_new: isNew,
             in_flows: flowsByFunction.get(node.qualified_name) || [],
         };

package/dist/analysis/prompt-formatter.d.ts

@@ -1,2 +1,13 @@
 import type { ContextV2Output } from './context-builder';
+/**
+ * Compact prompt format optimized for LLM agent consumption.
+ *
+ * Design principles (derived from Langsmith trace analysis):
+ * - Agent forms hypotheses on FIRST LLM call using graph + diff → dense signal, no noise
+ * - Agent then uses grep/readFile with names from the graph → names must be grepable (file:line)
+ * - Inheritance enables cross-class comparison (e.g. sibling method implementations) → keep hierarchy
+ * - Test Gaps list and Structural Changes were never referenced by agent → removed
+ * - Contract changes on callers are high-value signals → inline with ⚠
+ * - Flows show how HTTP/test paths cross changed code → inline per function
+ */
 export declare function formatPrompt(output: ContextV2Output): string;

package/dist/analysis/prompt-formatter.js

@@ -1,166 +1,201 @@
+/**
+ * Compact prompt format optimized for LLM agent consumption.
+ *
+ * Design principles (derived from Langsmith trace analysis):
+ * - Agent forms hypotheses on FIRST LLM call using graph + diff → dense signal, no noise
+ * - Agent then uses grep/readFile with names from the graph → names must be grepable (file:line)
+ * - Inheritance enables cross-class comparison (e.g. sibling method implementations) → keep hierarchy
+ * - Test Gaps list and Structural Changes were never referenced by agent → removed
+ * - Contract changes on callers are high-value signals → inline with ⚠
+ * - Flows show how HTTP/test paths cross changed code → inline per function
+ */
 export function formatPrompt(output) {
     const { analysis } = output;
     const lines = [];
-    // Header
     const risk = analysis.risk;
     const br = analysis.blast_radius;
     const meta = analysis.metadata;
-    lines.push('# Code Review Context');
+    // ── Header: one-line stats ──
+    lines.push(`${meta.changed_functions_count} changed | ${br.total_functions} impacted | ${br.total_files} files | risk ${risk.level} ${risk.score} | ${meta.untested_count} untested`);
     lines.push('');
-    lines.push(`Risk: ${risk.level} (${risk.score}) | ${br.total_functions} functions impacted across ${br.total_files} files | ${meta.untested_count} untested`);
-    lines.push('');
-    // Changed functions
+    // ── Changed functions ──
     if (analysis.changed_functions.length > 0) {
-        lines.push('## Changed Functions');
-        lines.push('');
+        lines.push('CHANGED:');
+        // Build a set of qualified names that have siblings (same method name in sibling classes)
+        const siblingMap = buildSiblingMap(analysis, output);
         for (const fn of analysis.changed_functions) {
-            lines.push(`### ${fn.signature}  [${fn.file_path}:${fn.line_start}-${fn.line_end}]`);
-            // Status
-            if (fn.is_new) {
-                lines.push('Status: new');
-            }
-            else if (fn.diff_changes.length > 0) {
-                lines.push(`Status: modified (${fn.diff_changes.join(', ')})`);
-            }
-            else {
-                lines.push('Status: unchanged');
-            }
-            // Callers
+            const status = fn.is_new ? 'new' : fn.diff_changes.length > 0 ? 'modified' : 'unchanged';
+            const tested = fn.has_test_coverage ? 'tested' : 'untested';
+            // Main line
+            lines.push(`  ${fn.signature} [${fn.file_path}:${fn.line_start}-${fn.line_end}] ${status} | ${fn.callers.length} callers | ${tested}`);
+            // Contract changes — high value for agent to spot breaking changes
+            for (const cd of fn.contract_diffs) {
+                lines.push(`    ⚠ ${cd.field}: ${cd.old_value} → ${cd.new_value}`);
+            }
+            if (fn.caller_impact) {
+                lines.push(`    ⚠ ${fn.caller_impact}`);
+            }
+            // Callers (← notation) — top N, then summary
             if (fn.callers.length > 0) {
-                lines.push('Callers:');
-                for (const c of fn.callers) {
-                    const conf = c.confidence < 0.85 ? ` confidence=${c.confidence.toFixed(2)}` : '';
-                    lines.push(`  - ${c.name}  [${c.file_path}:${c.line}]${conf}`);
+                const MAX_CALLERS = 5;
+                const shown = fn.callers.slice(0, MAX_CALLERS);
+                for (const c of shown) {
+                    const conf = c.confidence < 0.85 ? ` ~${Math.round(c.confidence * 100)}%` : '';
+                    lines.push(`    ← ${c.name} [${c.file_path}:${c.line}]${conf}`);
+                }
+                if (fn.callers.length > MAX_CALLERS) {
+                    const remaining = fn.callers.slice(MAX_CALLERS);
+                    const uniqueFiles = new Set(remaining.map((c) => c.file_path)).size;
+                    lines.push(`    ... +${remaining.length} callers in ${uniqueFiles} files`);
                 }
             }
-            else {
-                lines.push('Callers: none');
-            }
-            // Callees
+            // Callees (→ compact chain)
             if (fn.callees.length > 0) {
-                lines.push('Callees:');
-                for (const c of fn.callees) {
-                    lines.push(`  - ${c.signature}  [${c.file_path}]`);
+                const MAX_CALLEES = 8;
+                const names = fn.callees.slice(0, MAX_CALLEES).map((c) => c.name);
+                let calleeLine = `    → ${names.join(', ')}`;
+                if (fn.callees.length > MAX_CALLEES) {
+                    calleeLine += `, ... +${fn.callees.length - MAX_CALLEES}`;
                 }
+                lines.push(calleeLine);
             }
-            else {
-                lines.push('Callees: none');
+            // Similar: sibling class with same method name — enables cross-class comparison
+            const siblings = siblingMap.get(fn.qualified_name);
+            if (siblings && siblings.length > 0) {
+                for (const sib of siblings) {
+                    lines.push(`    similar: ${sib.name} [${sib.file_path}:${sib.line_start}]`);
+                }
             }
-            // Test coverage
-            lines.push(`Test coverage: ${fn.has_test_coverage ? 'yes' : 'no'}`);
-            // Affected flows
+            // Affected flows inline
             if (fn.in_flows.length > 0) {
-                lines.push('Affected flows:');
+                const MAX_FLOWS = 3;
+                let flowCount = 0;
                 for (const ep of fn.in_flows) {
+                    if (flowCount >= MAX_FLOWS) {
+                        lines.push(`    ... +${fn.in_flows.length - MAX_FLOWS} flows`);
+                        break;
+                    }
                     const flow = analysis.affected_flows.find((f) => f.entry_point === ep);
                     if (flow) {
                         const prefix = flow.type === 'http' ? 'HTTP' : 'TEST';
-                        lines.push(`  - ${prefix}: ${flow.path.map((q) => q.split('::').pop()).join(' → ')}`);
-                    }
-                    else {
-                        lines.push(`  - ${ep.split('::').pop()}`);
+                        const path = flow.path.map((q) => shortName(q)).join(' → ');
+                        lines.push(`    flow: ${prefix} ${path}`);
                     }
+                    flowCount++;
                 }
             }
-            else {
-                lines.push('Affected flows: none');
-            }
             lines.push('');
         }
     }
-    // Inheritance
+    // ── Hierarchy (compact) ──
     if (analysis.inheritance.length > 0) {
-        lines.push('## Inheritance');
-        lines.push('');
+        lines.push('HIERARCHY:');
         for (const entry of analysis.inheritance) {
-            const name = entry.qualified_name.split('::').pop();
+            const name = shortName(entry.qualified_name);
             const parts = [];
             if (entry.extends) {
-                parts.push(`extends ${entry.extends.split('::').pop()}`);
+                parts.push(`extends ${shortName(entry.extends)}`);
             }
             if (entry.implements.length > 0) {
-                parts.push(`implements ${entry.implements.map((i) => i.split('::').pop()).join(', ')}`);
+                parts.push(`impl ${entry.implements.map((i) => shortName(i)).join(', ')}`);
+            }
+            let line = `  ${name}`;
+            if (parts.length > 0) {
+                line += ` ${parts.join(' | ')}`;
             }
-            lines.push(`- ${name} ${parts.join(', ')}`);
             if (entry.children.length > 0) {
-                lines.push(`  Children: ${entry.children.map((c) => c.split('::').pop()).join(', ')}`);
+                line += ` | children: ${entry.children.map((c) => shortName(c)).join(', ')}`;
             }
+            lines.push(line);
         }
         lines.push('');
     }
-    // Blast radius by depth
+    // ── Blast radius by depth (compact) ──
     const byDepth = analysis.blast_radius.by_depth;
     const depthKeys = Object.keys(byDepth).sort();
     if (depthKeys.length > 0) {
-        lines.push('## Blast Radius');
-        lines.push('');
+        lines.push('BLAST RADIUS:');
         for (const depth of depthKeys) {
-            const names = byDepth[depth].map((q) => q.split('::').pop());
-            lines.push(`Depth ${depth}: ${names.join(', ')} (${names.length} functions)`);
+            const qnames = byDepth[depth];
+            const names = qnames.map((q) => shortName(q));
+            const MAX_SHOW = 8;
+            if (names.length <= MAX_SHOW) {
+                lines.push(`  depth ${depth}: ${names.join(', ')} (${names.length})`);
+            }
+            else {
+                const shown = names.slice(0, MAX_SHOW);
+                lines.push(`  depth ${depth}: ${shown.join(', ')} ... +${names.length - MAX_SHOW} (${names.length} total)`);
+            }
         }
         lines.push('');
     }
-    // Test gaps
-    if (analysis.test_gaps.length > 0) {
-        lines.push('## Test Gaps');
-        lines.push('');
-        for (const gap of analysis.test_gaps) {
-            const name = gap.function.split('::').pop();
-            lines.push(`- ${name}  [${gap.file_path}:${gap.line_start}]`);
+    return lines.join('\n');
+}
+// ── Helpers ──
+/** Extract short name from qualified_name (e.g. "mod::Class::method" → "method") */
+function shortName(qualifiedName) {
+    return qualifiedName.split('::').pop() || qualifiedName;
+}
+/**
+ * Build a map of changed functions → sibling implementations.
+ * A "sibling" is a function with the same method name in a class that shares
+ * the same parent (extends same base). This enables cross-class comparison
+ * (e.g. OptimizedCursorPaginator.get_item_key vs DateTimePaginator.get_item_key).
+ *
+ * Uses full graph edges (not just analysis.inheritance which is filtered to changed files).
+ */
+function buildSiblingMap(analysis, output) {
+    const result = new Map();
+    // Build parent→children index from ALL INHERITS edges in the graph (not just changed files)
+    const parentToChildren = new Map();
+    for (const edge of output.graph.edges) {
+        if (edge.kind !== 'INHERITS') {
+            continue;
         }
-        lines.push('');
+        const existing = parentToChildren.get(edge.target_qualified) || [];
+        existing.push(edge.source_qualified);
+        parentToChildren.set(edge.target_qualified, existing);
     }
-    // Structural diff
-    const diff = analysis.structural_diff;
-    const hasNodeChanges = diff.summary.added > 0 || diff.summary.removed > 0 || diff.summary.modified > 0;
-    const hasEdgeChanges = diff.edges.added.length > 0 || diff.edges.removed.length > 0;
-    if (hasNodeChanges || hasEdgeChanges) {
-        lines.push('## Structural Changes');
-        lines.push('');
-        if (hasNodeChanges) {
-            const parts = [];
-            if (diff.summary.added > 0) {
-                parts.push(`${diff.summary.added} added`);
-            }
-            if (diff.summary.removed > 0) {
-                parts.push(`${diff.summary.removed} removed`);
-            }
-            if (diff.summary.modified > 0) {
-                parts.push(`${diff.summary.modified} modified`);
-            }
-            lines.push(parts.join(', '));
+    // Index nodes by qualified name for fast lookup
+    const nodeByQN = new Map(output.graph.nodes.map((n) => [n.qualified_name, n]));
+    // For each changed function, find if its class has siblings with the same method
+    const changedQNs = new Set(analysis.changed_functions.map((f) => f.qualified_name));
+    for (const fn of analysis.changed_functions) {
+        // Extract class name from qualified_name (e.g. "file::Class::method" → "file::Class")
+        const parts = fn.qualified_name.split('::');
+        if (parts.length < 3) {
+            continue; // need at least file::class::method
         }
-        if (diff.nodes.removed.length > 0) {
-            lines.push('');
-            lines.push('Removed:');
-            for (const n of diff.nodes.removed) {
-                const name = n.qualified_name.split('::').pop();
-                lines.push(`  - [${n.kind}] ${name}  [${n.file_path}:${n.line_start}]`);
-            }
-        }
-        if (diff.nodes.modified.length > 0) {
-            lines.push('');
-            lines.push('Modified:');
-            for (const m of diff.nodes.modified) {
-                const name = m.qualified_name.split('::').pop();
-                lines.push(`  - ${name} (${m.changes.join(', ')})`);
-            }
+        const methodName = parts[parts.length - 1];
+        const className = parts.slice(0, -1).join('::');
+        // Find what this class extends (from INHERITS edges)
+        const parentEdge = output.graph.edges.find((e) => e.kind === 'INHERITS' && e.source_qualified === className);
+        if (!parentEdge) {
+            continue;
         }
-        if (hasEdgeChanges) {
-            lines.push('');
-            lines.push('Dependency changes:');
-            for (const e of diff.edges.added) {
-                const src = e.source_qualified.split('::').pop();
-                const tgt = e.target_qualified.split('::').pop();
-                lines.push(`  + ${e.kind}: ${src} → ${tgt}`);
-            }
-            for (const e of diff.edges.removed) {
-                const src = e.source_qualified.split('::').pop();
-                const tgt = e.target_qualified.split('::').pop();
-                lines.push(`  - ${e.kind}: ${src} → ${tgt}`);
+        // Find sibling classes (same parent)
+        const siblings = parentToChildren.get(parentEdge.target_qualified) || [];
+        for (const siblingClass of siblings) {
+            if (siblingClass === className) {
+                continue;
+            }
+            // Look for same method name in sibling class
+            const siblingMethodQN = `${siblingClass}::${methodName}`;
+            // Don't list if the sibling is also in changed functions (it's already shown)
+            if (changedQNs.has(siblingMethodQN)) {
+                continue;
+            }
+            const siblingNode = nodeByQN.get(siblingMethodQN);
+            if (siblingNode) {
+                const existing = result.get(fn.qualified_name) || [];
+                existing.push({
+                    name: `${shortName(siblingClass)}.${methodName}`,
+                    file_path: siblingNode.file_path,
+                    line_start: siblingNode.line_start,
+                });
+                result.set(fn.qualified_name, existing);
             }
         }
-        lines.push('');
     }
-    return lines.join('\n');
+    return result;
 }

package/dist/cli.js

@@ -24,6 +24,7 @@ program
     .option('--include <glob...>', 'Include only files matching glob (repeatable)')
     .option('--exclude <glob...>', 'Exclude files matching glob (repeatable)')
     .option('--skip-tests', 'Skip test detection (no Test nodes, TESTED_BY edges, or test gaps)')
+    .option('--max-memory <mb>', 'Maximum memory usage in MB (default: 768)', (v) => parseInt(v, 10))
     .requiredOption('--out <path>', 'Output JSON file path')
     .action(async (opts) => {
     const repoDir = resolve(opts.repoDir);
@@ -39,6 +40,7 @@ program
         include: opts.include,
         exclude: opts.exclude,
         skipTests: opts.skipTests ?? false,
+        maxMemoryMB: opts.maxMemory,
     });
 });
 program

package/dist/commands/analyze.js

@@ -60,7 +60,7 @@ export async function executeAnalyze(opts) {
     // Pre-resolve re-exports so barrel imports follow through to actual definitions
     const barrelMap = buildReExportMap(rawGraph.reExports, repoDir, tsconfigAliases);
     for (const imp of rawGraph.imports) {
-        const langKey = imp.lang === 'python' ? 'python' : imp.lang === 'ruby' ? 'ruby' : 'typescript';
+        const langKey = imp.lang;
         const resolved = resolveImport(resolve(repoDir, imp.file), imp.module, langKey, repoDir, tsconfigAliases);
         const resolvedRel = resolved ? relative(repoDir, resolved) : null;
         importEdges.push({
@@ -98,11 +98,13 @@ export async function executeAnalyze(opts) {
             log.warn('Failed to compute file hash', { file: f, error: String(err) });
         }
     }
-    const localGraphData = buildGraphData(rawGraph, callEdges, importEdges, repoDir, fileHashes);
+    const localGraphData = buildGraphData(rawGraph, callEdges, importEdges, repoDir, fileHashes, symbolTable, importMap);
     // Merge with main graph (or use local only)
     const mergedGraph = mainGraph ? mergeGraphs(mainGraph, localGraphData, opts.files) : localGraphData;
     // Analyze
-    const blastRadius = computeBlastRadius(mergedGraph, opts.files);
+    // Temporary: convert file-level to function-level until Mudança 3 provides trulyChangedQN
+    const changedQN = mergedGraph.nodes.filter((n) => opts.files.includes(n.file_path)).map((n) => n.qualified_name);
+    const blastRadius = computeBlastRadius(mergedGraph, changedQN);
     const riskScore = computeRiskScore(mergedGraph, opts.files, blastRadius, { skipTests: opts.skipTests });
     const testGaps = opts.skipTests ? [] : findTestGaps(mergedGraph, opts.files);
     const output = {

package/dist/commands/diff.js

@@ -57,7 +57,7 @@ export async function executeDiff(opts) {
         symbolTable.add(i.file, i.name, i.qualified);
     }
     for (const imp of rawGraph.imports) {
-        const langKey = imp.lang === 'python' ? 'python' : imp.lang === 'ruby' ? 'ruby' : 'typescript';
+        const langKey = imp.lang;
         const resolved = resolveImport(resolve(repoDir, imp.file), imp.module, langKey, repoDir, tsconfigAliases);
         const resolvedRel = resolved ? relative(repoDir, resolved) : null;
         importEdges.push({
@@ -79,7 +79,7 @@ export async function executeDiff(opts) {
         }
         catch { }
     }
-    const newGraphData = buildGraphData(rawGraph, callEdges, importEdges, repoDir, fileHashes);
+    const newGraphData = buildGraphData(rawGraph, callEdges, importEdges, repoDir, fileHashes, symbolTable, importMap);
     process.stderr.write(`[3/4] Re-parsed ${absFiles.length} files (${newGraphData.nodes.length} nodes)\n`);
     // Compute diff
     const relChangedFiles = changedFiles.map((f) => (f.startsWith('/') ? relative(repoDir, f) : f));

package/dist/commands/parse.d.ts

@@ -6,5 +6,6 @@ export interface ParseOptions {
     include?: string[];
     exclude?: string[];
     skipTests?: boolean;
+    maxMemoryMB?: number;
 }
 export declare function executeParse(opts: ParseOptions): Promise<void>;