@kodus/kodus-graph 0.2.12 → 0.2.14

package/dist/analysis/context-builder.d.ts

@@ -1,6 +1,7 @@
 import type { AffectedFlow, ContextAnalysisMetadata, GraphData, GraphEdge, GraphNode, ParseMetadata } from '../graph/types';
 import { computeBlastRadius } from './blast-radius';
 import { type DiffResult } from './diff';
+import { type DiffHunk } from './diff-lines';
 import { enrichChangedFunctions } from './enrich';
 import { extractInheritance } from './inheritance';
 import { computeRiskScore } from './risk-score';
@@ -29,6 +30,8 @@ interface BuildContextV2Options {
     minConfidence: number;
     maxDepth: number;
     skipTests?: boolean;
+    /** Parsed diff hunks per file — used to filter changed functions in fallback mode (no oldGraph) */
+    diffHunks?: Map<string, DiffHunk[]>;
 }
 export declare function buildContextV2(opts: BuildContextV2Options): ContextV2Output;
 export {};

package/dist/analysis/context-builder.js

@@ -1,7 +1,9 @@
 import { performance } from 'perf_hooks';
 import { indexGraph } from '../graph/loader';
+import { log } from '../shared/logger';
 import { computeBlastRadius } from './blast-radius';
 import { computeStructuralDiff } from './diff';
+import { overlapsWithDiff } from './diff-lines';
 import { enrichChangedFunctions } from './enrich';
 import { detectFlows } from './flows';
 import { extractInheritance } from './inheritance';
@@ -24,6 +26,22 @@ export function buildContextV2(opts) {
         ...structuralDiff.nodes.modified.map((n) => n.qualified_name),
         ...structuralDiff.nodes.removed.map((n) => n.qualified_name),
     ]);
+    // In fallback mode (no oldGraph), ALL functions are "added" by structural diff.
+    // If we have actual diff hunks, filter to only functions whose lines overlap with real changes.
+    if (!oldGraph && opts.diffHunks && opts.diffHunks.size > 0) {
+        const before = trulyChangedQN.size;
+        for (const qn of [...trulyChangedQN]) {
+            const node = indexed.byQualified.get(qn);
+            if (node && !overlapsWithDiff(node.file_path, node.line_start, node.line_end, opts.diffHunks)) {
+                trulyChangedQN.delete(qn);
+            }
+        }
+        log.info('context: diff-hunk filter applied (fallback mode)', {
+            before,
+            after: trulyChangedQN.size,
+            filtered: before - trulyChangedQN.size,
+        });
+    }
     const blastRadius = computeBlastRadius(mergedGraph, [...trulyChangedQN], maxDepth, minConfidence);
     const allFlows = detectFlows(indexed, { maxDepth: 10, type: 'all' });
     const testGaps = opts.skipTests ? [] : findTestGaps(mergedGraph, changedFiles);

package/dist/analysis/diff-lines.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Parse unified diff output to extract changed line ranges per file.
+ * Used in fallback mode (no DB baseline) to filter which AST functions
+ * are truly "changed" vs just "present in the file".
+ */
+export interface DiffHunk {
+    /** First changed line on the new (post-change) side */
+    newStart: number;
+    /** Number of lines in this hunk on the new side */
+    newCount: number;
+}
+/**
+ * Parse a unified diff string into per-file hunk ranges.
+ *
+ * Accepts standard `git diff` / `git format-patch` output as well as
+ * GitHub-style patches (individual file patches concatenated).
+ *
+ * @returns Map from file path (relative, no leading slash) to its hunks
+ */
+export declare function parseDiffHunks(diffContent: string): Map<string, DiffHunk[]>;
+/**
+ * Check if a node's line range overlaps with any diff hunk in the same file.
+ *
+ * A node [lineStart, lineEnd] overlaps with a hunk [hunkStart, hunkEnd] when:
+ *   lineStart <= hunkEnd AND lineEnd >= hunkStart
+ */
+export declare function overlapsWithDiff(filePath: string, lineStart: number, lineEnd: number, diffHunks: Map<string, DiffHunk[]>): boolean;

package/dist/analysis/diff-lines.js

