@kodus/kodus-graph 0.2.3 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kodus/kodus-graph",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "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,10 @@ 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');
+      // Only flag line_range when the file content actually changed (different file_hash).
+      // When file_hash matches, line shifts are just displacement from other edits — not real modifications.
+      const hashChanged = !n.file_hash || !newN.file_hash || n.file_hash !== newN.file_hash;
+      if (hashChanged && (n.line_start !== newN.line_start || n.line_end !== newN.line_end)) 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/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;
+}