@kodus/kodus-graph 0.2.8 → 0.2.10

package/dist/commands/diff.js

@@ -0,0 +1,89 @@
+import { execSync } from 'child_process';
+import { existsSync, writeFileSync } from 'fs';
+import { relative, resolve } from 'path';
+import { performance } from 'perf_hooks';
+import { computeStructuralDiff } from '../analysis/diff';
+import { buildGraphData } from '../graph/builder';
+import { loadGraph } from '../graph/loader';
+import { parseBatch } from '../parser/batch';
+import { discoverFiles } from '../parser/discovery';
+import { resolveAllCalls } from '../resolver/call-resolver';
+import { createImportMap } from '../resolver/import-map';
+import { loadTsconfigAliases, resolveImport } from '../resolver/import-resolver';
+import { createSymbolTable } from '../resolver/symbol-table';
+import { computeFileHash } from '../shared/file-hash';
+import { log } from '../shared/logger';
+export async function executeDiff(opts) {
+    const t0 = performance.now();
+    const repoDir = resolve(opts.repoDir);
+    // Resolve changed files
+    let changedFiles;
+    if (opts.base) {
+        try {
+            const output = execSync(`git diff --name-only ${opts.base}`, { cwd: repoDir, encoding: 'utf-8' });
+            changedFiles = output.trim().split('\n').filter(Boolean);
+        }
+        catch (err) {
+            log.error('failed to run git diff', { base: opts.base, error: String(err) });
+            process.exit(1);
+        }
+    }
+    else {
+        changedFiles = opts.files;
+    }
+    process.stderr.write(`[1/4] ${changedFiles.length} changed files\n`);
+    // Load old graph
+    const graphPath = resolve(opts.graph);
+    if (!existsSync(graphPath)) {
+        log.error('graph file not found', { path: graphPath });
+        process.exit(1);
+    }
+    const oldGraph = loadGraph(graphPath);
+    process.stderr.write(`[2/4] Loaded previous graph (${oldGraph.nodes.length} nodes)\n`);
+    // Re-parse changed files
+    const absFiles = discoverFiles(repoDir, changedFiles);
+    const rawGraph = await parseBatch(absFiles, repoDir);
+    const tsconfigAliases = loadTsconfigAliases(repoDir);
+    const symbolTable = createSymbolTable();
+    const importMap = createImportMap();
+    const importEdges = [];
+    for (const f of rawGraph.functions) {
+        symbolTable.add(f.file, f.name, f.qualified);
+    }
+    for (const c of rawGraph.classes) {
+        symbolTable.add(c.file, c.name, c.qualified);
+    }
+    for (const i of rawGraph.interfaces) {
+        symbolTable.add(i.file, i.name, i.qualified);
+    }
+    for (const imp of rawGraph.imports) {
+        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({
+            source: imp.file,
+            target: resolvedRel || imp.module,
+            resolved: !!resolvedRel,
+            line: imp.line,
+        });
+        const target = resolvedRel || imp.module;
+        for (const name of imp.names) {
+            importMap.add(imp.file, name, target);
+        }
+    }
+    const { callEdges } = resolveAllCalls(rawGraph.rawCalls, rawGraph.diMaps, symbolTable, importMap);
+    const fileHashes = new Map();
+    for (const f of absFiles) {
+        try {
+            fileHashes.set(relative(repoDir, f), computeFileHash(f));
+        }
+        catch { }
+    }
+    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));
+    const result = computeStructuralDiff(oldGraph, newGraphData.nodes, newGraphData.edges, relChangedFiles);
+    process.stderr.write(`[4/4] Diff: +${result.summary.added} -${result.summary.removed} ~${result.summary.modified} nodes (${Math.round(performance.now() - t0)}ms)\n`);
+    writeFileSync(opts.out, JSON.stringify(result, null, 2));
+}

package/dist/commands/flows.d.ts

