@kodus/kodus-graph 0.2.9 → 0.2.11

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('::')) {
@@ -123,7 +145,10 @@ export function buildGraphData(raw, callEdges, importEdges, _repoDir, fileHashes
                     }
                 }
             }
-            sourceQualified = resolved || `${ce.source}::unknown`;
+            if (!resolved) {
+                continue; // Skip top-level calls with no enclosing function
+            }
+            sourceQualified = resolved;
         }
         edges.push({
             kind: 'CALLS',
@@ -134,8 +159,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 +173,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;