@optave/codegraph 3.12.0 → 3.15.0

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

@@ -114,10 +114,12 @@ function buildContainmentEdges(
 // Lazily-cached prepared statements for reverse-dep operations
 let _revDepDb: BetterSqlite3Database | null = null;
 let _findRevDepsStmt: SqliteStatement | null = null;
+let _deleteDataflowByCallEdgeStmt: SqliteStatement | null | undefined; // undefined = not yet tried
 let _deleteOutEdgesStmt: SqliteStatement | null = null;
 
 function getRevDepStmts(db: BetterSqlite3Database): {
   findRevDepsStmt: SqliteStatement;
+  deleteDataflowByCallEdgeStmt: SqliteStatement | null;
   deleteOutEdgesStmt: SqliteStatement;
 } {
   if (_revDepDb !== db) {
@@ -128,12 +130,24 @@ function getRevDepStmts(db: BetterSqlite3Database): {
        JOIN nodes n_tgt ON e.target_id = n_tgt.id
        WHERE n_tgt.file = ? AND n_src.file != ? AND n_src.kind != 'directory'`,
     );
+    // Delete inter-procedural dataflow rows whose call_edge_id references an
+    // outgoing edge from this file. Must run before deleteOutEdgesStmt to avoid
+    // SQLITE_CONSTRAINT_FOREIGNKEY: dataflow.call_edge_id REFERENCES edges(id).
+    try {
+      _deleteDataflowByCallEdgeStmt = db.prepare(
+        `DELETE FROM dataflow WHERE call_edge_id IN
+           (SELECT id FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?))`,
+      );
+    } catch {
+      _deleteDataflowByCallEdgeStmt = null; // dataflow table or call_edge_id column absent
+    }
     _deleteOutEdgesStmt = db.prepare(
       'DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)',
     );
   }
   return {
     findRevDepsStmt: _findRevDepsStmt!,
+    deleteDataflowByCallEdgeStmt: _deleteDataflowByCallEdgeStmt ?? null,
     deleteOutEdgesStmt: _deleteOutEdgesStmt!,
   };
 }
@@ -144,7 +158,10 @@ function findReverseDeps(db: BetterSqlite3Database, relPath: string): string[] {
 }
 
 function deleteOutgoingEdges(db: BetterSqlite3Database, relPath: string): void {
-  const { deleteOutEdgesStmt } = getRevDepStmts(db);
+  const { deleteDataflowByCallEdgeStmt, deleteOutEdgesStmt } = getRevDepStmts(db);
+  // Clear any inter-procedural dataflow rows that reference outgoing edges via
+  // call_edge_id before deleting those edges (FK: dataflow.call_edge_id → edges.id).
+  deleteDataflowByCallEdgeStmt?.run(relPath);
   deleteOutEdgesStmt.run(relPath);
 }
 
@@ -482,6 +499,215 @@ function makeIncrementalLookup(db: BetterSqlite3Database, stmts: IncrementalStmt
   };
 }
 
+/** Coerce symbols.typeMap (Map, Array, or undefined) to a canonical Map. */
+function coerceTypeMap(symbols: ExtractorOutput): Map<string, unknown> {
+  const rawTM: unknown = symbols.typeMap;
+  if (rawTM instanceof Map) return rawTM;
+  if (Array.isArray(rawTM) && rawTM.length > 0) {
+    return new Map(
+      (rawTM as Array<{ name: string; typeName?: string; type?: string }>).map((e) => [
+        e.name,
+        e.typeName ?? e.type ?? null,
+      ]),
+    );
+  }
+  return new Map();
+}
+
+/**
+ * Seed scoped rest-param keys into typeMap (Phase 8.3f).
+ * Mirrors buildObjectRestParamPostPass in the full build.
+ *
+ * Scoped keys (`callee::restName`) 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.
+ */
+function seedRestParamTypeMap(typeMap: Map<string, unknown>, symbols: ExtractorOutput): void {
+  if (!symbols.objectRestParamBindings?.length || !symbols.paramBindings?.length) return;
+
+  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 });
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Normalize symbols.typeMap into a canonical Map and seed scoped rest-param
+ * keys (Phase 8.3f). Mirrors buildObjectRestParamPostPass in the full build.
+ */
+function buildIncrementalTypeMap(symbols: ExtractorOutput): Map<string, unknown> {
+  const typeMap = coerceTypeMap(symbols);
+  seedRestParamTypeMap(typeMap, symbols);
+  return typeMap;
+}
+
+/**
+ * Strategy 1 — same-class `this.method()` fallback.
+ * Derives the enclosing class name from callerName by extracting the segment
+ * immediately before the final dot (e.g. `MyClass.method` → `MyClass`,
+ * `Namespace.MyClass.method` → `MyClass`), then retries with the qualified
+ * method name `MyClass.callName`.
+ *
+ * Uses lastIndexOf to match the full-build counterpart in resolveFallbackTargets
+ * (build-edges.ts) — indexOf would extract `Namespace` instead of `MyClass` for
+ * deeply-qualified caller names like `Namespace.MyClass.method`.
+ */
+function resolveThisSameClassTarget(
+  callName: string,
+  callerName: string,
+  relPath: string,
+  lookup: CallNodeLookup,
+): Array<{ id: number; file: string; kind?: string }> {
+  const lastDot = callerName.lastIndexOf('.');
+  if (lastDot <= 0) return [];
+  const prevDot = callerName.lastIndexOf('.', lastDot - 1);
+  const className = callerName.slice(prevDot + 1, lastDot);
+  return lookup
+    .byNameAndFile(`${className}.${callName}`, relPath)
+    .filter((n) => n.kind === 'method');
+}
+
+/**
+ * Strategy 2 — Object.defineProperty accessor fallback.
+ * When a function is registered as a getter/setter via
+ * `Object.defineProperty(obj, "bar", { get: getter })`, calls to `this.X()`
+ * inside `getter` resolve against `obj`. Looks up the receiver var in the
+ * typeMap for its type, then falls back to any same-file definition named
+ * `callName` with function or method kind.
+ */
+function resolveDefinePropertyTarget(
+  callName: string,
+  callerName: string,
+  relPath: string,
+  typeMap: Map<string, unknown>,
+  lookup: CallNodeLookup,
+  definePropertyReceivers: Map<string, string>,
+): Array<{ id: number; file: string; kind?: string }> {
+  const receiverVarName = definePropertyReceivers.get(callerName);
+  if (!receiverVarName) return [];
+
+  const typeEntry = typeMap.get(receiverVarName);
+  const typeName = typeEntry
+    ? typeof typeEntry === 'string'
+      ? typeEntry
+      : (typeEntry as { type?: string }).type
+    : null;
+  if (typeName) {
+    const qualified = lookup.byNameAndFile(`${typeName}.${callName}`, relPath);
+    if (qualified.length > 0) return [...qualified];
+  }
+  // Narrow to function/method kinds only to avoid matching unrelated
+  // variables or classes that share a name in the same file.
+  return lookup
+    .byNameAndFile(callName, relPath)
+    .filter((n) => n.kind === 'function' || n.kind === 'method');
+}
+
+/**
+ * Apply `this`-receiver fallback resolution strategies for a single call site
+ * when the primary resolveCallTargets pass returned no targets.
+ */
+function applyThisReceiverFallbacks(
+  call: { name: string; receiver?: string | null },
+  callerName: string | null,
+  relPath: string,
+  typeMap: Map<string, unknown>,
+  lookup: CallNodeLookup,
+  definePropertyReceivers: Map<string, string> | undefined,
+  initialTargets: Array<{ id: number; file: string; kind?: string }>,
+): Array<{ id: number; file: string; kind?: string }> {
+  if (initialTargets.length > 0) return initialTargets;
+
+  // Strategy 1: same-class `this.method()` fallback.
+  if (call.receiver === 'this' && callerName != null) {
+    const s1 = resolveThisSameClassTarget(call.name, callerName, relPath, lookup);
+    if (s1.length > 0) return s1;
+  }
+
+  // Strategy 2: Object.defineProperty accessor fallback.
+  if (call.receiver === 'this' && callerName != null && definePropertyReceivers) {
+    return resolveDefinePropertyTarget(
+      call.name,
+      callerName,
+      relPath,
+      typeMap,
+      lookup,
+      definePropertyReceivers,
+    );
+  }
+
+  return initialTargets;
+}
+
+/**
+ * Emit direct `calls` edges for the resolved targets of a single call site,
+ * then emit a `receiver` edge when the call has a non-this/self/super receiver.
+ * Returns the number of edges inserted.
+ */
+function emitIncrementalCallEdges(
+  call: { name: string; receiver?: string | null; dynamic?: boolean },
+  caller: { id: number; callerName: string | null },
+  targets: Array<{ id: number; file: string; kind?: string }>,
+  importedFrom: string | null | undefined,
+  relPath: string,
+  typeMap: Map<string, unknown>,
+  lookup: CallNodeLookup,
+  importedNames: Map<string, string>,
+  seenCallEdges: Set<string>,
+  stmts: IncrementalStmts,
+): number {
+  let edgesAdded = 0;
+
+  for (const t of targets) {
+    const edgeKey = `${caller.id}|${t.id}`;
+    if (t.id !== caller.id && !seenCallEdges.has(edgeKey)) {
+      seenCallEdges.add(edgeKey);
+      const confidence = computeConfidence(relPath, t.file, importedFrom ?? null);
+      stmts.insertEdge.run(caller.id, t.id, 'calls', confidence, call.dynamic ? 1 : 0);
+      edgesAdded++;
+    }
+  }
+
+  if (
+    call.receiver &&
+    !BUILTIN_RECEIVERS.has(call.receiver) &&
+    call.receiver !== 'this' &&
+    call.receiver !== 'self' &&
+    call.receiver !== 'super'
+  ) {
+    const recv = resolveReceiverEdge(
+      lookup,
+      { name: call.name, receiver: call.receiver },
+      caller,
+      relPath,
+      typeMap,
+      seenCallEdges,
+      importedNames,
+    );
+    if (recv) {
+      stmts.insertEdge.run(recv.callerId, recv.receiverId, 'receiver', recv.confidence, 0);
+      edgesAdded++;
+    }
+  }
+
+  return edgesAdded;
+}
+
 function buildCallEdges(
   db: BetterSqlite3Database,
   stmts: IncrementalStmts,
@@ -490,46 +716,7 @@ function buildCallEdges(
   fileNodeRow: { id: number },
   importedNames: Map<string, string>,
 ): number {
-  const rawTM: unknown = symbols.typeMap;
-  const typeMap: Map<string, unknown> =
-    rawTM instanceof Map
-      ? rawTM
-      : Array.isArray(rawTM) && rawTM.length > 0
-        ? new Map(
-            (rawTM as Array<{ name: string; typeName?: string; type?: string }>).map((e) => [
-              e.name,
-              e.typeName ?? e.type ?? null,
-            ]),
-          )
-        : 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 typeMap = buildIncrementalTypeMap(symbols);
   const seenCallEdges = new Set<string>();
   const lookup = makeIncrementalLookup(db, stmts);
   let edgesAdded = 0;
@@ -546,86 +733,29 @@ function buildCallEdges(
       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}`;
-      if (t.id !== caller.id && !seenCallEdges.has(edgeKey)) {
-        seenCallEdges.add(edgeKey);
-        const confidence = computeConfidence(relPath, t.file, importedFrom ?? null);
-        stmts.insertEdge.run(caller.id, t.id, 'calls', confidence, call.dynamic ? 1 : 0);
-        edgesAdded++;
-      }
-    }
+    const targets = applyThisReceiverFallbacks(
+      call,
+      caller.callerName,
+      relPath,
+      typeMap,
+      lookup,
+      symbols.definePropertyReceivers,
+      initialTargets,
+    );
 
-    if (
-      call.receiver &&
-      !BUILTIN_RECEIVERS.has(call.receiver) &&
-      call.receiver !== 'this' &&
-      call.receiver !== 'self' &&
-      call.receiver !== 'super'
-    ) {
-      const recv = resolveReceiverEdge(
-        lookup,
-        { name: call.name, receiver: call.receiver },
-        caller,
-        relPath,
-        typeMap,
-        seenCallEdges,
-      );
-      if (recv) {
-        stmts.insertEdge.run(recv.callerId, recv.receiverId, 'receiver', recv.confidence, 0);
-        edgesAdded++;
-      }
-    }
+    edgesAdded += emitIncrementalCallEdges(
+      call,
+      caller,
+      targets,
+      importedFrom,
+      relPath,
+      typeMap,
+      lookup,
+      importedNames,
+      seenCallEdges,
+      stmts,
+    );
   }
   return edgesAdded;
 }

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';
@@ -55,7 +62,9 @@ export {
 
 function initializeEngine(ctx: PipelineContext): void {
   ctx.engineOpts = {
-    engine: ctx.opts.engine || 'auto',
+    // Priority: CLI --engine flag > .codegraphrc.json build.engine > 'auto'.
+    // ctx.config is already populated by the time initializeEngine is called.
+    engine: ctx.opts.engine ?? ctx.config.build.engine ?? 'auto',
     dataflow: ctx.opts.dataflow !== false,
     ast: ctx.opts.ast !== false,
     // nativeDb and WAL callbacks are set later when NativeDatabase is opened
@@ -114,6 +123,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 {
@@ -157,8 +176,13 @@ function setupPipeline(ctx: PipelineContext): void {
     ? path.resolve(ctx.opts.dbPath)
     : path.join(ctx.rootDir, '.codegraph', 'graph.db');
 
+  // Load config first so build.engine from .codegraphrc.json is available for
+  // the engine-pref fallback below (ctx.opts.engine > config.build.engine > 'auto').
+  ctx.config = loadConfig(ctx.rootDir, { userConfig: ctx.opts.userConfig });
+
   // Detect whether native engine is available.
-  const enginePref = ctx.opts.engine || 'auto';
+  // Priority: CLI --engine flag > .codegraphrc.json build.engine > 'auto'.
+  const enginePref = ctx.opts.engine ?? ctx.config.build.engine ?? 'auto';
   const native = enginePref !== 'wasm' ? loadNative() : null;
   ctx.nativeAvailable = !!native?.NativeDatabase;
 
@@ -171,8 +195,6 @@ function setupPipeline(ctx: PipelineContext): void {
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
   ctx.db = openDb(ctx.dbPath);
   initSchema(ctx.db);
-
-  ctx.config = loadConfig(ctx.rootDir);
   // 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 +208,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 +394,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) ──────────────
@@ -364,7 +416,8 @@ export async function buildGraph(
     // engineName, scope, etc.) we log the reason so the bench gate run
     // produces observable output even if `detectNoChanges` is never
     // entered.
-    const fastSkipDiag = process.env.CODEGRAPH_FAST_SKIP_DIAG === '1';
+    // Reads from config (which applies CODEGRAPH_FAST_SKIP_DIAG via applyEnvOverrides).
+    const fastSkipDiag = ctx.config.build.fastSkipDiag;
     if (fastSkipDiag) {
       const reasons: string[] = [];
       if (!ctx.nativeAvailable) reasons.push('nativeAvailable=false');