@optave/codegraph 3.12.0 → 3.15.0

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

@@ -8,8 +8,8 @@ import fs from 'node:fs';
 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, matchesAny } from '../../../shared/globs.js';
+import { buildIgnoreSet, EXTENSIONS, normalizePath } from '../../../shared/constants.js';
+import { compileGlobs, globToRegex, matchesAny } from '../../../shared/globs.js';
 import type {
   BetterSqlite3Database,
   CodegraphConfig,
@@ -48,14 +48,20 @@ export const BUILTIN_RECEIVERS: Set<string> = new Set([
   'require',
 ]);
 
+/** Phase 8.6: confidence penalty applied to CHA-dispatch edges. */
+export const CHA_DISPATCH_PENALTY = 0.1;
+/** Phase 8.6: fixed confidence for typed-receiver (interface/CHA) dispatch edges.
+ *  File proximity is not meaningful for virtual dispatch — all three engine paths
+ *  (WASM inline, WASM post-pass, native post-pass) must agree on this value. */
+export const CHA_TYPED_DISPATCH_CONFIDENCE = 0.8;
+
 /** Check if a directory entry should be skipped (ignored dirs, dotfiles). */
-function shouldSkipEntry(entry: fs.Dirent, extraIgnore: Set<string> | null): boolean {
+function shouldSkipEntry(entry: fs.Dirent, ignoreSet: ReadonlySet<string>): boolean {
   if (entry.name.startsWith('.') && entry.name !== '.') {
-    if (IGNORE_DIRS.has(entry.name)) return true;
+    if (ignoreSet.has(entry.name)) return true;
     if (entry.isDirectory()) return true;
   }
-  if (IGNORE_DIRS.has(entry.name)) return true;
-  if (extraIgnore?.has(entry.name)) return true;
+  if (ignoreSet.has(entry.name)) return true;
   return false;
 }
 
@@ -76,13 +82,65 @@ export function passesIncludeExclude(
   return true;
 }
 
+/**
+ * Parse the `.gitignore` file at the project root and return compiled regexes
+ * for each non-negated, non-comment pattern.
+ *
+ * Only the root-level `.gitignore` is read — nested `.gitignore` files and
+ * global gitignore are not consulted. This gives the WASM file-collection
+ * walker the same coarse gitignore respect that the Rust engine gets from the
+ * `ignore` crate's `git_ignore(true)` option, without requiring an additional
+ * npm dependency.
+ *
+ * Negation patterns (`!pattern`) are intentionally skipped — honoring them
+ * correctly requires ordered evaluation which is outside scope here. The Rust
+ * engine's `ignore` crate handles negation natively.
+ */
+export function readGitignorePatterns(rootDir: string): readonly RegExp[] {
+  const gitignorePath = path.join(rootDir, '.gitignore');
+  let contents: string;
+  try {
+    contents = fs.readFileSync(gitignorePath, 'utf-8');
+  } catch {
+    return [];
+  }
+
+  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;
+    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));
+    } catch {
+      // Ignore patterns that don't compile (e.g. those with unsupported syntax)
+    }
+  }
+  return Object.freeze(regexes);
+}
+
 /** Per-walk state computed once at the top-level invocation. */
 interface CollectContext {
   readonly rootDir: string;
   readonly includeRegexes: readonly RegExp[];
   readonly excludeRegexes: readonly RegExp[];
+  readonly gitignoreRegexes: readonly RegExp[];
   readonly hasGlobFilters: boolean;
-  readonly extraIgnore: Set<string> | null;
+  /** Merged set of IGNORE_DIRS + config.ignoreDirs + config.ignoreAdditionalDirs. */
+  readonly ignoreSet: ReadonlySet<string>;
   readonly visited: Set<string>;
 }
 