@@ -0,0 +1,8 @@
+interface FlowsCommandOptions {
+    graph: string;
+    out: string;
+    maxDepth: number;
+    type: 'test' | 'http' | 'all';
+}
+export declare function executeFlows(opts: FlowsCommandOptions): void;
+export {};

package/dist/commands/flows.js

@@ -0,0 +1,9 @@
+import { writeFileSync } from 'fs';
+import { detectFlows } from '../analysis/flows';
+import { loadGraph } from '../graph/loader';
+export function executeFlows(opts) {
+    const graph = loadGraph(opts.graph);
+    const result = detectFlows(graph, { maxDepth: opts.maxDepth, type: opts.type });
+    writeFileSync(opts.out, JSON.stringify(result, null, 2));
+    process.stderr.write(`Flows: ${result.summary.total_flows} detected (test:${result.summary.by_type.test} http:${result.summary.by_type.http}), avg depth ${result.summary.avg_depth}\n`);
+}

package/dist/commands/parse.d.ts

@@ -0,0 +1,11 @@
+export interface ParseOptions {
+    repoDir: string;
+    files?: string[];
+    all: boolean;
+    out: string;
+    include?: string[];
+    exclude?: string[];
+    skipTests?: boolean;
+    maxMemoryMB?: number;
+}
+export declare function executeParse(opts: ParseOptions): Promise<void>;

package/dist/commands/parse.js

@@ -0,0 +1,101 @@
+import { relative, resolve } from 'path';
+import { performance } from 'perf_hooks';
+import { buildGraphData } from '../graph/builder';
+import { writeGraphJSON } from '../graph/json-writer';
+import { parseBatch } from '../parser/batch';
+import { discoverFiles } from '../parser/discovery';
+import { resolveAllCalls } from '../resolver/call-resolver';
+import { createImportMap } from '../resolver/import-map';
+import { loadTsconfigAliases, resolveImport } from '../resolver/import-resolver';
+import { buildReExportMap } from '../resolver/re-export-resolver';
+import { createSymbolTable } from '../resolver/symbol-table';
+import { computeFileHash } from '../shared/file-hash';
+import { log } from '../shared/logger';
+export async function executeParse(opts) {
+    const t0 = performance.now();
+    const repoDir = resolve(opts.repoDir);
+    // Phase 1: Discover files
+    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, 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);
+    let symbolTable = createSymbolTable();
+    let importMap = createImportMap();
+    let importEdges = [];
+    for (const f of rawGraph.functions) {
+        symbolTable.add(f.file, f.name, f.qualified);
+    }
+    for (const c of rawGraph.classes) {
+        symbolTable.add(c.file, c.name, c.qualified);
+    }
+    for (const i of rawGraph.interfaces) {
+        symbolTable.add(i.file, i.name, i.qualified);
+    }
+    // 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;
+        const resolved = resolveImport(resolve(repoDir, imp.file), imp.module, langKey, repoDir, tsconfigAliases);
+        const resolvedRel = resolved ? relative(repoDir, resolved) : null;
+        importEdges.push({
+            source: imp.file,
+            target: resolvedRel || imp.module,
+            resolved: !!resolvedRel,
+            line: imp.line,
+        });
+        const target = resolvedRel || imp.module;
+        for (const name of imp.names) {
+            // If target is a barrel file, follow re-exports to find the actual definition
+            let finalTarget = target;
+            if (resolvedRel) {
+                const reExportedFiles = barrelMap.get(resolvedRel);
+                if (reExportedFiles) {
+                    for (const reFile of reExportedFiles) {
+                        if (symbolTable.lookupExact(reFile, name)) {
+                            finalTarget = reFile;
+                            break;
+                        }
+                    }
+                }
+            }
+            importMap.add(imp.file, name, finalTarget);
+        }
+    }
+    process.stderr.write(`[3/5] Resolved ${importEdges.filter((e) => e.resolved).length}/${importEdges.length} imports\n`);
+    // Phase 4: Resolve calls
+    let { callEdges, stats } = resolveAllCalls(rawGraph.rawCalls, rawGraph.diMaps, symbolTable, importMap);
+    process.stderr.write(`[4/5] Resolved ${callEdges.length} calls (DI:${stats.di} same:${stats.same} import:${stats.import} unique:${stats.unique} ambiguous:${stats.ambiguous} noise:${stats.noise})\n`);
+    // Phase 5: Build output
+    const fileHashes = new Map();
+    for (const f of files) {
+        try {
+            fileHashes.set(relative(repoDir, f), computeFileHash(f));
+        }
+        catch (err) {
+            log.warn('Failed to compute file hash', { file: f, error: String(err) });
+        }
+    }
+    const parseErrors = rawGraph.parseErrors;
+    const extractErrors = rawGraph.extractErrors;
+    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;
+    symbolTable = null;
+    importMap = null;
+    callEdges = null;
+    importEdges = null;
+    const metadata = {
+        repo_dir: repoDir,
+        files_parsed: files.length,
+        total_nodes: graphData.nodes.length,
+        total_edges: graphData.edges.length,
+        duration_ms: Math.round(performance.now() - t0),
+        parse_errors: parseErrors,
+        extract_errors: extractErrors,
+    };
+    writeGraphJSON(opts.out, metadata, graphData.nodes, graphData.edges);
+}