@@ -0,0 +1,71 @@
+/**
+ * Parse unified diff output to extract changed line ranges per file.
+ * Used in fallback mode (no DB baseline) to filter which AST functions
+ * are truly "changed" vs just "present in the file".
+ */
+/**
+ * Parse a unified diff string into per-file hunk ranges.
+ *
+ * Accepts standard `git diff` / `git format-patch` output as well as
+ * GitHub-style patches (individual file patches concatenated).
+ *
+ * @returns Map from file path (relative, no leading slash) to its hunks
+ */
+export function parseDiffHunks(diffContent) {
+    const result = new Map();
+    let currentFile = null;
+    for (const line of diffContent.split('\n')) {
+        // Match file header: +++ b/path/to/file
+        if (line.startsWith('+++ b/')) {
+            currentFile = line.slice(6);
+            if (!result.has(currentFile)) {
+                result.set(currentFile, []);
+            }
+            continue;
+        }
+        // Also handle +++ path (without b/ prefix, e.g. GitHub patch format)
+        if (line.startsWith('+++ ') && !line.startsWith('+++ /dev/null')) {
+            const path = line.slice(4).replace(/^a\/|^b\//, '');
+            if (path) {
+                currentFile = path;
+                if (!result.has(currentFile)) {
+                    result.set(currentFile, []);
+                }
+            }
+            continue;
+        }
+        // Match hunk header: @@ -oldStart,oldCount +newStart,newCount @@
+        if (line.startsWith('@@') && currentFile) {
+            const match = line.match(/@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+            if (match) {
+                const newStart = parseInt(match[1], 10);
+                const newCount = match[2] !== undefined ? parseInt(match[2], 10) : 1;
+                result.get(currentFile).push({ newStart, newCount });
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Check if a node's line range overlaps with any diff hunk in the same file.
+ *
+ * A node [lineStart, lineEnd] overlaps with a hunk [hunkStart, hunkEnd] when:
+ *   lineStart <= hunkEnd AND lineEnd >= hunkStart
+ */
+export function overlapsWithDiff(filePath, lineStart, lineEnd, diffHunks) {
+    const hunks = diffHunks.get(filePath);
+    if (!hunks || hunks.length === 0) {
+        return false;
+    }
+    for (const hunk of hunks) {
+        // A hunk with newCount=0 means pure deletion at that point — skip
+        if (hunk.newCount === 0) {
+            continue;
+        }
+        const hunkEnd = hunk.newStart + hunk.newCount - 1;
+        if (lineStart <= hunkEnd && lineEnd >= hunk.newStart) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/analysis/prompt-formatter.js

@@ -90,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:');
@@ -216,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/dist/cli.js

@@ -71,6 +71,7 @@ program
     .requiredOption('--files <paths...>', 'Changed files')
     .option('--repo-dir <path>', 'Repository root directory', '.')
     .option('--graph <path>', 'Path to main graph JSON')
+    .option('--diff <path>', 'Path to unified diff file (filters changed functions in fallback mode)')
     .requiredOption('--out <path>', 'Output JSON file path')
     .option('--min-confidence <n>', 'Minimum CALLS edge confidence', '0.5')
     .option('--max-depth <n>', 'Blast radius BFS depth', '3')
@@ -90,6 +91,7 @@ program
         repoDir: opts.repoDir,
         files: opts.files,
         graph: opts.graph,
+        diff: opts.diff,
         out: opts.out,
         minConfidence: Number.parseFloat(opts.minConfidence),
         maxDepth: Number.parseInt(opts.maxDepth, 10),

package/dist/commands/context.d.ts

@@ -2,6 +2,7 @@ interface ContextOptions {
     repoDir: string;
     files: string[];
     graph?: string;
+    diff?: string;
     out: string;
     minConfidence: number;
     maxDepth: number;

package/dist/commands/context.js

@@ -2,6 +2,7 @@ import { execSync } from 'child_process';
 import { readFileSync, rmSync, writeFileSync } from 'fs';
 import { resolve } from 'path';
 import { buildContextV2 } from '../analysis/context-builder';
+import { parseDiffHunks } from '../analysis/diff-lines';
 import { formatPrompt } from '../analysis/prompt-formatter';
 import { mergeGraphs } from '../graph/merger';
 import { log } from '../shared/logger';
@@ -94,6 +95,25 @@ export async function executeContext(opts) {
         else {
             mergedGraph = { nodes: parseResult.nodes, edges: parseResult.edges };
         }
+        // Parse diff hunks if provided (used in fallback mode to filter changed functions)
+        let diffHunks;
+        if (opts.diff) {
+            try {
+                const diffContent = readFileSync(opts.diff, 'utf-8');
+                diffHunks = parseDiffHunks(diffContent);
+                log.info('context: diff hunks loaded', {
+                    path: opts.diff,
+                    files: diffHunks.size,
+                    totalHunks: [...diffHunks.values()].reduce((s, h) => s + h.length, 0),
+                });
+            }
+            catch (err) {
+                log.warn('context: failed to read --diff file, proceeding without it', {
+                    path: opts.diff,
+                    error: String(err),
+                });
+            }
+        }
         // Build V2 context
         const output = buildContextV2({
             mergedGraph,
@@ -102,6 +122,7 @@ export async function executeContext(opts) {
             minConfidence: opts.minConfidence,
             maxDepth: opts.maxDepth,
             skipTests: opts.skipTests,
+            diffHunks,
         });
         log.info('context: analysis done', {
             changedFunctions: output.analysis.changed_functions.length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kodus/kodus-graph",
-  "version": "0.2.12",
+  "version": "0.2.14",
   "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",