@kodus/kodus-graph 0.2.3 → 0.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kodus/kodus-graph",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Code graph builder for Kodus code review — parses source code into structural graphs with nodes, edges, and analysis",
   "type": "module",
   "bin": {

package/src/analysis/diff.ts

@@ -74,7 +74,19 @@ export function computeStructuralDiff(
     } else {
       const newN = newNodesMap.get(qn)!;
       const changes: string[] = [];
-      if (n.line_start !== newN.line_start || n.line_end !== newN.line_end) changes.push('line_range');
+      // Detect real changes vs. pure displacement using content_hash.
+      // content_hash is per-node (SHA256 of the function/class source text).
+      // If both have content_hash: definitive comparison — same hash = identical content.
+      // If either is missing (legacy data): fallback to size heuristic.
+      if (n.line_start !== newN.line_start || n.line_end !== newN.line_end) {
+        if (n.content_hash && newN.content_hash) {
+          if (n.content_hash !== newN.content_hash) changes.push('line_range');
+        } else {
+          const oldSize = n.line_end - n.line_start;
+          const newSize = newN.line_end - newN.line_start;
+          if (oldSize !== newSize) changes.push('line_range');
+        }
+      }
       if ((n.params || '') !== (newN.params || '')) changes.push('params');
       if ((n.return_type || '') !== (newN.return_type || '')) changes.push('return_type');
       if (changes.length > 0) modified.push({ qualified_name: qn, changes });

package/src/analysis/enrich.ts

@@ -50,14 +50,15 @@ export function enrichChangedFunctions(
       const callers: CallerRef[] = [];
       for (const edge of graph.reverseAdjacency.get(node.qualified_name) || []) {
         if (edge.kind !== 'CALLS') continue;
-        if ((edge.confidence ?? 0) < minConfidence) continue;
+        // null/undefined confidence = high confidence (edge came from DB or parser without scoring)
+        if ((edge.confidence ?? 1.0) < minConfidence) continue;
         const sourceNode = graph.byQualified.get(edge.source_qualified);
         callers.push({
           qualified_name: edge.source_qualified,
           name: sourceNode?.name || edge.source_qualified.split('::').pop() || 'unknown',
           file_path: sourceNode?.file_path || edge.file_path,
           line: edge.line,
-          confidence: edge.confidence || 0,
+          confidence: edge.confidence ?? 1.0,
         });
       }
 

package/src/cli.ts

@@ -13,7 +13,8 @@ import { executeUpdate } from './commands/update';
 
 const program = new Command();
 
-program.name('kodus-graph').description('Code graph builder for Kodus code review').version('0.2.1');
+import pkg from '../package.json';
+program.name('kodus-graph').description('Code graph builder for Kodus code review').version(pkg.version);
 
 program
   .command('parse')

package/src/commands/analyze.ts

@@ -1,13 +1,20 @@
 import { readFileSync, writeFileSync } from 'fs';
-import { resolve } from 'path';
+import { resolve, relative } from 'path';
 import { computeBlastRadius } from '../analysis/blast-radius';
 import { computeRiskScore } from '../analysis/risk-score';
 import { findTestGaps } from '../analysis/test-gaps';
 import { buildGraphData } from '../graph/builder';
 import { mergeGraphs } from '../graph/merger';
-import type { AnalysisOutput, MainGraphInput } from '../graph/types';
+import type { AnalysisOutput, ImportEdge, MainGraphInput } from '../graph/types';
 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';
 import { GraphInputSchema } from '../shared/schemas';
 
 interface AnalyzeOptions {
@@ -46,7 +53,62 @@ export async function executeAnalyze(opts: AnalyzeOptions): Promise<void> {
   // Parse changed files locally
   const localFiles = discoverFiles(repoDir, opts.files);
   const rawGraph = await parseBatch(localFiles, repoDir);
-  const localGraphData = buildGraphData(rawGraph, [], [], repoDir, new Map());
+
+  // Resolve imports
+  const tsconfigAliases = loadTsconfigAliases(repoDir);
+  const symbolTable = createSymbolTable();
+  const importMap = createImportMap();
+  const importEdges: ImportEdge[] = [];
+
+  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 === 'python' ? 'python' : imp.lang === 'ruby' ? 'ruby' : 'typescript';
+    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) {
+      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);
+    }
+  }
+
+  // Resolve calls
+  const { callEdges } = resolveAllCalls(rawGraph.rawCalls, rawGraph.diMaps, symbolTable, importMap);
+
+  // Build graph with file hashes
+  const fileHashes = new Map<string, string>();
+  for (const f of localFiles) {
+    try {
+      fileHashes.set(relative(repoDir, f), computeFileHash(f));
+    } catch (err) {
+      log.warn('Failed to compute file hash', { file: f, error: String(err) });
+    }
+  }
+
+  const localGraphData = buildGraphData(rawGraph, callEdges, importEdges, repoDir, fileHashes);
 
   // Merge with main graph (or use local only)
   const mergedGraph = mainGraph ? mergeGraphs(mainGraph, localGraphData, opts.files) : localGraphData;

package/src/commands/parse.ts

@@ -8,6 +8,7 @@ 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';
@@ -45,6 +46,9 @@ export async function executeParse(opts: ParseOptions): Promise<void> {
   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 === 'python' ? 'python' : imp.lang === 'ruby' ? 'ruby' : 'typescript';
     const resolved = resolveImport(resolve(repoDir, imp.file), imp.module, langKey, repoDir, tsconfigAliases);
@@ -56,7 +60,22 @@ export async function executeParse(opts: ParseOptions): Promise<void> {
       line: imp.line,
     });
     const target = resolvedRel || imp.module;
-    for (const name of imp.names) importMap.add(imp.file, name, target);
+    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(

package/src/graph/builder.ts

@@ -26,6 +26,7 @@ export function buildGraphData(
       return_type: f.returnType || undefined,
       is_test: false,
       file_hash: fileHashes.get(f.file) || '',
+      content_hash: f.content_hash,
     });
   }
 
@@ -41,6 +42,7 @@ export function buildGraphData(
       language: detectLang(c.file),
       is_test: false,
       file_hash: fileHashes.get(c.file) || '',
+      content_hash: c.content_hash,
     });
   }
 