package/dist/commands/search.d.ts

@@ -0,0 +1,12 @@
+interface SearchCommandOptions {
+    graph: string;
+    query?: string;
+    kind?: string;
+    file?: string;
+    callersOf?: string;
+    calleesOf?: string;
+    limit: number;
+    out?: string;
+}
+export declare function executeSearch(opts: SearchCommandOptions): void;
+export {};

package/dist/commands/search.js

@@ -0,0 +1,27 @@
+import { writeFileSync } from 'fs';
+import { findCallees, findCallers, searchNodes } from '../analysis/search';
+import { loadGraph } from '../graph/loader';
+export function executeSearch(opts) {
+    const graph = loadGraph(opts.graph);
+    let results;
+    let queryInfo;
+    if (opts.callersOf) {
+        results = findCallers(graph, opts.callersOf);
+        queryInfo = { callers_of: opts.callersOf, kind: null, file: null };
+    }
+    else if (opts.calleesOf) {
+        results = findCallees(graph, opts.calleesOf);
+        queryInfo = { callees_of: opts.calleesOf, kind: null, file: null };
+    }
+    else {
+        results = searchNodes(graph, { query: opts.query, kind: opts.kind, file: opts.file, limit: opts.limit });
+        queryInfo = { pattern: opts.query || null, kind: opts.kind || null, file: opts.file || null };
+    }
+    const output = JSON.stringify({ results, total: results.length, query: queryInfo }, null, 2);
+    if (opts.out) {
+        writeFileSync(opts.out, output);
+    }
+    else {
+        process.stdout.write(`${output}\n`);
+    }
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,7 @@
+interface UpdateCommandOptions {
+    repoDir: string;
+    graph?: string;
+    out?: string;
+}
+export declare function executeUpdate(opts: UpdateCommandOptions): Promise<void>;
+export {};

package/dist/commands/update.js

@@ -0,0 +1,154 @@
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { dirname, relative, resolve } from 'path';
+import { performance } from 'perf_hooks';
+import { buildGraphData } from '../graph/builder';
+import { loadGraph } from '../graph/loader';
+import { parseBatch } from '../parser/batch';
+import { discoverFiles } from '../parser/discovery';
+import { resolveAllCalls } from '../resolver/call-resolver';
+import { createImportMap } from '../resolver/import-map';
+import { loadTsconfigAliases, resolveImport } from '../resolver/import-resolver';
+import { createSymbolTable } from '../resolver/symbol-table';
+import { computeFileHash } from '../shared/file-hash';
+import { log } from '../shared/logger';
+const DEFAULT_GRAPH_PATH = '.kodus-graph/graph.json';
+export async function executeUpdate(opts) {
+    const t0 = performance.now();
+    const repoDir = resolve(opts.repoDir);
+    const graphPath = resolve(repoDir, opts.graph || DEFAULT_GRAPH_PATH);
+    const outPath = resolve(repoDir, opts.out || opts.graph || DEFAULT_GRAPH_PATH);
+    if (!existsSync(graphPath)) {
+        log.error('graph file not found — run "kodus-graph parse" first', { path: graphPath });
+        process.exit(1);
+    }
+    const oldGraph = loadGraph(graphPath);
+    process.stderr.write(`[1/5] Loaded previous graph (${oldGraph.nodes.length} nodes)\n`);
+    // Build file hash index from old graph
+    const oldHashes = new Map();
+    for (const node of oldGraph.nodes) {
+        if (node.file_hash && !oldHashes.has(node.file_path)) {
+            oldHashes.set(node.file_path, node.file_hash);
+        }
+    }
+    // Discover current files
+    const allFiles = discoverFiles(repoDir);
+    const allRel = allFiles.map((f) => relative(repoDir, f));
+    const currentFiles = new Set(allRel);
+    const oldFiles = new Set(oldHashes.keys());
+    // Classify files
+    const added = [];
+    const modified = [];
+    const deleted = [];
+    const unchanged = [];
+    for (const file of currentFiles) {
+        const absPath = resolve(repoDir, file);
+        if (!oldHashes.has(file)) {
+            added.push(file);
+        }
+        else {
+            const currentHash = computeFileHash(absPath);
+            if (currentHash !== oldHashes.get(file)) {
+                modified.push(file);
+            }
+            else {
+                unchanged.push(file);
+            }
+        }
+    }
+    for (const file of oldFiles) {
+        if (!currentFiles.has(file)) {
+            deleted.push(file);
+        }
+    }
+    const toReparse = [...added, ...modified];
+    process.stderr.write(`[2/5] Files: ${added.length} added, ${modified.length} modified, ${deleted.length} deleted, ${unchanged.length} unchanged\n`);
+    if (toReparse.length === 0 && deleted.length === 0) {
+        process.stderr.write('[3/5] No changes detected, graph is up to date\n');
+        const output = {
+            metadata: {
+                ...oldGraph.metadata,
+                duration_ms: Math.round(performance.now() - t0),
+                files_unchanged: unchanged.length,
+                incremental: true,
+            },
+            nodes: oldGraph.nodes,
+            edges: oldGraph.edges,
+        };
+        ensureDir(outPath);
+        writeFileSync(outPath, JSON.stringify(output, null, 2));
+        return;
+    }
+    // Re-parse changed files
+    const absToReparse = toReparse.map((f) => resolve(repoDir, f));
+    const rawGraph = await parseBatch(absToReparse, repoDir);
+    process.stderr.write(`[3/5] Re-parsed ${toReparse.length} files\n`);
+    // Resolve imports and calls for new files
+    const tsconfigAliases = loadTsconfigAliases(repoDir);
+    const symbolTable = createSymbolTable();
+    const importMap = createImportMap();
+    const importEdges = [];
+    for (const f of rawGraph.functions) {
+        symbolTable.add(f.file, f.name, f.qualified);
+    }
+    for (const c of rawGraph.classes) {
+        symbolTable.add(c.file, c.name, c.qualified);
+    }
+    for (const i of rawGraph.interfaces) {
+        symbolTable.add(i.file, i.name, i.qualified);
+    }
+    for (const imp of rawGraph.imports) {
+        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({
+            source: imp.file,
+            target: resolvedRel || imp.module,
+            resolved: !!resolvedRel,
+            line: imp.line,
+        });
+        const target = resolvedRel || imp.module;
+        for (const name of imp.names) {
+            importMap.add(imp.file, name, target);
+        }
+    }
+    const { callEdges } = resolveAllCalls(rawGraph.rawCalls, rawGraph.diMaps, symbolTable, importMap);
+    const fileHashes = new Map();
+    for (const f of absToReparse) {
+        try {
+            fileHashes.set(relative(repoDir, f), computeFileHash(f));
+        }
+        catch { }
+    }
+    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]);
+    const mergedNodes = oldGraph.nodes.filter((n) => !changedOrDeleted.has(n.file_path));
+    const mergedEdges = oldGraph.edges.filter((e) => !changedOrDeleted.has(e.file_path));
+    mergedNodes.push(...newGraphData.nodes);
+    mergedEdges.push(...newGraphData.edges);
+    process.stderr.write(`[5/5] Merged: ${mergedNodes.length} nodes, ${mergedEdges.length} edges\n`);
+    const output = {
+        metadata: {
+            repo_dir: repoDir,
+            files_parsed: toReparse.length,
+            files_unchanged: unchanged.length,
+            total_nodes: mergedNodes.length,
+            total_edges: mergedEdges.length,
+            duration_ms: Math.round(performance.now() - t0),
+            parse_errors: rawGraph.parseErrors,
+            extract_errors: rawGraph.extractErrors,
+            incremental: true,
+        },
+        nodes: mergedNodes,
+        edges: mergedEdges,
+    };
+    ensureDir(outPath);
+    writeFileSync(outPath, JSON.stringify(output, null, 2));
+}
+function ensureDir(filePath) {
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}

