optave-codegraph 3.13.0 → 3.14.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "optave-codegraph",
-  "version": "3.13.0",
+  "version": "3.14.1",
   "description": "Local code graph CLI — parse codebases with tree-sitter, build dependency graphs, query them",
   "type": "module",
   "main": "dist/index.js",
@@ -91,6 +91,7 @@
     "lint:fix": "biome check --write src/ tests/",
     "format": "biome format --write src/ tests/",
     "prepack": "npm run build",
+    "prepublishOnly": "npm version patch --no-git-tag-version",
     "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true});require('fs').rmSync('.tsbuildinfo',{force:true})\"",
     "prepare": "npm run build:wasm && npm run build && husky && npm run deps:tree",
     "deps:tree": "node scripts/node-ts.js scripts/gen-deps.ts",
@@ -132,12 +133,12 @@
   },
   "optionalDependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@optave/codegraph-darwin-arm64": "3.13.0",
-    "@optave/codegraph-darwin-x64": "3.13.0",
-    "@optave/codegraph-linux-arm64-gnu": "3.13.0",
-    "@optave/codegraph-linux-x64-gnu": "3.13.0",
-    "@optave/codegraph-linux-x64-musl": "3.13.0",
-    "@optave/codegraph-win32-x64-msvc": "3.13.0"
+    "@optave/codegraph-darwin-arm64": "3.14.1",
+    "@optave/codegraph-darwin-x64": "3.14.1",
+    "@optave/codegraph-linux-arm64-gnu": "3.14.1",
+    "@optave/codegraph-linux-x64-gnu": "3.14.1",
+    "@optave/codegraph-linux-x64-musl": "3.14.1",
+    "@optave/codegraph-win32-x64-msvc": "3.14.1"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.4",

package/src/domain/graph/builder/call-resolver.ts