@@ -115,8 +173,10 @@ function readDirSafe(dir: string): fs.Dirent[] | null {
 /** True if `entry` is a source file we should collect under `ctx`. */
 function isCollectableSourceFile(full: string, entry: fs.Dirent, ctx: CollectContext): boolean {
   if (!EXTENSIONS.has(path.extname(entry.name))) return false;
-  if (!ctx.hasGlobFilters) return true;
   const rel = normalizePath(path.relative(ctx.rootDir, full));
+  // Respect .gitignore patterns before applying include/exclude globs
+  if (ctx.gitignoreRegexes.length > 0 && matchesAny(ctx.gitignoreRegexes, rel)) return false;
+  if (!ctx.hasGlobFilters) return true;
   return passesIncludeExclude(rel, ctx.includeRegexes, ctx.excludeRegexes);
 }
 
@@ -133,7 +193,7 @@ function walkCollect(
 
   let hasFiles = false;
   for (const entry of entries) {
-    if (shouldSkipEntry(entry, ctx.extraIgnore)) continue;
+    if (shouldSkipEntry(entry, ctx.ignoreSet)) continue;
 
     const full = path.join(dir, entry.name);
     if (entry.isDirectory()) {
@@ -176,12 +236,19 @@ export function collectFiles(
   const trackDirs = directories instanceof Set;
   const includeRegexes = compileGlobs(config.include);
   const excludeRegexes = compileGlobs(config.exclude);
+  const gitignoreRegexes = readGitignorePatterns(dir);
+  // Build the merged ignore set:
+  //   - config.ignoreDirs are appended to IGNORE_DIRS (existing behaviour: per-repo overrides)
+  //   - config.ignoreAdditionalDirs are also merged in on top of IGNORE_DIRS (new feature)
+  const extraDirs = [...(config.ignoreDirs ?? []), ...(config.ignoreAdditionalDirs ?? [])];
+  const ignoreSet = buildIgnoreSet(extraDirs.length ? extraDirs : undefined);
   const ctx: CollectContext = {
     rootDir: dir,
     includeRegexes,
     excludeRegexes,
+    gitignoreRegexes,
     hasGlobFilters: includeRegexes.length > 0 || excludeRegexes.length > 0,
-    extraIgnore: config.ignoreDirs ? new Set(config.ignoreDirs) : null,
+    ignoreSet,
     visited: new Set(),
   };
 
@@ -313,9 +380,9 @@ function getEdgeStmt(db: BetterSqlite3Database, chunkSize: number): SqliteStatem
   }
   let stmt = cache.get(chunkSize);
   if (!stmt) {
-    const ph = '(?,?,?,?,?,?)';
+    const ph = '(?,?,?,?,?,?,?)';
     stmt = db.prepare(
-      'INSERT INTO edges (source_id,target_id,kind,confidence,dynamic,technique) VALUES ' +
+      'INSERT INTO edges (source_id,target_id,kind,confidence,dynamic,technique,dynamic_kind) VALUES ' +
         Array.from({ length: chunkSize }, () => ph).join(','),
     );
     cache.set(chunkSize, stmt);
@@ -344,7 +411,7 @@ export function batchInsertNodes(db: BetterSqlite3Database, rows: unknown[][]):
 
 /**
  * Batch-insert edge rows via multi-value INSERT statements.
- * Each row: [source_id, target_id, kind, confidence, dynamic, technique]
+ * Each row: [source_id, target_id, kind, confidence, dynamic, technique, dynamic_kind]
  */
 export function batchInsertEdges(db: BetterSqlite3Database, rows: unknown[][]): void {
   if (!rows.length) return;
@@ -355,32 +422,26 @@ export function batchInsertEdges(db: BetterSqlite3Database, rows: unknown[][]):
     const vals: unknown[] = [];
     for (let j = i; j < end; j++) {
       const r = rows[j] as unknown[];
-      vals.push(r[0], r[1], r[2], r[3], r[4], r[5] ?? null);
+      vals.push(r[0], r[1], r[2], r[3], r[4], r[5] ?? null, r[6] ?? null);
     }
     stmt.run(...vals);
   }
 }
 
+/** Confidence assigned to CHA-expanded interface/abstract dispatch edges. */
+export const CHA_DISPATCH_CONFIDENCE = 0.8;
+
 /**
- * CHA (Class Hierarchy Analysis) post-pass.
- *
- * Expands virtual-dispatch call edges for class hierarchies and interface
- * implementations already present in the DB:
- *
- *  1. Build implementors map: parent/interface → [child/implementing class] from
- *     `extends` and `implements` edges.
- *  2. Collect RTA evidence: class nodes that appear as `calls` targets (new X()).
- *  3. Find all `calls` edges to qualified method nodes (name contains '.').
- *  4. For each such call, expand to concrete overrides via the implementors map,
- *     filtered by RTA when evidence exists.
- *
- * Used by both the native orchestrator post-pass and the WASM build-edges pass.
+ * Build the parent→children implementor map from `extends`/`implements` edges.
+ * Returns null if no hierarchy edges exist.
  */
-export function runChaPostPass(db: BetterSqlite3Database): number {
+function buildImplementorMap(
+  db: BetterSqlite3Database,
+): { implementors: Map<string, string[]>; implementorSets: Map<string, Set<string>> } | null {
   const hasHierarchy = db
     .prepare(`SELECT 1 FROM edges WHERE kind IN ('extends', 'implements') LIMIT 1`)
     .get();
-  if (!hasHierarchy) return 0;
+  if (!hasHierarchy) return null;
 
   const hierarchyRows = db
     .prepare(
@@ -401,11 +462,22 @@ export function runChaPostPass(db: BetterSqlite3Database): number {
     }
     set.add(row.child_name);
   }
-  if (implementorSets.size === 0) return 0;
-  // Convert to arrays for iteration compatibility with the rest of the function
+  if (implementorSets.size === 0) return null;
+
+  // Convert to arrays for iteration compatibility
   const implementors = new Map([...implementorSets.entries()].map(([k, v]) => [k, [...v]]));
+  return { implementors, implementorSets };
+}
 
-  // RTA: collect class names instantiated via constructor calls (`new X()`).
+/**
+ * Collect RTA (Rapid Type Analysis) evidence: class names instantiated via
+ * constructor calls (`new X()`). Falls back to constructor/function-kind nodes
+ * for languages that record constructor calls differently (e.g. TS via WASM).
+ */
+function collectRtaInstantiated(
+  db: BetterSqlite3Database,
+  implementorSets: Map<string, Set<string>>,
+): Set<string> {
   let rtaRows = db
     .prepare(
       `SELECT DISTINCT tgt.name
@@ -414,6 +486,7 @@ export function runChaPostPass(db: BetterSqlite3Database): number {
        WHERE e.kind = 'calls' AND tgt.kind = 'class'`,
     )
     .all() as Array<{ name: string }>;
+
   if (rtaRows.length === 0) {
     // Fallback: some languages (e.g. TypeScript via WASM) record constructor calls as
     // 'function' or 'constructor' kind rather than 'class'. Restrict to names that are
@@ -446,7 +519,89 @@ export function runChaPostPass(db: BetterSqlite3Database): number {
       }
     }
   }
-  const instantiated = new Set(rtaRows.map((r) => r.name));
+
+  return new Set(rtaRows.map((r) => r.name));
+}
+
+/**
+ * BFS-expand a single call-to-qualified-method into CHA dispatch edges.
+ *
+ * For `source_id` calling `typeName.methodSuffix`, walks the implementors
+ * map (BFS) and emits an edge for each concrete override that passes the
+ * RTA filter.  New edges are appended to `newEdges`; `seen` is updated in
+ * place to prevent duplicate insertions within the same pass.
+ */
+function expandChaCall(
+  sourceId: number,
+  typeName: string,
+  methodSuffix: string,
+  implementors: Map<string, string[]>,
+  instantiated: Set<string>,
+  noRtaEvidence: boolean,
+  findMethodStmt: { all(name: string): unknown[] },
+  seen: Set<string>,
+  newEdges: Array<[number, number, string, number, number, string]>,
+): void {
+  // BFS over the implementors map — handles multi-level hierarchies where
+  // abstract/non-instantiated classes sit between the call-site type and
+  // the concrete leaf implementations (matches runPostNativeCha, issue #1311).
+  const bfsQueue: string[] = [typeName];
+  const bfsVisited = new Set<string>([typeName]);
+  while (bfsQueue.length > 0) {
+    const current = bfsQueue.shift()!;
+    const children = implementors.get(current);
+    if (!children?.length) continue;
+
+    for (const cls of children) {
+      if (bfsVisited.has(cls)) continue;
+      bfsVisited.add(cls);
+
+      if (noRtaEvidence || instantiated.has(cls)) {
+        const qualifiedName = `${cls}.${methodSuffix}`;
+        const methodNodes = findMethodStmt.all(qualifiedName) as Array<{ id: number }>;
+        for (const methodNode of methodNodes) {
+          if (methodNode.id === sourceId) continue; // skip self-loops
+          const key = `${sourceId}|${methodNode.id}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          newEdges.push([
+            sourceId,
+            methodNode.id,
+            'calls',
+            CHA_TYPED_DISPATCH_CONFIDENCE,
+            0,
+            'cha-expanded',
+          ]);
+        }
+      }
+
+      // Always traverse children — non-instantiated classes may have instantiated subclasses.
+      bfsQueue.push(cls);
+    }
+  }
+}
+
+/**
+ * CHA (Class Hierarchy Analysis) post-pass.
+ *
+ * Expands virtual-dispatch call edges for class hierarchies and interface
+ * implementations already present in the DB:
+ *
+ *  1. Build implementors map: parent/interface → [child/implementing class] from
+ *     `extends` and `implements` edges.
+ *  2. Collect RTA evidence: class nodes that appear as `calls` targets (new X()).
+ *  3. Find all `calls` edges to qualified method nodes (name contains '.').
+ *  4. For each such call, expand to concrete overrides via the implementors map,
+ *     filtered by RTA when evidence exists.
+ *
+ * Used by both the native orchestrator post-pass and the WASM build-edges pass.
+ */
+export function runChaPostPass(db: BetterSqlite3Database): number {
+  const hierarchy = buildImplementorMap(db);
+  if (!hierarchy) return 0;
+  const { implementors, implementorSets } = hierarchy;
+
+  const instantiated = collectRtaInstantiated(db, implementorSets);
   const noRtaEvidence = instantiated.size === 0;
   if (noRtaEvidence) {
     debug('runChaPostPass: no constructor-call evidence — proceeding without RTA filter');
@@ -454,19 +609,21 @@ export function runChaPostPass(db: BetterSqlite3Database): number {
 
   const callToMethods = db
     .prepare(
-      `SELECT e.source_id, tgt.name AS method_name
+      `SELECT e.source_id, src.name AS caller_name, tgt.name AS method_name
        FROM edges e
        JOIN nodes tgt ON e.target_id = tgt.id
+       JOIN nodes src ON e.source_id = src.id
        WHERE e.kind = 'calls' AND tgt.kind = 'method'
-       AND INSTR(tgt.name, '.') > 0`,
+       AND INSTR(tgt.name, '.') > 0
+       AND (e.technique IS NULL OR e.technique != 'cha-expanded')`,
     )
-    .all() as Array<{ source_id: number; method_name: string }>;
+    .all() as Array<{ source_id: number; caller_name: string; method_name: string }>;
 
-  const seen = new Set<string>();
   // Scope deduplication to only the source_ids we are about to expand, avoiding
   // a full-table scan. CHA only inserts edges FROM callers that already call a
   // qualified method (the source_ids in callToMethods), so we only need to
   // check existing edges for those specific callers.
+  const seen = new Set<string>();
   const callerIds = [...new Set(callToMethods.map((r) => r.source_id))];
   if (callerIds.length > 0) {
     // Chunk to stay within SQLite SQLITE_MAX_VARIABLE_NUMBER (999 in many builds).
@@ -492,36 +649,17 @@ export function runChaPostPass(db: BetterSqlite3Database): number {
     if (dotIdx === -1) continue;
     const typeName = method_name.slice(0, dotIdx);
     const methodSuffix = method_name.slice(dotIdx + 1);
-
-    // BFS over the implementors map — handles multi-level hierarchies where
-    // abstract/non-instantiated classes sit between the call-site type and
-    // the concrete leaf implementations (matches runPostNativeCha, issue #1311).
-    const bfsQueue: string[] = [typeName];
-    const bfsVisited = new Set<string>([typeName]);
-    while (bfsQueue.length > 0) {
-      const current = bfsQueue.shift()!;
-      const children = implementors.get(current);
-      if (!children?.length) continue;
-
-      for (const cls of children) {
-        if (bfsVisited.has(cls)) continue;
-        bfsVisited.add(cls);
-
-        if (noRtaEvidence || instantiated.has(cls)) {
-          const qualifiedName = `${cls}.${methodSuffix}`;
-          const methodNodes = findMethodStmt.all(qualifiedName) as Array<{ id: number }>;
-          for (const methodNode of methodNodes) {
-            const key = `${source_id}|${methodNode.id}`;
-            if (seen.has(key)) continue;
-            seen.add(key);
-            newEdges.push([source_id, methodNode.id, 'calls', 0.8, 0, 'cha']);
-          }
-        }
-
-        // Always traverse children — non-instantiated classes may have instantiated subclasses.
-        bfsQueue.push(cls);
-      }
-    }
+    expandChaCall(
+      source_id,
+      typeName,
+      methodSuffix,
+      implementors,
+      instantiated,
+      noRtaEvidence,
+      findMethodStmt,
+      seen,
+      newEdges,
+    );
   }
 
   if (newEdges.length > 0) {