@@ -56,6 +58,7 @@ export function buildGraphData(
       language: detectLang(i.file),
       is_test: false,
       file_hash: fileHashes.get(i.file) || '',
+      content_hash: i.content_hash,
     });
   }
 
@@ -71,6 +74,7 @@ export function buildGraphData(
       language: detectLang(e.file),
       is_test: false,
       file_hash: fileHashes.get(e.file) || '',
+      content_hash: e.content_hash,
     });
   }
 
@@ -86,6 +90,7 @@ export function buildGraphData(
       language: detectLang(t.file),
       is_test: true,
       file_hash: fileHashes.get(t.file) || '',
+      content_hash: t.content_hash,
     });
   }
 

package/src/graph/types.ts

@@ -19,6 +19,7 @@ export interface GraphNode {
   modifiers?: string;
   is_test: boolean;
   file_hash: string;
+  content_hash?: string;
 }
 
 // ── Graph edge (matches ast_edges table) ──
@@ -185,6 +186,7 @@ export interface RawFunction {
   kind: 'Function' | 'Method' | 'Constructor';
   className: string;
   qualified: string;
+  content_hash?: string;
 }
 
 export interface RawClass {
@@ -195,6 +197,7 @@ export interface RawClass {
   extends: string;
   implements: string;
   qualified: string;
+  content_hash?: string;
 }
 
 export interface RawInterface {
@@ -204,6 +207,7 @@ export interface RawInterface {
   line_end: number;
   methods: string[];
   qualified: string;
+  content_hash?: string;
 }
 
 export interface RawEnum {
@@ -212,6 +216,7 @@ export interface RawEnum {
   line_start: number;
   line_end: number;
   qualified: string;
+  content_hash?: string;
 }
 
 export interface RawTest {
@@ -220,6 +225,7 @@ export interface RawTest {
   line_start: number;
   line_end: number;
   qualified: string;
+  content_hash?: string;
 }
 
 export interface RawImport {

package/src/parser/extractors/generic.ts

@@ -1,5 +1,6 @@
 import type { SgNode, SgRoot } from '@ast-grep/napi';
 import type { RawCallSite, RawGraph } from '../../graph/types';
+import { computeContentHash } from '../../shared/file-hash';
 import { NOISE } from '../../shared/filters';
 import { log } from '../../shared/logger';
 import { LANG_KINDS } from '../languages';
@@ -24,6 +25,7 @@ export function extractGeneric(root: SgRoot, fp: string, lang: string, seen: Set
           extends: '',
           implements: '',
           qualified: `${fp}::${name}`,
+          content_hash: computeContentHash(node.text()),
         });
       }
     } catch (err) {
@@ -58,6 +60,7 @@ export function extractGeneric(root: SgRoot, fp: string, lang: string, seen: Set
           kind: className ? 'Method' : 'Function',
           className,
           qualified: className ? `${fp}::${className}.${name}` : `${fp}::${name}`,
+          content_hash: computeContentHash(node.text()),
         });
       }
     } catch (err) {

package/src/parser/extractors/python.ts

@@ -1,5 +1,6 @@
 import type { SgNode, SgRoot } from '@ast-grep/napi';
 import type { RawCallSite, RawGraph } from '../../graph/types';
+import { computeContentHash } from '../../shared/file-hash';
 import { NOISE } from '../../shared/filters';
 import { LANG_KINDS } from '../languages';
 
@@ -28,6 +29,7 @@ export function extractPython(root: SgRoot, fp: string, seen: Set<string>, graph
       extends: extendsName,
       implements: '',
       qualified: `${fp}::${name}`,
+      content_hash: computeContentHash(node.text()),
     });
   }
 
