@kodus/kodus-graph 0.2.7 → 0.2.8

package/package.json

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

@@ -1,5 +1,6 @@
 import type { IndexedGraph } from '../graph/loader';
 import type { GraphEdge, GraphNode } from '../graph/types';
+import { log } from '../shared/logger';
 
 export interface NodeChange {
   qualified_name: string;
@@ -45,6 +46,12 @@ export function computeStructuralDiff(
     if (changedSet.has(n.file_path)) newNodesMap.set(n.qualified_name, n);
   }
 
+  log.debug('diff: input', {
+    oldNodesInChanged: oldNodesInChanged.size,
+    newNodesInChanged: newNodesMap.size,
+    changedFiles,
+  });
+
   // Classify nodes
   const added: NodeChange[] = [];
   const removed: NodeChange[] = [];
@@ -79,12 +86,34 @@ export function computeStructuralDiff(
       if (n.content_hash && newN.content_hash) {
         // Definitive: hash comparison catches ALL content changes,
         // even same-line-count edits (e.g. `return 1` → `return 2`).
-        if (n.content_hash !== newN.content_hash) changes.push('body');
+        if (n.content_hash !== newN.content_hash) {
+          changes.push('body');
+          log.debug('diff: body change detected', {
+            node: qn,
+            oldHash: n.content_hash.substring(0, 8),
+            newHash: newN.content_hash.substring(0, 8),
+          });
+        } else {
+          log.debug('diff: hash match (displacement only)', {
+            node: qn,
+            oldLines: `${n.line_start}-${n.line_end}`,
+            newLines: `${newN.line_start}-${newN.line_end}`,
+          });
+        }
       } else if (n.line_start !== newN.line_start || n.line_end !== newN.line_end) {
         // Fallback (legacy data without content_hash): size heuristic.
         const oldSize = n.line_end - n.line_start;
         const newSize = newN.line_end - newN.line_start;
-        if (oldSize !== newSize) changes.push('line_range');
+        if (oldSize !== newSize) {
+          changes.push('line_range');
+          log.debug('diff: line_range fallback (no content_hash)', {
+            node: qn,
+            hasOldHash: !!n.content_hash,
+            hasNewHash: !!newN.content_hash,
+            oldSize,
+            newSize,
+          });
+        }
       }
       if ((n.params || '') !== (newN.params || '')) changes.push('params');
       if ((n.return_type || '') !== (newN.return_type || '')) changes.push('return_type');
@@ -121,6 +150,15 @@ export function computeStructuralDiff(
     riskByFile[file] = { dependents: count, risk };
   }
 
+  log.info('diff: result', {
+    added: added.length,
+    removed: removed.length,
+    modified: modified.length,
+    edgesAdded: addedEdges.length,
+    edgesRemoved: removedEdges.length,
+    modifiedDetails: modified.map((m) => `${m.qualified_name} [${m.changes.join(',')}]`),
+  });
+
   return {
     changed_files: changedFiles,
     summary: { added: added.length, removed: removed.length, modified: modified.length },

package/src/cli.ts

@@ -14,6 +14,9 @@ import { executeUpdate } from './commands/update';
 const program = new Command();
 
 import pkg from '../package.json';
+import { log } from './shared/logger';
+
+log.info(`kodus-graph v${pkg.version}`, { node: process.version, platform: process.platform });
 program.name('kodus-graph').description('Code graph builder for Kodus code review').version(pkg.version);
 
 program

package/src/commands/context.ts

@@ -22,6 +22,15 @@ interface ContextOptions {
 export async function executeContext(opts: ContextOptions): Promise<void> {
   const repoDir = resolve(opts.repoDir);
 
+  log.info('context: starting', {
+    files: opts.files,
+    repoDir,
+    graph: opts.graph ?? null,
+    format: opts.format,
+    minConfidence: opts.minConfidence,
+    maxDepth: opts.maxDepth,
+  });
+
   // Parse changed files using secure temp
   const tmp = createSecureTempFile('ctx');
   try {
@@ -33,6 +42,11 @@ export async function executeContext(opts: ContextOptions): Promise<void> {
     });
     const parseResult = JSON.parse(readFileSync(tmp.filePath, 'utf-8'));
 
+    log.info('context: parse done', {
+      nodes: parseResult.nodes?.length ?? 0,
+      edges: parseResult.edges?.length ?? 0,
+    });
+
     // Load and merge with main graph if provided
     let mergedGraph: GraphData;
     let oldGraph: GraphData | null = null;
@@ -53,6 +67,12 @@ export async function executeContext(opts: ContextOptions): Promise<void> {
       const changedSet = new Set(opts.files);
       const sameBranch = detectSameBranch(validated.data.nodes, parseResult.nodes, changedSet);
 
+      log.info('context: baseline graph loaded', {
+        graphNodes: validated.data.nodes.length,
+        graphEdges: validated.data.edges.length,
+        sameBranch,
+      });
+
       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"
@@ -88,6 +108,16 @@ export async function executeContext(opts: ContextOptions): Promise<void> {
       maxDepth: opts.maxDepth,
     });
 
+    log.info('context: analysis done', {
+      changedFunctions: output.analysis.changed_functions.length,
+      diff: output.analysis.structural_diff.summary,
+      blastRadius: output.analysis.blast_radius.total_functions,
+      risk: `${output.analysis.risk.level} (${output.analysis.risk.score})`,
+      testGaps: output.analysis.test_gaps.length,
+      affectedFlows: output.analysis.affected_flows.length,
+      duration_ms: output.analysis.metadata.duration_ms,
+    });
+
     if (opts.format === 'prompt') {
       writeFileSync(opts.out, formatPrompt(output));
     } else {
@@ -120,7 +150,10 @@ function detectSameBranch(
   }
 
   // No overlap means graph has no nodes for changed files — not same-branch scenario
-  if (graphHashes.size === 0) return false;
+  if (graphHashes.size === 0) {
+    log.debug('detectSameBranch: no graph hashes for changed files');
+    return false;
+  }
 
   const parseHashes = new Map<string, string>();
   for (const n of parseNodes) {
@@ -132,8 +165,18 @@ function detectSameBranch(
   // 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;
+    if (parseHash && parseHash !== hash) {
+      log.debug('detectSameBranch: hash mismatch → different branch', {
+        file,
+        graphHash: hash.substring(0, 8),
+        parseHash: parseHash.substring(0, 8),
+      });
+      return false;
+    }
   }
 
+  log.debug('detectSameBranch: all hashes match → same branch', {
+    filesCompared: graphHashes.size,
+  });
   return true;
 }

package/src/shared/logger.ts

@@ -1,5 +1,8 @@
 // src/shared/logger.ts
 export const log = {
+  info(msg: string, ctx?: Record<string, unknown>): void {
+    process.stderr.write(`[INFO] ${msg}${ctx ? ` ${JSON.stringify(ctx)}` : ''}\n`);
+  },
   debug(msg: string, ctx?: Record<string, unknown>): void {
     if (process.env.KODUS_GRAPH_DEBUG) {
       process.stderr.write(`[DEBUG] ${msg}${ctx ? ` ${JSON.stringify(ctx)}` : ''}\n`);