@kodus/kodus-graph 0.2.11 → 0.2.13

package/dist/analysis/enrich.js

@@ -37,27 +37,55 @@ export function enrichChangedFunctions(graph, changedFiles, diff, allFlows, minC
         }
         return true;
     });
+    // Pre-index INHERITS edges: child → parent qualified name
+    const childToParent = new Map();
+    for (const edge of graph.edges) {
+        if (edge.kind === 'INHERITS') {
+            childToParent.set(edge.source_qualified, edge.target_qualified);
+        }
+    }
     return changedFunctions
         .sort((a, b) => a.file_path.localeCompare(b.file_path) || a.line_start - b.line_start)
         .map((node) => {
-        // Callers
+        // Callers — include both direct callers AND callers of the overridden parent method.
+        // When code calls `base.method()`, the edge points to the parent class method,
+        // so overrides show 0 callers without this inheritance resolution.
         const callers = [];
-        for (const edge of graph.reverseAdjacency.get(node.qualified_name) || []) {
-            if (edge.kind !== 'CALLS') {
-                continue;
+        const seenCallers = new Set();
+        const collectCallers = (targetQN) => {
+            for (const edge of graph.reverseAdjacency.get(targetQN) || []) {
+                if (edge.kind !== 'CALLS') {
+                    continue;
+                }
+                if (seenCallers.has(edge.source_qualified)) {
+                    continue;
+                }
+                if ((edge.confidence ?? 1.0) < minConfidence) {
+                    continue;
+                }
+                seenCallers.add(edge.source_qualified);
+                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 ?? 1.0,
+                });
             }
-            // null/undefined confidence = high confidence (edge came from DB or parser without scoring)
-            if ((edge.confidence ?? 1.0) < minConfidence) {
-                continue;
+        };
+        // Direct callers
+        collectCallers(node.qualified_name);
+        // Inherited callers: if this is a method override, also collect callers of the parent method.
+        // e.g. OptimizedCursorPaginator::get_result inherits callers of BasePaginator::get_result
+        const qnParts = node.qualified_name.split('::');
+        if (qnParts.length >= 3) {
+            const methodName = qnParts[qnParts.length - 1];
+            const className = qnParts.slice(0, -1).join('::');
+            const parentClass = childToParent.get(className);
+            if (parentClass) {
+                collectCallers(`${parentClass}::${methodName}`);
             }
-            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 ?? 1.0,
-            });
         }
         // Callees
         const callees = [];

package/dist/analysis/prompt-formatter.js

@@ -15,8 +15,9 @@ export function formatPrompt(output) {
     const risk = analysis.risk;
     const br = analysis.blast_radius;
     const meta = analysis.metadata;
-    // ── Header: one-line stats ──
-    lines.push(`${meta.changed_functions_count} changed | ${br.total_functions} impacted | ${br.total_files} files | risk ${risk.level} ${risk.score} | ${meta.untested_count} untested`);
+    // ── Header: one-line stats (untested scoped to changed functions only) ──
+    const changedUntested = analysis.changed_functions.filter((f) => !f.has_test_coverage).length;
+    lines.push(`${meta.changed_functions_count} changed (${changedUntested} untested) | ${br.total_functions} impacted | ${br.total_files} files | risk ${risk.level} ${risk.score}`);
     lines.push('');
     // ── Changed functions ──
     if (analysis.changed_functions.length > 0) {
@@ -26,8 +27,10 @@ export function formatPrompt(output) {
         for (const fn of analysis.changed_functions) {
             const status = fn.is_new ? 'new' : fn.diff_changes.length > 0 ? 'modified' : 'unchanged';
             const tested = fn.has_test_coverage ? 'tested' : 'untested';
+            // Class-qualified signature for methods (language-agnostic via qualified_name)
+            const displayName = classQualifiedSignature(fn.qualified_name, fn.signature);
             // Main line
-            lines.push(`  ${fn.signature} [${fn.file_path}:${fn.line_start}-${fn.line_end}] ${status} | ${fn.callers.length} callers | ${tested}`);
+            lines.push(`  ${displayName} [${fn.file_path}:${fn.line_start}-${fn.line_end}] ${status} | ${fn.callers.length} callers | ${tested}`);
             // Contract changes — high value for agent to spot breaking changes
             for (const cd of fn.contract_diffs) {
                 lines.push(`    ⚠ ${cd.field}: ${cd.old_value} → ${cd.new_value}`);
@@ -87,6 +90,15 @@ export function formatPrompt(output) {
             lines.push('');
         }
     }
+    // ── Imports for changed files (helps agent spot missing/new dependencies) ──
+    const importLines = buildImportsSection(output, analysis);
+    if (importLines.length > 0) {
+        lines.push('IMPORTS:');
+        for (const line of importLines) {
+            lines.push(line);
+        }
+        lines.push('');
+    }
     // ── Hierarchy (compact) ──
     if (analysis.inheritance.length > 0) {
         lines.push('HIERARCHY:');
@@ -136,6 +148,20 @@ export function formatPrompt(output) {
 function shortName(qualifiedName) {
     return qualifiedName.split('::').pop() || qualifiedName;
 }
+/**
+ * Build class-qualified signature for methods.
+ * "file::Class::method" + "method(params) -> ret" → "Class.method(params) -> ret"
+ * For top-level functions ("file::func"), returns signature as-is.
+ * Language-agnostic: works for any language since qualified_name always uses "::" separator.
+ */
+function classQualifiedSignature(qualifiedName, signature) {
+    const parts = qualifiedName.split('::');
+    if (parts.length < 3) {
+        return signature; // top-level function, no class
+    }
+    const className = parts[parts.length - 2];
+    return `${className}.${signature}`;
+}
 /**
  * Build a map of changed functions → sibling implementations.
  * A "sibling" is a function with the same method name in a class that shares
@@ -199,3 +225,53 @@ function buildSiblingMap(analysis, output) {
     }
     return result;
 }
+/**
+ * Build compact IMPORTS section for changed files.
+ * Shows each import edge from a changed file with:
+ *   - NEW tag if the import was added in this change (not in oldGraph)
+ *   - ⚠ UNRESOLVED if the import target has no corresponding node in the graph
+ * Groups by source file for readability.
+ */
+function buildImportsSection(output, analysis) {
+    const changedFiles = new Set(analysis.structural_diff.changed_files);
+    // Collect IMPORTS edges from changed files
+    const importEdges = output.graph.edges.filter((e) => e.kind === 'IMPORTS' && changedFiles.has(e.file_path));
+    if (importEdges.length === 0) {
+        return [];
+    }
+    // Set of new import edges (added in this diff)
+    const newImportKeys = new Set(analysis.structural_diff.edges.added
+        .filter((e) => e.kind === 'IMPORTS')
+        .map((e) => `${e.source_qualified}→${e.target_qualified}`));
+    // Set of all node qualified names — to detect unresolved targets
+    const allNodes = new Set(output.graph.nodes.map((n) => n.qualified_name));
+    // Group by source file
+    const byFile = new Map();
+    for (const edge of importEdges) {
+        const existing = byFile.get(edge.file_path) || [];
+        existing.push(edge);
+        byFile.set(edge.file_path, existing);
+    }
+    const lines = [];
+    for (const [filePath, edges] of byFile) {
+        for (const edge of edges) {
+            const key = `${edge.source_qualified}→${edge.target_qualified}`;
+            const tags = [];
+            if (newImportKeys.has(key)) {
+                tags.push('NEW');
+            }
+            // Check if target exists as a node in the graph
+            // For IMPORTS, target_qualified is usually "file::Symbol".
+            // If neither the exact target nor any node starting with the target exists, it's unresolved.
+            const targetExists = allNodes.has(edge.target_qualified) ||
+                // Also check if the target is a file-level reference (e.g. "src/utils.ts::default")
+                [...allNodes].some((qn) => qn.startsWith(`${edge.target_qualified}::`));
+            if (!targetExists) {
+                tags.push('⚠ UNRESOLVED');
+            }
+            const tagStr = tags.length > 0 ? ` (${tags.join(', ')})` : '';
+            lines.push(`  ${filePath} → ${shortName(edge.target_qualified)}${tagStr}`);
+        }
+    }
+    return lines;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kodus/kodus-graph",
-  "version": "0.2.11",
+  "version": "0.2.13",
   "description": "Code graph builder for Kodus code review — parses source code into structural graphs with nodes, edges, and analysis",
   "type": "module",
   "main": "./dist/cli.js",