@@ -55,6 +57,7 @@ export function extractPython(root: SgRoot, fp: string, seen: Set<string>, graph
         line_start: line,
         line_end: node.range().end.line,
         qualified: `${fp}::test:${name}`,
+        content_hash: computeContentHash(node.text()),
       });
     }
 
@@ -68,6 +71,7 @@ export function extractPython(root: SgRoot, fp: string, seen: Set<string>, graph
       kind: name === '__init__' ? 'Constructor' : className ? 'Method' : 'Function',
       className,
       qualified: className ? `${fp}::${className}.${name}` : `${fp}::${name}`,
+      content_hash: computeContentHash(node.text()),
     });
   }
 

package/src/parser/extractors/ruby.ts

@@ -1,5 +1,6 @@
 import type { SgNode, SgRoot } from '@ast-grep/napi';
 import type { RawCallSite, RawGraph } from '../../graph/types';
+import { computeContentHash } from '../../shared/file-hash';
 import { NOISE } from '../../shared/filters';
 import { log } from '../../shared/logger';
 import { LANG_KINDS } from '../languages';
@@ -23,6 +24,7 @@ export function extractRuby(root: SgRoot, fp: string, seen: Set<string>, graph:
       extends: superclass,
       implements: '',
       qualified: `${fp}::${name}`,
+      content_hash: computeContentHash(node.text()),
     });
   }
 
@@ -39,6 +41,7 @@ export function extractRuby(root: SgRoot, fp: string, seen: Set<string>, graph:
       extends: '',
       implements: '',
       qualified: `${fp}::${name}`,
+      content_hash: computeContentHash(node.text()),
     });
   }
 
@@ -63,6 +66,7 @@ export function extractRuby(root: SgRoot, fp: string, seen: Set<string>, graph:
       kind: className ? 'Method' : 'Function',
       className,
       qualified: className ? `${fp}::${className}.${name}` : `${fp}::${name}`,
+      content_hash: computeContentHash(node.text()),
     });
   }
 
@@ -88,6 +92,7 @@ export function extractRuby(root: SgRoot, fp: string, seen: Set<string>, graph:
           line_start: m.range().start.line,
           line_end: m.range().end.line,
           qualified: `${fp}::test:${name}`,
+          content_hash: computeContentHash(m.text()),
         });
       }
     } catch (err) {

package/src/parser/extractors/typescript.ts

@@ -1,6 +1,7 @@
 import type { SgNode, SgRoot } from '@ast-grep/napi';
 import { Lang } from '@ast-grep/napi';
 import type { RawCallSite, RawGraph } from '../../graph/types';
+import { computeContentHash } from '../../shared/file-hash';
 import { NOISE } from '../../shared/filters';
 import { LANG_KINDS } from '../languages';
 
@@ -52,6 +53,7 @@ export function extractTypeScript(
         extends: extendsName,
         implements: implementsName,
         qualified: `${fp}::${name}`,
+        content_hash: computeContentHash(node.text()),
       });
     }
   }
@@ -112,6 +114,7 @@ export function extractTypeScript(
         kind: 'Constructor',
         className,
         qualified: `${fp}::${className}.constructor`,
+        content_hash: computeContentHash(node.text()),
       });
     } else {
       graph.functions.push({
@@ -124,6 +127,7 @@ export function extractTypeScript(
         kind: className ? 'Method' : 'Function',
         className,
         qualified: className ? `${fp}::${className}.${name}` : `${fp}::${name}`,
+        content_hash: computeContentHash(node.text()),
       });
     }
   }
@@ -148,6 +152,7 @@ export function extractTypeScript(
       kind: 'Function',
       className: '',
       qualified: `${fp}::${name}`,
+      content_hash: computeContentHash(node.text()),
     });
   }
 
@@ -172,6 +177,7 @@ export function extractTypeScript(
       kind: 'Function',
       className: '',
       qualified: `${fp}::${name}`,
+      content_hash: computeContentHash(node.text()),
     });
   }
 
@@ -198,6 +204,7 @@ export function extractTypeScript(
         line_end: node.range().end.line,
         methods,
         qualified: `${fp}::${name}`,
+        content_hash: computeContentHash(node.text()),
       });
     }
 
@@ -213,6 +220,7 @@ export function extractTypeScript(
         line_start: node.range().start.line,
         line_end: node.range().end.line,
         qualified: `${fp}::${name}`,
+        content_hash: computeContentHash(node.text()),
       });
     }
 