@@ -66,23 +66,32 @@ function findEnclosingCallable(
   definitions: ReadonlyArray<Def>,
   relPath: string,
 ): CallerMatch {
-  let best: CallerMatch = null;
-  let bestSpan = Infinity;
+  const candidates: Array<{ def: Def; span: number }> = [];
+
   for (const def of definitions) {
     if (!CALLABLE_KINDS.has(def.kind)) continue;
     if (def.line > callLine) continue;
     const end = def.endLine ?? Infinity;
     if (callLine > end) continue;
     const span = end === Infinity ? Infinity : end - def.line;
-    if (span < bestSpan) {
-      const row = lookup.nodeId(def.name, def.kind, relPath, def.line);
-      if (row) {
-        best = { ...row, name: def.name };
-        bestSpan = span;
-      }
+    candidates.push({ def, span });
+  }
+
+  candidates.sort((a, b) => {
+    if (a.span === b.span) return 0;
+    if (a.span === Infinity) return 1;
+    if (b.span === Infinity) return -1;
+    return a.span - b.span;
+  });
+
+  for (const { def } of candidates) {
+    const row = lookup.nodeId(def.name, def.kind, relPath, def.line);
+    if (row) {
+      return { ...row, name: def.name };
     }
   }
-  return best;
+
+  return null;
 }
 
 /**
@@ -97,23 +106,32 @@ function findEnclosingBinding(
   definitions: ReadonlyArray<Def>,
   relPath: string,
 ): CallerMatch {
-  let best: CallerMatch = null;
-  let bestSpan = -1; // looking for WIDEST span, so start at -1
+  const candidates: Array<{ def: Def; span: number }> = [];
+
   for (const def of definitions) {
     if (!TOP_LEVEL_BINDING_KINDS.has(def.kind)) continue;
     if (def.line > callLine) continue;
     const end = def.endLine ?? Infinity;
     if (callLine > end) continue;
     const span = end === Infinity ? Infinity : end - def.line;
-    if (span > bestSpan) {
-      const row = lookup.nodeId(def.name, def.kind, relPath, def.line);
-      if (row) {
-        best = { ...row, name: def.name };
-        bestSpan = span;
-      }
+    candidates.push({ def, span });
+  }
+
+  candidates.sort((a, b) => {
+    if (a.span === b.span) return 0;
+    if (a.span === Infinity) return -1;
+    if (b.span === Infinity) return 1;
+    return b.span - a.span; // Descending (widest first)
+  });
+
+  for (const { def } of candidates) {
+    const row = lookup.nodeId(def.name, def.kind, relPath, def.line);
+    if (row) {
+      return { ...row, name: def.name };
     }
   }
-  return best;
+
+  return null;
 }
 
 export function findCaller(

package/src/domain/graph/builder/helpers.ts

@@ -9,7 +9,12 @@ import path from 'node:path';
 import { purgeFilesData } from '../../../db/index.js';
 import { debug, warn } from '../../../infrastructure/logger.js';
 import { EXTENSIONS, IGNORE_DIRS, normalizePath } from '../../../shared/constants.js';
-import { compileGlobs, globToRegex, matchesAny } from '../../../shared/globs.js';
+import {
+  compileGlobs,
+  globToRegex,
+  matchesAny,
+  transformExcludePatterns,
+} from '../../../shared/globs.js';
 import type {
   BetterSqlite3Database,
   CodegraphConfig,
@@ -107,25 +112,17 @@ export function readGitignorePatterns(rootDir: string): readonly RegExp[] {
   }
 
   const regexes: RegExp[] = [];
-  for (const rawLine of contents.split(/\r?\n/)) {
-    const line = rawLine.trim();
-    // Skip empty lines, comments, and negation patterns
-    if (!line || line.startsWith('#') || line.startsWith('!')) continue;
-    // Strip trailing slash (directory indicator) — we match files by path regardless
-    const pattern = line.endsWith('/') ? line.slice(0, -1) : line;
+  // Apply the same transformation logic as for exclude patterns
+  const transformedGitignorePatterns = transformExcludePatterns(
+    contents
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter((line) => line && !line.startsWith('#') && !line.startsWith('!')),
+  );
+
+  for (const pattern of transformedGitignorePatterns) {
     try {
-      // If pattern contains no '/', it should match at any depth — prefix with `**/`.
-      // If pattern starts with '/', it is anchored to root — strip the leading slash.
-      // Otherwise use as-is (e.g. `crates/codegraph-core/index.js`).
-      let normalized: string;
-      if (pattern.startsWith('/')) {
-        normalized = pattern.slice(1);
-      } else if (!pattern.includes('/')) {
-        normalized = `**/${pattern}`;
-      } else {
-        normalized = pattern;
-      }
-      regexes.push(globToRegex(normalized));
+      regexes.push(globToRegex(pattern));
     } catch {
       // Ignore patterns that don't compile (e.g. those with unsupported syntax)
     }
@@ -235,7 +232,7 @@ export function collectFiles(
 ): string[] | { files: string[]; directories: Set<string> } {
   const trackDirs = directories instanceof Set;
   const includeRegexes = compileGlobs(config.include);
-  const excludeRegexes = compileGlobs(config.exclude);
+  const excludeRegexes = compileGlobs(config.exclude, true);
   const gitignoreRegexes = readGitignorePatterns(dir);
   const ctx: CollectContext = {
     rootDir: dir,

package/src/domain/graph/builder/pipeline.ts

@@ -28,7 +28,7 @@ import { loadNative } from '../../../infrastructure/native.js';
 import { toErrorMessage } from '../../../shared/errors.js';
 import { CODEGRAPH_VERSION } from '../../../shared/version.js';
 import type { BuildGraphOpts, BuildResult } from '../../../types.js';
-import { getActiveEngine } from '../../parser.js';
+import { getActiveEngine, type ParseFileOpts } from '../../parser.js';
 import { writeJournalHeader } from '../journal.js';
 import { setWorkspaces } from '../resolve.js';
 import { PipelineContext } from './context.js';
@@ -274,7 +274,7 @@ function formatTimingResult(ctx: PipelineContext): BuildResult {
 
 // ── Pipeline stages execution ───────────────────────────────────────────
 
-async function runPipelineStages(ctx: PipelineContext): Promise<void> {
+async function runPipelineStages(ctx: PipelineContext, options: ParseFileOpts = {}): Promise<void> {
   // ── WASM / fallback dual-connection mode ─────────────────────────────
   // NativeDatabase is deferred — not opened during setup. collectFiles and
   // detectChanges only need better-sqlite3. If no files changed, we exit
@@ -297,7 +297,7 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
 
   if (ctx.earlyExit) return;
 
-  await parseFiles(ctx);
+  await parseFiles(ctx, options);
 
   // For small incremental builds (≤smallFilesThreshold files), skip the nativeDb open/close
   // cycle for insertNodes — the WAL checkpoint + connection churn (~5-10ms)
@@ -388,6 +388,8 @@ export async function buildGraph(
   rootDir: string,
   opts: BuildGraphOpts = {},
 ): Promise<BuildResult | undefined> {
+  const { parseFileOptions } = opts;
+
   const ctx = new PipelineContext();
   ctx.buildStart = performance.now();
   ctx.opts = opts;
@@ -486,7 +488,7 @@ export async function buildGraph(
       }
     }
 
-    await runPipelineStages(ctx);
+    await runPipelineStages(ctx, parseFileOptions);
   } catch (err) {
     if (!ctx.earlyExit) {
       // Release WASM trees before closing DB to prevent V8 crash during

package/src/domain/graph/builder/stages/collect-files.ts

@@ -82,7 +82,7 @@ function tryFastCollect(
   //    Also apply gitignore patterns so the incremental fast path is consistent
   //    with the full filesystem walk (which calls readGitignorePatterns too).
   const includeRegexes = compileGlobs(config?.include);
-  const excludeRegexes = compileGlobs(config?.exclude);
+  const excludeRegexes = compileGlobs(config?.exclude, true);
   const hasGlobFilters = includeRegexes.length > 0 || excludeRegexes.length > 0;
   const gitignoreRegexes = readGitignorePatterns(rootDir);
 

package/src/domain/graph/builder/stages/parse-files.ts

@@ -6,10 +6,10 @@
  */
 import { performance } from 'node:perf_hooks';
 import { info } from '../../../../infrastructure/logger.js';
-import { parseFilesAuto } from '../../../parser.js';
+import { type ParseFileOpts, parseFilesAuto } from '../../../parser.js';
 import type { PipelineContext } from '../context.js';
 
-export async function parseFiles(ctx: PipelineContext): Promise<void> {
+export async function parseFiles(ctx: PipelineContext, options: ParseFileOpts = {}): Promise<void> {
   const { allFiles, parseChanges, isFullBuild, engineOpts, rootDir } = ctx;
 
   ctx.filesToParse = isFullBuild ? allFiles.map((f) => ({ file: f })) : parseChanges;
@@ -17,7 +17,7 @@ export async function parseFiles(ctx: PipelineContext): Promise<void> {
 
   const filePaths = ctx.filesToParse.map((item) => item.file);
   const t0 = performance.now();
-  ctx.allSymbols = await parseFilesAuto(filePaths, rootDir, engineOpts);
+  ctx.allSymbols = await parseFilesAuto(filePaths, rootDir, { ...engineOpts, ...options });
   ctx.timing.parseMs = performance.now() - t0;
 
   const parsed = ctx.allSymbols.size;

package/src/domain/parser.ts

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { setTimeout } from 'node:timers/promises';
 import { fileURLToPath } from 'node:url';
 import type { Tree } from 'web-tree-sitter';
 import { Language, Parser, Query } from 'web-tree-sitter';
@@ -1154,6 +1155,11 @@ async function backfillTypeMapBatch(
   }
 }
 
+export interface ParseFileOpts {
+  throttlePerFileInMs?: number;
+  onFileProcessed?: (filePath: string, processed: number, total: number) => void;
+}
+
 /**
  * Parse files via WASM engine, returning a Map<relPath, symbols>.
  *
@@ -1169,10 +1175,18 @@ async function backfillTypeMapBatch(
 async function parseFilesWasm(
   filePaths: string[],
   rootDir: string,
-  analysis: WorkerAnalysisOpts = FULL_ANALYSIS,
+  options?: WorkerAnalysisOpts & ParseFileOpts,
 ): Promise<Map<string, ExtractorOutput>> {
+  const { throttlePerFileInMs, onFileProcessed, ...analysis } = options || { ...FULL_ANALYSIS };
+
+  if (Object.keys(analysis).length === 0) {
+    Object.assign(analysis, FULL_ANALYSIS);
+  }
+
   const result = new Map<string, ExtractorOutput>();
   const pool = getWasmWorkerPool();
+  let processed = 0;
+
   for (const filePath of filePaths) {
     if (!_extToLang.has(path.extname(filePath).toLowerCase())) continue;
     let code: string;
@@ -1186,6 +1200,13 @@ async function parseFilesWasm(
     if (output) {
       const relPath = path.relative(rootDir, filePath).split(path.sep).join('/');
       result.set(relPath, output);
+      if (throttlePerFileInMs) {
+        await setTimeout(throttlePerFileInMs);
+      }
+    }
+    processed++;
+    if (onFileProcessed) {
+      onFileProcessed(filePath, processed, filePaths.length);
     }
   }
   return result;
@@ -1359,10 +1380,16 @@ async function backfillNativeDrops(
 export async function parseFilesAuto(
   filePaths: string[],
   rootDir: string,
-  opts: ParseEngineOpts = {},
+  opts: ParseEngineOpts & ParseFileOpts = {},
 ): Promise<Map<string, ExtractorOutput>> {
-  const { native } = resolveEngine(opts);
-  if (!native) return parseFilesWasm(filePaths, rootDir);
+  const { throttlePerFileInMs, onFileProcessed, ...engOpt } = opts;
+  const { native } = resolveEngine(engOpt);
+  if (!native)
+    return parseFilesWasm(filePaths, rootDir, {
+      throttlePerFileInMs,
+      onFileProcessed,
+      ...FULL_ANALYSIS,
+    });
 
   const result = new Map<string, ExtractorOutput>();
   const { nativeParsed, needsTypeMap } = ingestNativeResults(native, filePaths, rootDir, result);

package/src/shared/globs.ts

@@ -74,13 +74,17 @@ function buildCacheKey(patterns: readonly string[]): string {
  * with the same include/exclude lists reuse the compiled regexes. The
  * returned array is shared across callers and must not be mutated.
  */
-export function compileGlobs(patterns: readonly string[] | undefined): readonly RegExp[] {
+export function compileGlobs(
+  patterns: readonly string[] | undefined,
+  isExclusion: boolean = false,
+): readonly RegExp[] {
   if (!patterns || patterns.length === 0) return EMPTY_REGEX_LIST;
   const key = buildCacheKey(patterns);
   const cached = compileCache.get(key);
   if (cached) return cached;
   const out: RegExp[] = [];
-  for (const p of patterns) {
+  const transformedPatterns = isExclusion ? transformExcludePatterns(patterns) : patterns;
+  for (const p of transformedPatterns) {
     if (typeof p !== 'string' || p.length === 0) continue;
     try {
       out.push(globToRegex(p));
@@ -119,3 +123,32 @@ export function matchesAny(regexes: readonly RegExp[], path: string): boolean {
   }
   return false;
 }
+
+/**
+ * Transforms exclude patterns to behave more like gitignore rules.
+ */
+export function transformExcludePatterns(patterns: readonly string[]): string[] {
+  const transformed: string[] = [];
+  for (const pattern of patterns) {
+    let p = pattern;
+
+    if (p.startsWith('/')) {
+      p = p.slice(1);
+    } else if (!p.includes('/') && !p.startsWith('**')) {
+      p = `**/${p}`;
+    }
+
+    if (
+      pattern.endsWith('/') ||
+      (!pattern.includes('/') && !pattern.includes('*') && !pattern.includes('?'))
+    ) {
+      if (!p.endsWith('**') && !p.endsWith('/*')) {
+        p += '/**';
+      }
+    } else if (p.endsWith('/')) {
+      p += '**';
+    }
+    transformed.push(p);
+  }
+  return transformed;
+}

package/src/types.ts

@@ -7,6 +7,8 @@
  * parsers, builders, visitors, features, config, and the graph model.
  */
 
+import type { ParseFileOpts } from '#domain/parser.js';
+
 // ════════════════════════════════════════════════════════════════════════
 // §1  Symbol & Edge Kind Enumerations
 // ════════════════════════════════════════════════════════════════════════
@@ -1308,6 +1310,8 @@ export interface BuildGraphOpts {
    * build command when stdin/stdout are TTYs and CI is not set.
    */
   promptForConsent?: boolean;
+
+  parseFileOptions?: ParseFileOpts;
 }
 
 /** Build timing result from buildGraph. */