@kodus/kodus-graph 0.2.13 → 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/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.13",
+  "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",