@kodus/kodus-graph 0.2.0 → 0.2.1

package/package.json

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

package/src/cli.ts

@@ -13,7 +13,7 @@ import { executeUpdate } from './commands/update';
 
 const program = new Command();
 
-program.name('kodus-graph').description('Code graph builder for Kodus code review').version('0.2.0');
+program.name('kodus-graph').description('Code graph builder for Kodus code review').version('0.2.1');
 
 program
   .command('parse')
@@ -21,6 +21,8 @@ program
   .option('--all', 'Parse all files in repo')
   .option('--files <paths...>', 'Parse specific files')
   .option('--repo-dir <path>', 'Repository root directory', '.')
+  .option('--include <glob...>', 'Include only files matching glob (repeatable)')
+  .option('--exclude <glob...>', 'Exclude files matching glob (repeatable)')
   .requiredOption('--out <path>', 'Output JSON file path')
   .action(async (opts) => {
     const repoDir = resolve(opts.repoDir);
@@ -33,6 +35,8 @@ program
       files: opts.files,
       all: opts.all ?? false,
       out: opts.out,
+      include: opts.include,
+      exclude: opts.exclude,
     });
   });
 

package/src/commands/parse.ts

@@ -1,8 +1,8 @@
-import { writeFileSync } from 'fs';
-import { relative, resolve } from 'path';
+import { resolve, relative } from 'path';
 import { performance } from 'perf_hooks';
 import { buildGraphData } from '../graph/builder';
-import type { ImportEdge, ParseOutput } from '../graph/types';
+import { writeGraphJSON } from '../graph/json-writer';
+import type { ImportEdge } from '../graph/types';
 import { parseBatch } from '../parser/batch';
 import { discoverFiles } from '../parser/discovery';
 import { resolveAllCalls } from '../resolver/call-resolver';
@@ -12,11 +12,13 @@ import { createSymbolTable } from '../resolver/symbol-table';
 import { computeFileHash } from '../shared/file-hash';
 import { log } from '../shared/logger';
 