@@ -288,6 +296,7 @@ export function extractTypeScript(
         line_start: m.range().start.line,
         line_end: m.range().end.line,
         qualified: `${fp}::test:${name}`,
+        content_hash: computeContentHash(m.text()),
       });
     }
   }

package/src/resolver/call-resolver.ts

@@ -153,15 +153,44 @@ function resolveByName(
     return { target: candidates[0], confidence: 0.5, strategy: 'unique' };
   }
 
-  // Strategy 4: Ambiguous (0.30)
+  // Strategy 4: Ambiguous (0.30) — pick closest candidate by directory proximity
   const candidates = symbolTable.lookupGlobal(callName);
   if (candidates.length > 1) {
-    return { target: callName, confidence: 0.3, strategy: 'ambiguous' };
+    const best = pickClosestCandidate(candidates, currentFile);
+    return { target: best, confidence: 0.3, strategy: 'ambiguous' };
   }
 
   return null;
 }
 
+// ── Proximity-based candidate selection ──
+
+/**
+ * Pick the candidate whose file path is closest to the caller's file.
+ * Counts shared leading path segments — more shared = closer.
+ */
+function pickClosestCandidate(candidates: string[], callerFile: string): string {
+  const callerParts = callerFile.split('/');
+  let best = candidates[0];
+  let bestScore = -1;
+
+  for (const candidate of candidates) {
+    const candidateFile = candidate.includes('::') ? candidate.split('::')[0] : candidate;
+    const parts = candidateFile.split('/');
+    let shared = 0;
+    for (let i = 0; i < Math.min(callerParts.length, parts.length); i++) {
+      if (callerParts[i] === parts[i]) shared++;
+      else break;
+    }
+    if (shared > bestScore) {
+      bestScore = shared;
+      best = candidate;
+    }
+  }
+
+  return best;
+}
+
 // ── Public wrapper for unit testing ──
 
 export function resolveCall(

package/src/resolver/re-export-resolver.ts

@@ -0,0 +1,66 @@
+/**
+ * Re-export (barrel) resolver.
+ *
+ * Follows `export { X } from './module'` chains so that the import map
+ * points to the file where the symbol is actually defined, not the
+ * barrel index file.
+ *
+ * Without this, an import like `import { Foo } from '@lib'` resolves
+ * to `@lib/index.ts`, but `Foo` is defined in `@lib/foo.ts`.
+ * The call resolver can't find `Foo` in the barrel's symbol table and
+ * falls to lower-confidence tiers.
+ */
+
+import { relative, resolve } from 'path';
+import { resolveImport } from './import-resolver';
+
+interface RawReExport {
+  module: string;
+  file: string;
+  line: number;
+}
+
+/**
+ * Build a map: barrel file (relative) → list of resolved re-export target files (relative).
+ *
+ * Follows one level of re-exports (covers >95% of real-world barrel patterns).
+ */
+export function buildReExportMap(
+  reExports: RawReExport[],
+  repoDir: string,
+  tsconfigAliases?: Map<string, string[]>,
+): Map<string, string[]> {
+  const barrelMap = new Map<string, string[]>();
+
+  for (const re of reExports) {
+    const absFrom = resolve(repoDir, re.file);
+    const resolved = resolveImport(absFrom, re.module, 'typescript', repoDir, tsconfigAliases);
+    if (!resolved) continue;
+
+    const resolvedRel = relative(repoDir, resolved);
+    const list = barrelMap.get(re.file);
+    if (list) {
+      if (!list.includes(resolvedRel)) list.push(resolvedRel);
+    } else {
+      barrelMap.set(re.file, [resolvedRel]);
+    }
+  }
+
+  // Follow one extra level: if a re-export target is itself a barrel, flatten
+  for (const [barrel, targets] of barrelMap) {
+    const extra: string[] = [];
+    for (const target of targets) {
+      const nested = barrelMap.get(target);
+      if (nested) {
+        for (const n of nested) {
+          if (n !== barrel && !targets.includes(n) && !extra.includes(n)) {
+            extra.push(n);
+          }
+        }
+      }
+    }
+    if (extra.length > 0) targets.push(...extra);
+  }
+
+  return barrelMap;
+}

package/src/shared/file-hash.ts

@@ -5,3 +5,8 @@ export function computeFileHash(filePath: string): string {
   const content = readFileSync(filePath);
   return createHash('sha256').update(content).digest('hex');
 }
+
+/** Hash a node's source text (function body, class body, etc.) */
+export function computeContentHash(sourceText: string): string {
+  return createHash('sha256').update(sourceText).digest('hex');
+}

package/src/shared/schemas.ts

@@ -10,6 +10,7 @@ const GraphNodeSchema = z.object({
   language: z.string(),
   is_test: z.boolean(),
   file_hash: z.string(),
+  content_hash: z.string().optional(),
   parent_name: z.string().optional(),
   params: z.string().optional(),
   return_type: z.string().optional(),