package/dist/graph/builder.d.ts

@@ -0,0 +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>, symbolTable?: {
+    lookupGlobal(name: string): string[];
+}, importMap?: {
+    lookup(file: string, name: string): string | null;
+}): GraphData;

package/dist/graph/builder.js

@@ -0,0 +1,248 @@
+import { deriveEdges } from './edges';
+export function buildGraphData(raw, callEdges, importEdges, _repoDir, fileHashes, symbolTable, importMap) {
+    const nodes = [];
+    const edges = [];
+    // Functions -> nodes
+    for (const f of raw.functions) {
+        nodes.push({
+            kind: f.kind,
+            ast_kind: f.ast_kind,
+            name: f.name,
+            qualified_name: f.qualified,
+            file_path: f.file,
+            line_start: f.line_start,
+            line_end: f.line_end,
+            language: detectLang(f.file),
+            parent_name: f.className || undefined,
+            params: f.params || undefined,
+            return_type: f.returnType || undefined,
+            is_test: false,
+            file_hash: fileHashes.get(f.file) || '',
+            content_hash: f.content_hash,
+        });
+    }
+    // Classes -> nodes
+    for (const c of raw.classes) {
+        nodes.push({
+            kind: 'Class',
+            ast_kind: c.ast_kind,
+            name: c.name,
+            qualified_name: c.qualified,
+            file_path: c.file,
+            line_start: c.line_start,
+            line_end: c.line_end,
+            language: detectLang(c.file),
+            is_test: false,
+            file_hash: fileHashes.get(c.file) || '',
+            content_hash: c.content_hash,
+        });
+    }
+    // Interfaces -> nodes
+    for (const i of raw.interfaces) {
+        nodes.push({
+            kind: 'Interface',
+            ast_kind: i.ast_kind,
+            name: i.name,
+            qualified_name: i.qualified,
+            file_path: i.file,
+            line_start: i.line_start,
+            line_end: i.line_end,
+            language: detectLang(i.file),
+            is_test: false,
+            file_hash: fileHashes.get(i.file) || '',
+            content_hash: i.content_hash,
+        });
+    }
+    // Enums -> nodes
+    for (const e of raw.enums) {
+        nodes.push({
+            kind: 'Enum',
+            ast_kind: e.ast_kind,
+            name: e.name,
+            qualified_name: e.qualified,
+            file_path: e.file,
+            line_start: e.line_start,
+            line_end: e.line_end,
+            language: detectLang(e.file),
+            is_test: false,
+            file_hash: fileHashes.get(e.file) || '',
+            content_hash: e.content_hash,
+        });
+    }
+    // Tests -> nodes
+    for (const t of raw.tests) {
+        nodes.push({
+            kind: 'Test',
+            ast_kind: t.ast_kind,
+            name: t.name,
+            qualified_name: t.qualified,
+            file_path: t.file,
+            line_start: t.line_start,
+            line_end: t.line_end,
+            language: detectLang(t.file),
+            is_test: true,
+            file_hash: fileHashes.get(t.file) || '',
+            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) {
+        if (node.kind === 'Class' || node.kind === 'Interface' || node.kind === 'Enum') {
+            continue;
+        }
+        const entry = { qualified_name: node.qualified_name, line_start: node.line_start, line_end: node.line_end };
+        const list = functionsByFile.get(node.file_path);
+        if (list) {
+            list.push(entry);
+        }
+        else {
+            functionsByFile.set(node.file_path, [entry]);
+        }
+    }
+    // Sort descending by line_start so inner/nested functions match first
+    for (const list of functionsByFile.values()) {
+        list.sort((a, b) => b.line_start - a.line_start);
+    }
+    // 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('::')) {
+            sourceQualified = ce.source;
+        }
+        else {
+            // Find the innermost function containing this call line
+            const fns = functionsByFile.get(ce.source);
+            let resolved;
+            if (fns) {
+                for (const fn of fns) {
+                    if (ce.line >= fn.line_start && ce.line <= fn.line_end) {
+                        resolved = fn.qualified_name;
+                        break;
+                    }
+                }
+            }
+            sourceQualified = resolved || `${ce.source}::unknown`;
+        }
+        edges.push({
+            kind: 'CALLS',
+            source_qualified: sourceQualified,
+            target_qualified: ce.target,
+            file_path: sourceFile,
+            line: ce.line,
+            confidence: ce.confidence,
+        });
+    }
+    // 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,
+            target_qualified: ie.target,
+            file_path: ie.source,
+            line: ie.line,
+        });
+    }
+    // Derived edges
+    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',
+            source_qualified: e.source,
+            target_qualified: e.target,
+            file_path: e.file || '',
+            line: 0,
+        });
+    }
+    for (const e of derived.implements) {
+        edges.push({
+            kind: 'IMPLEMENTS',
+            source_qualified: e.source,
+            target_qualified: e.target,
+            file_path: e.file || '',
+            line: 0,
+        });
+    }
+    for (const e of derived.testedBy) {
+        edges.push({
+            kind: 'TESTED_BY',
+            source_qualified: e.source,
+            target_qualified: e.target,
+            file_path: e.target || '',
+            line: 0,
+        });
+    }
+    for (const e of derived.contains) {
+        edges.push({
+            kind: 'CONTAINS',
+            source_qualified: e.source,
+            target_qualified: e.target,
+            file_path: e.source,
+            line: 0,
+        });
+    }
+    return { nodes, edges };
+}
+function detectLang(file) {
+    if (file.endsWith('.ts') || file.endsWith('.tsx')) {
+        return 'typescript';
+    }
+    if (file.endsWith('.js') || file.endsWith('.jsx') || file.endsWith('.mjs') || file.endsWith('.cjs')) {
+        return 'javascript';
+    }
+    if (file.endsWith('.py')) {
+        return 'python';
+    }
+    if (file.endsWith('.rb')) {
+        return 'ruby';
+    }
+    if (file.endsWith('.go')) {
+        return 'go';
+    }
+    if (file.endsWith('.java')) {
+        return 'java';
+    }
+    if (file.endsWith('.rs')) {
+        return 'rust';
+    }
+    if (file.endsWith('.cs')) {
+        return 'csharp';
+    }
+    if (file.endsWith('.php')) {
+        return 'php';
+    }
+    return 'unknown';
+}