@kodus/kodus-graph 0.2.1 → 0.2.3

package/package.json

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

package/src/commands/context.ts

@@ -50,7 +50,24 @@ export async function executeContext(opts: ContextOptions): Promise<void> {
         process.stderr.write(`Error: Invalid graph JSON: ${validated.error.message}\n`);
         process.exit(1);
       }
-      oldGraph = { nodes: validated.data.nodes, edges: validated.data.edges };
+      const changedSet = new Set(opts.files);
+      const sameBranch = detectSameBranch(validated.data.nodes, parseResult.nodes, changedSet);
+
+      if (sameBranch) {
+        // --graph was built from the same commit (e.g. kodus-ai's parse --all on PR branch).
+        // Exclude changed files from oldGraph so diff detects their functions as "added"
+        // instead of falsely marking everything "unchanged".
+        oldGraph = {
+          nodes: validated.data.nodes.filter((n: { file_path: string }) => !changedSet.has(n.file_path)),
+          edges: validated.data.edges.filter((e: { file_path: string }) => !changedSet.has(e.file_path)),
+        };
+        log.debug('Same-branch detected: excluding changed files from baseline', {
+          changedFiles: opts.files.length,
+        });
+      } else {
+        oldGraph = { nodes: validated.data.nodes, edges: validated.data.edges };
+      }
+
       const mainGraph: MainGraphInput = {
         repo_id: '',
         sha: '',
@@ -84,3 +101,39 @@ export async function executeContext(opts: ContextOptions): Promise<void> {
     }
   }
 }
+
+/**
+ * Detect if --graph was built from the same commit as the current repo.
+ * Compares file_hash values for changed files between the graph and the fresh parse.
+ * When hashes match, the graph can't serve as a baseline for diff — it IS the new state.
+ */
+function detectSameBranch(
+  graphNodes: Array<{ file_path: string; file_hash: string }>,
+  parseNodes: Array<{ file_path: string; file_hash: string }>,
+  changedFiles: Set<string>,
+): boolean {
+  const graphHashes = new Map<string, string>();
+  for (const n of graphNodes) {
+    if (changedFiles.has(n.file_path) && n.file_hash && !graphHashes.has(n.file_path)) {
+      graphHashes.set(n.file_path, n.file_hash);
+    }
+  }
+
+  // No overlap means graph has no nodes for changed files — not same-branch scenario
+  if (graphHashes.size === 0) return false;
+
+  const parseHashes = new Map<string, string>();
+  for (const n of parseNodes) {
+    if (n.file_hash && !parseHashes.has(n.file_path)) {
+      parseHashes.set(n.file_path, n.file_hash);
+    }
+  }
+
+  // If any overlapping file has different hash → different branch
+  for (const [file, hash] of graphHashes) {
+    const parseHash = parseHashes.get(file);
+    if (parseHash && parseHash !== hash) return false;
+  }
+
+  return true;
+}

package/src/graph/builder.ts

@@ -89,13 +89,47 @@ export function buildGraphData(
     });
   }
 
-  // CALLS edges
+  // Build file→functions index to resolve caller from line number
+  const functionsByFile = new Map<string, Array<{ qualified_name: string; line_start: number; line_end: number }>>();
+  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) {
+    const sourceFile = ce.source.includes('::') ? ce.source.split('::')[0] : ce.source;
+    let sourceQualified: string;
+
+    if (ce.source.includes('::')) {
+      sourceQualified = ce.source;
+    } else {
+      // Find the innermost function containing this call line
+      const fns = functionsByFile.get(ce.source);
+      let resolved: string | undefined;
+      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: ce.source.includes('::') ? ce.source : `${ce.source}::unknown`,
+      source_qualified: sourceQualified,
       target_qualified: ce.target,
-      file_path: ce.source.includes('::') ? ce.source.split('::')[0] : ce.source,
+      file_path: sourceFile,
       line: ce.line,
       confidence: ce.confidence,
     });