@kodus/kodus-graph 0.2.9 → 0.2.10

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.js

@@ -20,7 +20,14 @@ export function formatPrompt(output) {
                 lines.push('Status: new');
             }
             else if (fn.diff_changes.length > 0) {
-                lines.push(`Status: modified (${fn.diff_changes.join(', ')})`);
+                lines.push('Status: modified');
+                lines.push(`  Changes: ${fn.diff_changes.join(', ')}`);
+                for (const cd of fn.contract_diffs) {
+                    lines.push(`  - ${cd.field}: ${cd.old_value} -> ${cd.new_value}`);
+                }
+                if (fn.caller_impact) {
+                    lines.push(`  Impact: ${fn.caller_impact}`);
+                }
             }
             else {
                 lines.push('Status: unchanged');

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>;

package/dist/commands/parse.js

@@ -18,7 +18,7 @@ export async function executeParse(opts) {
     const files = discoverFiles(repoDir, opts.all ? undefined : opts.files, opts.include, opts.exclude);
     process.stderr.write(`[1/5] Discovered ${files.length} files\n`);
     // Phase 2: Parse + extract
-    let rawGraph = await parseBatch(files, repoDir, { skipTests: opts.skipTests });
+    let rawGraph = await parseBatch(files, repoDir, { skipTests: opts.skipTests, maxMemoryMB: opts.maxMemoryMB });
     process.stderr.write(`[2/5] Parsed ${rawGraph.functions.length} functions, ${rawGraph.classes.length} classes, ${rawGraph.rawCalls.length} call sites\n`);
     // Phase 3: Resolve imports
     const tsconfigAliases = loadTsconfigAliases(repoDir);
@@ -37,7 +37,7 @@ export async function executeParse(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({
@@ -80,7 +80,7 @@ export async function executeParse(opts) {
     }
     const parseErrors = rawGraph.parseErrors;
     const extractErrors = rawGraph.extractErrors;
-    const graphData = buildGraphData(rawGraph, callEdges, importEdges, repoDir, fileHashes);
+    const graphData = buildGraphData(rawGraph, callEdges, importEdges, repoDir, fileHashes, symbolTable, importMap);
     process.stderr.write(`[5/5] Built graph: ${graphData.nodes.length} nodes, ${graphData.edges.length} edges\n`);
     // Release intermediaries — no longer needed after buildGraphData
     rawGraph = null;

package/dist/commands/update.js

@@ -97,7 +97,7 @@ export async function executeUpdate(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({
@@ -119,7 +119,7 @@ export async function executeUpdate(opts) {
         }
         catch { }
     }
-    const newGraphData = buildGraphData(rawGraph, callEdges, importEdges, repoDir, fileHashes);
+    const newGraphData = buildGraphData(rawGraph, callEdges, importEdges, repoDir, fileHashes, symbolTable, importMap);
     process.stderr.write(`[4/5] Built new graph fragment (${newGraphData.nodes.length} nodes)\n`);
     // Merge: keep old nodes/edges NOT in changed/deleted files, add new ones
     const changedOrDeleted = new Set([...toReparse, ...deleted]);

package/dist/graph/builder.d.ts

@@ -1,2 +1,6 @@
 import type { GraphData, ImportEdge, RawCallEdge, RawGraph } from './types';
-export declare function buildGraphData(raw: RawGraph, callEdges: RawCallEdge[], importEdges: ImportEdge[], _repoDir: string, fileHashes: Map<string, string>): GraphData;
+export declare function buildGraphData(raw: RawGraph, callEdges: RawCallEdge[], importEdges: ImportEdge[], _repoDir: string, fileHashes: Map<string, string>, symbolTable?: {
+    lookupGlobal(name: string): string[];
+}, importMap?: {
+    lookup(file: string, name: string): string | null;
+}): GraphData;

package/dist/graph/builder.js

@@ -1,5 +1,5 @@
 import { deriveEdges } from './edges';
-export function buildGraphData(raw, callEdges, importEdges, _repoDir, fileHashes) {
+export function buildGraphData(raw, callEdges, importEdges, _repoDir, fileHashes, symbolTable, importMap) {
     const nodes = [];
     const edges = [];
     // Functions -> nodes
@@ -85,6 +85,23 @@ export function buildGraphData(raw, callEdges, importEdges, _repoDir, fileHashes
             content_hash: t.content_hash,
         });
     }
+    // Build a set of all parsed file paths for validation (filter external targets)
+    const parsedFiles = new Set();
+    for (const f of raw.functions) {
+        parsedFiles.add(f.file);
+    }
+    for (const c of raw.classes) {
+        parsedFiles.add(c.file);
+    }
+    for (const i of raw.interfaces) {
+        parsedFiles.add(i.file);
+    }
+    for (const e of raw.enums) {
+        parsedFiles.add(e.file);
+    }
+    for (const t of raw.tests) {
+        parsedFiles.add(t.file);
+    }
     // Build file→functions index to resolve caller from line number
     const functionsByFile = new Map();
     for (const node of nodes) {
@@ -106,6 +123,11 @@ export function buildGraphData(raw, callEdges, importEdges, _repoDir, fileHashes
     }
     // CALLS edges — resolve caller function from call line number
     for (const ce of callEdges) {
+        // Skip calls to external packages (target file not in repo)
+        const targetFile = ce.target.split('::')[0];
+        if (targetFile && !parsedFiles.has(targetFile)) {
+            continue;
+        }
         const sourceFile = ce.source.includes('::') ? ce.source.split('::')[0] : ce.source;
         let sourceQualified;
         if (ce.source.includes('::')) {
@@ -134,8 +156,11 @@ export function buildGraphData(raw, callEdges, importEdges, _repoDir, fileHashes
             confidence: ce.confidence,
         });
     }
-    // IMPORTS edges
+    // IMPORTS edges — only emit resolved imports (skip external/unresolved packages)
     for (const ie of importEdges) {
+        if (!ie.resolved) {
+            continue;
+        }
         edges.push({
             kind: 'IMPORTS',
             source_qualified: ie.source,
@@ -145,7 +170,14 @@ export function buildGraphData(raw, callEdges, importEdges, _repoDir, fileHashes
         });
     }
     // Derived edges
-    const derived = deriveEdges(raw, importEdges);
+    const derived = deriveEdges(raw, importEdges, symbolTable, importMap);
+    // Release raw graph arrays — no longer needed after deriveEdges
+    raw.functions = [];
+    raw.classes = [];
+    raw.interfaces = [];
+    raw.enums = [];
+    raw.tests = [];
+    raw.rawCalls = [];
     for (const e of derived.inherits) {
         edges.push({
             kind: 'INHERITS',

package/dist/graph/edges.d.ts

@@ -15,5 +15,9 @@ export interface DerivedEdges {
  * prefixes/suffixes. Returns null if no test pattern was found.
  */
 export declare function extractTestStem(testFile: string): string | null;
-export declare function deriveEdges(graph: RawGraph, importEdges: ImportEdge[]): DerivedEdges;
+export declare function deriveEdges(graph: RawGraph, importEdges: ImportEdge[], symbolTable?: {
+    lookupGlobal(name: string): string[];
+}, importMap?: {
+    lookup(file: string, name: string): string | null;
+}): DerivedEdges;
 export {};

package/dist/graph/edges.js

@@ -21,16 +21,70 @@ export function extractTestStem(testFile) {
     }
     return cleaned;
 }
-export function deriveEdges(graph, importEdges) {
-    // INHERITS: class extends another class
-    const inherits = graph.classes
-        .filter((c) => c.extends)
-        .map((c) => ({ source: c.qualified, target: c.extends, file: c.file }));
-    // IMPLEMENTS: class implements interface(s)
+/**
+ * Resolve a bare type name (e.g. "User", "IAuthService") to its qualified name
+ * using import map, same-file lookup, and global symbol table.
+ * Returns null if the name cannot be resolved (external class/interface).
+ */
+function resolveTypeName(name, file, graph, symbolTable, importMap) {
+    // 1. Check import map — was it imported in this file?
+    const importedFrom = importMap?.lookup(file, name);
+    if (importedFrom) {
+        // Look up the qualified name in the imported file
+        const candidates = symbolTable?.lookupGlobal(name) ?? [];
+        const match = candidates.find((q) => q.startsWith(`${importedFrom}::`));
+        if (match) {
+            return match;
+        }
+        // If importedFrom is not a local file (not in graph), it's an external package — skip
+        const isLocal = graph.classes.some((c) => c.file === importedFrom) ||
+            graph.interfaces.some((i) => i.file === importedFrom) ||
+            graph.functions.some((f) => f.file === importedFrom);
+        if (!isLocal) {
+            return null;
+        }
+        // Fallback: construct qualified name from local import target
+        return `${importedFrom}::${name}`;
+    }
+    // 2. Check same file — class or interface defined in same file
+    const sameFileClass = graph.classes.find((other) => other.name === name && other.file === file);
+    if (sameFileClass) {
+        return sameFileClass.qualified;
+    }
+    const sameFileInterface = graph.interfaces.find((other) => other.name === name && other.file === file);
+    if (sameFileInterface) {
+        return sameFileInterface.qualified;
+    }
+    // 3. Check global symbol table — unique match only
+    const globalCandidates = symbolTable?.lookupGlobal(name) ?? [];
+    if (globalCandidates.length === 1) {
+        return globalCandidates[0];
+    }
+    // 4. External class/interface (React.Component, Error, etc.) — unresolvable
+    return null;
+}
+export function deriveEdges(graph, importEdges, symbolTable, importMap) {
+    // INHERITS: class extends another class — resolve to qualified names
+    const inherits = [];
+    for (const c of graph.classes) {
+        if (!c.extends) {
+            continue;
+        }
+        const resolved = resolveTypeName(c.extends, c.file, graph, symbolTable, importMap);
+        if (resolved) {
+            inherits.push({ source: c.qualified, target: resolved, file: c.file });
+        }
+        // Skip unresolvable external classes (React.Component, Error, etc.)
+    }
+    // IMPLEMENTS: class implements interface(s) — resolve to qualified names
     const implements_ = [];
     for (const c of graph.classes) {
         for (const iface of c.implements) {
-            implements_.push({ source: c.qualified, target: iface, file: c.file });
+            const resolved = resolveTypeName(iface, c.file, graph, symbolTable, importMap);
+            if (resolved) {
+                implements_.push({ source: c.qualified, target: resolved, file: c.file });
+            }
+            // Skip unresolvable external interfaces
         }
     }
     // TESTED_BY: two heuristics, deduplicated

package/dist/graph/types.d.ts

@@ -1,3 +1,4 @@
+import type { ContractDiff } from '../analysis/diff';
 export type NodeKind = 'Function' | 'Method' | 'Constructor' | 'Class' | 'Interface' | 'Enum' | 'Test';
 export type EdgeKind = 'CALLS' | 'IMPORTS' | 'INHERITS' | 'IMPLEMENTS' | 'TESTED_BY' | 'CONTAINS';
 export interface GraphNode {
@@ -122,6 +123,8 @@ export interface EnrichedFunction {
     callees: CalleeRef[];
     has_test_coverage: boolean;
     diff_changes: string[];
+    contract_diffs: ContractDiff[];
+    caller_impact?: string;
     is_new: boolean;
     in_flows: string[];
 }

package/dist/parser/batch.d.ts

@@ -1,4 +1,5 @@
 import type { ParseBatchResult } from '../graph/types';
 export declare function parseBatch(files: string[], repoRoot: string, options?: {
     skipTests?: boolean;
+    maxMemoryMB?: number;
 }): Promise<ParseBatchResult>;

package/dist/parser/batch.js

@@ -5,7 +5,8 @@ import { NOISE } from '../shared/filters';
 import { log } from '../shared/logger';
 import { extractCallsFromFile, extractFromFile } from './extractor';
 import { getLanguage } from './languages';
-const BATCH_SIZE = 50;
+const INITIAL_BATCH = 50;
+const MEMORY_THRESHOLD_RATIO = 0.7;
 export async function parseBatch(files, repoRoot, options) {
     const graph = {
         functions: [],
@@ -21,8 +22,10 @@ export async function parseBatch(files, repoRoot, options) {
     const seen = new Set();
     let parseErrors = 0;
     let extractErrors = 0;
-    for (let i = 0; i < files.length; i += BATCH_SIZE) {
-        const batch = files.slice(i, i + BATCH_SIZE);
+    let batchSize = INITIAL_BATCH;
+    const maxMemBytes = (options?.maxMemoryMB ?? 768) * 1024 * 1024;
+    for (let i = 0; i < files.length; i += batchSize) {
+        const batch = files.slice(i, i + batchSize);
         const promises = batch.map(async (filePath) => {
             const lang = getLanguage(extname(filePath));
             if (!lang) {
@@ -70,6 +73,18 @@ export async function parseBatch(files, repoRoot, options) {
             }
         });
         await Promise.all(promises);
+        // Dynamic batch sizing: reduce if memory pressure detected
+        const rss = process.memoryUsage().rss;
+        if (rss > maxMemBytes * MEMORY_THRESHOLD_RATIO) {
+            const oldBatch = batchSize;
+            batchSize = Math.max(5, Math.floor(batchSize / 2));
+            log.warn('Memory pressure detected, reducing batch size', {
+                rssMB: Math.round(rss / 1024 / 1024),
+                maxMB: Math.round(maxMemBytes / 1024 / 1024),
+                oldBatchSize: oldBatch,
+                newBatchSize: batchSize,
+            });
+        }
     }
     if (options?.skipTests) {
         graph.tests = [];

package/dist/parser/languages.js

@@ -242,6 +242,7 @@ function derivedKinds(config) {
         result.method = firstOf(config.method);
     }
     if (firstOf(config.constructorKinds)) {
+        // biome-ignore lint/complexity/useLiteralKeys: bracket notation required — dot notation resolves to Function.prototype.constructor (TS2322)
         result['constructor'] = firstOf(config.constructorKinds);
     }
     if (firstOf(config.interface)) {

package/dist/resolver/external-detector.d.ts

@@ -0,0 +1,11 @@
+/**
+ * External package detector.
+ * Reads dependency manifests (package.json, requirements.txt, go.mod, etc.)
+ * to determine if an import target is an external (third-party) package.
+ */
+export declare function clearExternalCache(): void;
+/**
+ * Check if an import is an external (third-party) package.
+ * Returns the package name if external, null if not detected as external.
+ */
+export declare function detectExternal(modulePath: string, lang: string, repoRoot: string): string | null;