-interface ParseOptions {
+export interface ParseOptions {
   repoDir: string;
   files?: string[];
   all: boolean;
   out: string;
+  include?: string[];
+  exclude?: string[];
 }
 
 export async function executeParse(opts: ParseOptions): Promise<void> {
@@ -24,27 +26,25 @@ export async function executeParse(opts: ParseOptions): Promise<void> {
   const repoDir = resolve(opts.repoDir);
 
   // Phase 1: Discover files
-  const files = discoverFiles(repoDir, opts.all ? undefined : opts.files);
+  const files = discoverFiles(repoDir, opts.all ? undefined : opts.files, opts.include, opts.exclude);
   process.stderr.write(`[1/5] Discovered ${files.length} files\n`);
 
   // Phase 2: Parse + extract
-  const rawGraph = await parseBatch(files, repoDir);
+  let rawGraph = await parseBatch(files, repoDir);
   process.stderr.write(
     `[2/5] Parsed ${rawGraph.functions.length} functions, ${rawGraph.classes.length} classes, ${rawGraph.rawCalls.length} call sites\n`,
   );
 
   // Phase 3: Resolve imports
   const tsconfigAliases = loadTsconfigAliases(repoDir);
-  const symbolTable = createSymbolTable();
-  const importMap = createImportMap();
-  const importEdges: ImportEdge[] = [];
+  let symbolTable = createSymbolTable();
+  let importMap = createImportMap();
+  let importEdges: ImportEdge[] = [];
 
-  // Populate symbol table
   for (const f of rawGraph.functions) symbolTable.add(f.file, f.name, f.qualified);
   for (const c of rawGraph.classes) symbolTable.add(c.file, c.name, c.qualified);
   for (const i of rawGraph.interfaces) symbolTable.add(i.file, i.name, i.qualified);
 
-  // Resolve each import
   for (const imp of rawGraph.imports) {
     const langKey = imp.lang === 'python' ? 'python' : imp.lang === 'ruby' ? 'ruby' : 'typescript';
     const resolved = resolveImport(resolve(repoDir, imp.file), imp.module, langKey, repoDir, tsconfigAliases);
@@ -64,7 +64,7 @@ export async function executeParse(opts: ParseOptions): Promise<void> {
   );
 
   // Phase 4: Resolve calls
-  const { callEdges, stats } = resolveAllCalls(rawGraph.rawCalls, rawGraph.diMaps, symbolTable, importMap);
+  let { callEdges, stats } = resolveAllCalls(rawGraph.rawCalls, rawGraph.diMaps, symbolTable, importMap);
   process.stderr.write(
     `[4/5] Resolved ${callEdges.length} calls (DI:${stats.di} same:${stats.same} import:${stats.import} unique:${stats.unique} ambiguous:${stats.ambiguous} noise:${stats.noise})\n`,
   );
@@ -79,22 +79,27 @@ export async function executeParse(opts: ParseOptions): Promise<void> {
     }
   }
 
+  const parseErrors = rawGraph.parseErrors;
+  const extractErrors = rawGraph.extractErrors;
   const graphData = buildGraphData(rawGraph, callEdges, importEdges, repoDir, fileHashes);
   process.stderr.write(`[5/5] Built graph: ${graphData.nodes.length} nodes, ${graphData.edges.length} edges\n`);
 
-  const output: ParseOutput = {
-    metadata: {
-      repo_dir: repoDir,
-      files_parsed: files.length,
-      total_nodes: graphData.nodes.length,
-      total_edges: graphData.edges.length,
-      duration_ms: Math.round(performance.now() - t0),
-      parse_errors: rawGraph.parseErrors,
-      extract_errors: rawGraph.extractErrors,
-    },
-    nodes: graphData.nodes,
-    edges: graphData.edges,
+  // Release intermediaries — no longer needed after buildGraphData
+  rawGraph = null as any;
+  symbolTable = null as any;
+  importMap = null as any;
+  callEdges = null as any;
+  importEdges = null as any;
+
+  const metadata = {
+    repo_dir: repoDir,
+    files_parsed: files.length,
+    total_nodes: graphData.nodes.length,
+    total_edges: graphData.edges.length,
+    duration_ms: Math.round(performance.now() - t0),
+    parse_errors: parseErrors,
+    extract_errors: extractErrors,
   };
 
-  writeFileSync(opts.out, JSON.stringify(output, null, 2));
+  writeGraphJSON(opts.out, metadata, graphData.nodes, graphData.edges);
 }

package/src/graph/json-writer.ts

@@ -0,0 +1,43 @@
+import { openSync, writeSync, closeSync } from 'fs';
+import type { GraphEdge, GraphNode, ParseMetadata } from './types';
+
+/**
+ * Write graph output as JSON to disk using incremental serialization.
+ *
+ * Instead of JSON.stringify on the full output (which creates a ~100-300 MB
+ * string for large repos), this writes each node/edge individually.
+ * Peak memory: only one JSON.stringify(singleNode) string at a time (~1 KB).
+ */
+export function writeGraphJSON(
+  out: string,
+  metadata: ParseMetadata,
+  nodes: GraphNode[],
+  edges: GraphEdge[],
+): void {
+  const fd = openSync(out, 'w');
+
+  try {
+    writeSync(fd, '{"metadata":');
+    writeSync(fd, JSON.stringify(metadata));
+
+    // Nodes
+    writeSync(fd, ',"nodes":[');
+    for (let i = 0; i < nodes.length; i++) {
+      if (i > 0) writeSync(fd, ',');
+      writeSync(fd, '\n');
+      writeSync(fd, JSON.stringify(nodes[i]));
+    }
+    writeSync(fd, '\n]');
+
+    // Edges
+    writeSync(fd, ',"edges":[');
+    for (let i = 0; i < edges.length; i++) {
+      if (i > 0) writeSync(fd, ',');
+      writeSync(fd, '\n');
+      writeSync(fd, JSON.stringify(edges[i]));
+    }
+    writeSync(fd, '\n]}');
+  } finally {
+    closeSync(fd);
+  }
+}

package/src/parser/batch.ts

@@ -2,7 +2,8 @@ import type { SgRoot } from '@ast-grep/napi';
 import { parseAsync } from '@ast-grep/napi';
 import { readFileSync } from 'fs';
 import { extname, relative } from 'path';
-import type { ParseBatchResult, RawGraph } from '../graph/types';
+import type { ParseBatchResult, RawCallSite, RawGraph } from '../graph/types';
+import { NOISE } from '../shared/filters';
 import { log } from '../shared/logger';
 import { extractCallsFromFile, extractFromFile } from './extractor';
 import { getLanguage } from './languages';
@@ -60,7 +61,14 @@ export async function parseBatch(files: string[], repoRoot: string): Promise<Par
       }
 
       try {
-        extractCallsFromFile(root, fp, lang, graph.rawCalls);
+        // Extract calls into a temporary buffer, then filter noise before pushing
+        const rawCalls: RawCallSite[] = [];
+        extractCallsFromFile(root, fp, lang, rawCalls);
+        for (const call of rawCalls) {
+          if (!NOISE.has(call.callName)) {
+            graph.rawCalls.push(call);
+          }
+        }
       } catch (err) {
         log.error('Call extraction crashed', { file: fp, error: String(err) });
         extractErrors++;

package/src/parser/discovery.ts

@@ -1,5 +1,5 @@
 import { readdirSync } from 'fs';
-import { extname, join, resolve } from 'path';
+import { extname, join, relative, resolve } from 'path';
 import { isSkippableFile, SKIP_DIRS } from '../shared/filters';
 import { log } from '../shared/logger';
 import { ensureWithinRoot } from '../shared/safe-path';
@@ -8,8 +8,15 @@ import { getLanguage } from './languages';
 /**
  * Walk the filesystem and find all supported source files.
  * If `filterFiles` is provided, only return those specific files (resolved to absolute paths).
+ * If `include` patterns are provided, keep only files matching at least one pattern.
+ * If `exclude` patterns are provided, remove files matching any pattern.
  */
-export function discoverFiles(repoDir: string, filterFiles?: string[]): string[] {
+export function discoverFiles(
+  repoDir: string,
+  filterFiles?: string[],
+  include?: string[],
+  exclude?: string[],
+): string[] {
   const absRepoDir = resolve(repoDir);
 
   if (filterFiles) {
@@ -26,8 +33,34 @@ export function discoverFiles(repoDir: string, filterFiles?: string[]): string[]
       });
   }
 
-  const files: string[] = [];
+  let files: string[] = [];
   walkFiles(absRepoDir, files);
+
+  // Apply include/exclude filters using Bun.Glob
+  const hasInclude = include && include.length > 0;
+  const hasExclude = exclude && exclude.length > 0;
+
+  if (hasInclude || hasExclude) {
+    const includeGlobs = hasInclude ? include.map((p) => new Bun.Glob(p)) : null;
+    const excludeGlobs = hasExclude ? exclude.map((p) => new Bun.Glob(p)) : null;
+
+    files = files.filter((absPath) => {
+      const rel = relative(absRepoDir, absPath);
+
+      // If include patterns exist, file must match at least one
+      if (includeGlobs && !includeGlobs.some((g) => g.match(rel))) {
+        return false;
+      }
+
+      // If exclude patterns exist, file must not match any
+      if (excludeGlobs && excludeGlobs.some((g) => g.match(rel))) {
+        return false;
+      }
+
+      return true;
+    });
+  }
+
   return files;
 }