@optave/codegraph 3.11.2 → 3.13.0

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

@@ -7,7 +7,7 @@ import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { purgeFilesData } from '../../../db/index.js';
-import { warn } from '../../../infrastructure/logger.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 type {
@@ -48,6 +48,13 @@ 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 {
   if (entry.name.startsWith('.') && entry.name !== '.') {
@@ -313,9 +320,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) VALUES ' +
+      'INSERT INTO edges (source_id,target_id,kind,confidence,dynamic,technique) VALUES ' +
         Array.from({ length: chunkSize }, () => ph).join(','),
     );
     cache.set(chunkSize, stmt);
@@ -344,7 +351,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]
+ * Each row: [source_id, target_id, kind, confidence, dynamic, technique]
  */
 export function batchInsertEdges(db: BetterSqlite3Database, rows: unknown[][]): void {
   if (!rows.length) return;
@@ -355,8 +362,191 @@ 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]);
+      vals.push(r[0], r[1], r[2], r[3], r[4], r[5] ?? 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.
+ */
+export function runChaPostPass(db: BetterSqlite3Database): number {
+  const hasHierarchy = db
+    .prepare(`SELECT 1 FROM edges WHERE kind IN ('extends', 'implements') LIMIT 1`)
+    .get();
+  if (!hasHierarchy) return 0;
+
+  const hierarchyRows = db
+    .prepare(
+      `SELECT src.name AS child_name, tgt.name AS parent_name
+       FROM edges e
+       JOIN nodes src ON e.source_id = src.id
+       JOIN nodes tgt ON e.target_id = tgt.id
+       WHERE e.kind IN ('extends', 'implements')`,
+    )
+    .all() as Array<{ child_name: string; parent_name: string }>;
+
+  const implementorSets = new Map<string, Set<string>>();
+  for (const row of hierarchyRows) {
+    let set = implementorSets.get(row.parent_name);
+    if (!set) {
+      set = new Set<string>();
+      implementorSets.set(row.parent_name, set);
+    }
+    set.add(row.child_name);
+  }
+  if (implementorSets.size === 0) return 0;
+  // Convert to arrays for iteration compatibility with the rest of the function
+  const implementors = new Map([...implementorSets.entries()].map(([k, v]) => [k, [...v]]));
+
+  // RTA: collect class names instantiated via constructor calls (`new X()`).
+  let rtaRows = db
+    .prepare(
+      `SELECT DISTINCT tgt.name
+       FROM edges e
+       JOIN nodes tgt ON e.target_id = tgt.id
+       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
+    // actually known class names to avoid treating unrelated function calls like `logger()`
+    // as class-instantiation evidence.
+    // Include both parent/interface names AND implementor (child) names so that
+    // `new UserRepository()` (a child class) is correctly detected as RTA evidence.
+    const knownClassNames = [
+      ...new Set([
+        ...implementorSets.keys(),
+        ...[...implementorSets.values()].flatMap((s) => [...s]),
+      ]),
+    ];
+    if (knownClassNames.length > 0) {
+      // Chunk to stay within SQLite SQLITE_MAX_VARIABLE_NUMBER (999 in many builds).
+      const CHUNK = 999;
+      for (let i = 0; i < knownClassNames.length; i += CHUNK) {
+        const chunk = knownClassNames.slice(i, i + CHUNK);
+        const placeholders = chunk.map(() => '?').join(',');
+        const chunkRows = db
+          .prepare(
+            `SELECT DISTINCT tgt.name
+             FROM edges e
+             JOIN nodes tgt ON e.target_id = tgt.id
+             WHERE e.kind = 'calls' AND tgt.kind IN ('constructor', 'function')
+             AND tgt.name IN (${placeholders})`,
+          )
+          .all(...chunk) as Array<{ name: string }>;
+        rtaRows = rtaRows.concat(chunkRows);
+      }
+    }
+  }
+  const instantiated = new Set(rtaRows.map((r) => r.name));
+  const noRtaEvidence = instantiated.size === 0;
+  if (noRtaEvidence) {
+    debug('runChaPostPass: no constructor-call evidence — proceeding without RTA filter');
+  }
+
+  const callToMethods = db
+    .prepare(
+      `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 (e.technique IS NULL OR e.technique != 'cha-expanded')`,
+    )
+    .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 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).
+    const CHUNK = 999;
+    for (let i = 0; i < callerIds.length; i += CHUNK) {
+      const chunk = callerIds.slice(i, i + CHUNK);
+      const placeholders = chunk.map(() => '?').join(',');
+      const existingPairs = db
+        .prepare(
+          `SELECT source_id, target_id FROM edges WHERE kind = 'calls' AND source_id IN (${placeholders})`,
+        )
+        .all(...chunk) as Array<{ source_id: number; target_id: number }>;
+      for (const e of existingPairs) seen.add(`${e.source_id}|${e.target_id}`);
+    }
+  }
+
+  // No LIMIT: multiple files can define the same qualified name in a monorepo.
+  const findMethodStmt = db.prepare(`SELECT id FROM nodes WHERE name = ? AND kind = 'method'`);
+  const newEdges: Array<[number, number, string, number, number, string]> = [];
+
+  for (const { source_id, method_name } of callToMethods) {
+    const dotIdx = method_name.indexOf('.');
+    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) {
+            if (methodNode.id === source_id) continue; // skip self-loops
+            const key = `${source_id}|${methodNode.id}`;
+            if (seen.has(key)) continue;
+            seen.add(key);
+            newEdges.push([
+              source_id,
+              methodNode.id,
+              'calls',
+              CHA_TYPED_DISPATCH_CONFIDENCE,
+              0,
+              'cha-expanded',
+            ]);
+          }
+        }
+
+        // Always traverse children — non-instantiated classes may have instantiated subclasses.
+        bfsQueue.push(cls);
+      }
+    }
+  }
+
+  if (newEdges.length > 0) {
+    db.transaction(() => batchInsertEdges(db, newEdges))();
+    debug(`runChaPostPass: inserted ${newEdges.length} CHA dispatch edge(s)`);
+  }
+  return newEdges.length;
+}

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

@@ -502,6 +502,34 @@ function buildCallEdges(
             ]),
           )
         : new Map();
+
+  // Phase 8.3f: seed typeMap[callee::restName] = { type: argName } from
+  // objectRestParamBindings × paramBindings, mirroring buildObjectRestParamPostPass.
+  // Scoped keys prevent same-name rest-param collisions when two functions in
+  // the same file both use `...rest` (#1358). The unscoped key is also seeded
+  // when only one callee uses a given rest name, preserving resolution when
+  // callerName is null (findCaller couldn't identify the enclosing function).
+  if (symbols.objectRestParamBindings?.length && symbols.paramBindings?.length) {
+    const restNameCallees = new Map<string, Set<string>>();
+    for (const orpb of symbols.objectRestParamBindings) {
+      if (!restNameCallees.has(orpb.restName)) restNameCallees.set(orpb.restName, new Set());
+      restNameCallees.get(orpb.restName)!.add(orpb.callee);
+    }
+    for (const orpb of symbols.objectRestParamBindings) {
+      for (const pb of symbols.paramBindings) {
+        if (pb.callee === orpb.callee && pb.argIndex === orpb.argIndex) {
+          const scopedKey = `${orpb.callee}::${orpb.restName}`;
+          if (!typeMap.has(scopedKey)) {
+            typeMap.set(scopedKey, { type: pb.argName, confidence: 0.65 });
+            if (restNameCallees.get(orpb.restName)!.size === 1 && !typeMap.has(orpb.restName)) {
+              typeMap.set(orpb.restName, { type: pb.argName, confidence: 0.65 });
+            }
+          }
+        }
+      }
+    }
+  }
+
   const seenCallEdges = new Set<string>();
   const lookup = makeIncrementalLookup(db, stmts);
   let edgesAdded = 0;
@@ -510,13 +538,63 @@ function buildCallEdges(
     if (call.receiver && BUILTIN_RECEIVERS.has(call.receiver)) continue;
 
     const caller = findCaller(lookup, call, symbols.definitions, relPath, fileNodeRow);
-    const { targets, importedFrom } = resolveCallTargets(
+    const { targets: initialTargets, importedFrom } = resolveCallTargets(
       lookup,
       call,
       relPath,
       importedNames,
       typeMap,
+      caller.callerName,
     );
+    let targets = initialTargets;
+
+    if (targets.length === 0 && call.receiver === 'this' && caller.callerName != null) {
+      const dotIdx = caller.callerName.indexOf('.');
+      if (dotIdx > 0) {
+        const className = caller.callerName.slice(0, dotIdx);
+        const qualifiedName = `${className}.${call.name}`;
+        const qualified = lookup
+          .byNameAndFile(qualifiedName, relPath)
+          .filter((n) => n.kind === 'method');
+        if (qualified.length > 0) {
+          targets = qualified;
+        }
+      }
+    }
+
+    if (
+      targets.length === 0 &&
+      call.receiver === 'this' &&
+      caller.callerName != null &&
+      symbols.definePropertyReceivers
+    ) {
+      const receiverVarName = symbols.definePropertyReceivers.get(caller.callerName);
+      if (receiverVarName) {
+        const typeEntry = typeMap.get(receiverVarName);
+        const typeName = typeEntry
+          ? typeof typeEntry === 'string'
+            ? typeEntry
+            : (typeEntry as { type?: string }).type
+          : null;
+        if (typeName) {
+          const qualifiedName = `${typeName}.${call.name}`;
+          const qualified = lookup.byNameAndFile(qualifiedName, relPath);
+          if (qualified.length > 0) {
+            targets = [...qualified];
+          }
+        }
+        if (targets.length === 0) {
+          // Narrow to function/method kinds only to avoid matching unrelated
+          // variables or classes that share a name in the same file.
+          const sameFile = lookup
+            .byNameAndFile(call.name, relPath)
+            .filter((n) => n.kind === 'function' || n.kind === 'method');
+          if (sameFile.length > 0) {
+            targets = [...sameFile];
+          }
+        }
+      }
+    }
 
     for (const t of targets) {
       const edgeKey = `${caller.id}|${t.id}`;
@@ -542,6 +620,7 @@ function buildCallEdges(
         relPath,
         typeMap,
         seenCallEdges,
+        importedNames,
       );
       if (recv) {
         stmts.insertEdge.run(recv.callerId, recv.receiverId, 'receiver', recv.confidence, 0);

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

@@ -15,7 +15,14 @@ import {
   MIGRATIONS,
   openDb,
 } from '../../../db/index.js';
-import { detectWorkspaces, loadConfig } from '../../../infrastructure/config.js';
+import {
+  computeConfigHash,
+  detectWorkspaces,
+  getLastAppliedGlobalConfig,
+  getLastAppliedGlobalPath,
+  loadConfig,
+  promptForConsentIfNeeded,
+} from '../../../infrastructure/config.js';
 import { debug, info, warn } from '../../../infrastructure/logger.js';
 import { loadNative } from '../../../infrastructure/native.js';
 import { toErrorMessage } from '../../../shared/errors.js';
@@ -114,6 +121,16 @@ function checkEngineSchemaMismatch(ctx: PipelineContext): void {
     );
     ctx.forceFullRebuild = true;
   }
+
+  // Config hash — promotes to full rebuild when build-relevant config changes
+  // (include/exclude/ignoreDirs/extensions/aliases/build.*).
+  // This closes the pre-existing config-change gap and covers the new global-config layer.
+  const currentConfigHash = computeConfigHash(ctx.config);
+  const prevConfigHash = meta('config_hash');
+  if (prevConfigHash && prevConfigHash !== currentConfigHash) {
+    info('Build-relevant config changed, promoting to full rebuild.');
+    ctx.forceFullRebuild = true;
+  }
 }
 
 function warnOnEmbeddingsWipe(ctx: PipelineContext): void {
@@ -172,7 +189,7 @@ function setupPipeline(ctx: PipelineContext): void {
   ctx.db = openDb(ctx.dbPath);
   initSchema(ctx.db);
 
-  ctx.config = loadConfig(ctx.rootDir);
+  ctx.config = loadConfig(ctx.rootDir, { userConfig: ctx.opts.userConfig });
   // Merge caller-supplied excludes on top of the file-config excludes so
   // programmatic callers (e.g. benchmark scripts) can extend exclusion
   // without mutating .codegraphrc.json. Native orchestrator picks this up
@@ -186,6 +203,30 @@ function setupPipeline(ctx: PipelineContext): void {
   ctx.incremental =
     ctx.opts.incremental !== false && ctx.config.build && ctx.config.build.incremental !== false;
 
+  // ── Build-time global-config notice ──────────────────────────────
+  // Use the already-parsed and sanitized global config cached by loadConfig —
+  // avoids a second disk read and the TOCTOU window between loadConfig and here.
+  const appliedGlobalPath = getLastAppliedGlobalPath();
+  if (appliedGlobalPath) {
+    const buildAffectingKeys = [
+      'include',
+      'exclude',
+      'ignoreDirs',
+      'extensions',
+      'aliases',
+      'build',
+    ];
+    const globalData = getLastAppliedGlobalConfig();
+    if (globalData) {
+      const injectedKeys = buildAffectingKeys.filter((k) => k in globalData);
+      if (injectedKeys.length > 0) {
+        process.stderr.write(
+          `ℹ global config applied (${appliedGlobalPath}) — injecting: ${injectedKeys.join(', ')} · --no-user-config to ignore\n`,
+        );
+      }
+    }
+  }
+
   initializeEngine(ctx);
   checkEngineSchemaMismatch(ctx);
   warnOnEmbeddingsWipe(ctx);
@@ -348,6 +389,12 @@ export async function buildGraph(
   ctx.rootDir = rootDir;
 
   try {
+    // Interactive consent prompt — only fires when the caller opts in (build
+    // command with TTY), a global file exists, and the repo is undecided.
+    if (opts.promptForConsent) {
+      await promptForConsentIfNeeded(rootDir);
+    }
+
     setupPipeline(ctx);
 
     // ── JS-side fast-skip for native incremental (#1054) ──────────────