@optave/codegraph 3.9.1 → 3.9.3

package/src/domain/analysis/dependencies.ts

@@ -2,7 +2,7 @@ import { findFileNodes, type Repository } from '../../db/index.js';
 import { cachedStmt } from '../../db/repository/cached-stmt.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import { resolveMethodViaHierarchy } from '../../shared/hierarchy.js';
-import { normalizeSymbol } from '../../shared/normalize.js';
+import { normalizeSymbol, toSymbolRef } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
 import type {
   BetterSqlite3Database,
@@ -143,12 +143,8 @@ function buildNodeDepsResult(
 
   return {
     ...normalizeSymbol(node, repo, hc),
-    callees: filteredCallees.map((c) => ({
-      name: c.name,
-      kind: c.kind,
-      file: c.file,
-      line: c.line,
-    })),
+    callees: filteredCallees.map(toSymbolRef),
+    // Not using toSymbolRef — callers include the extra viaHierarchy field
     callers: callers.map((c) => ({
       name: c.name,
       kind: c.kind,
@@ -245,20 +241,14 @@ function resolveEndpoints(
         to,
         found: false,
         error: `No symbol matching "${to}"`,
-        fromCandidates: fromNodes
-          .slice(0, 5)
-          .map((n) => ({ name: n.name, kind: n.kind, file: n.file, line: n.line })),
+        fromCandidates: fromNodes.slice(0, 5).map(toSymbolRef),
         toCandidates: [],
       },
     };
   }
 
-  const fromCandidates = fromNodes
-    .slice(0, 5)
-    .map((n) => ({ name: n.name, kind: n.kind, file: n.file, line: n.line }));
-  const toCandidates = toNodes
-    .slice(0, 5)
-    .map((n) => ({ name: n.name, kind: n.kind, file: n.file, line: n.line }));
+  const fromCandidates = fromNodes.slice(0, 5).map(toSymbolRef);
+  const toCandidates = toNodes.slice(0, 5).map(toSymbolRef);
 
   return {
     sourceNode: fromNodes[0],

package/src/domain/analysis/diff-impact.ts

@@ -307,6 +307,33 @@ export function diffImpactData(
     }
 
     const affectedFunctions = findAffectedFunctions(db, changedRanges, noTests);
+
+    // Short-circuit: when no function-level changes detected, skip expensive
+    // lookups (BFS, co-change, ownership).  Boundary checks are preserved
+    // because they are file-scoped and can surface real violations even when
+    // no function bodies were touched (e.g. import or type-alias changes).
+    if (affectedFunctions.length === 0) {
+      const { boundaryViolations, boundaryViolationCount } = checkBoundaryViolations(
+        db,
+        changedRanges,
+        noTests,
+        { ...opts, config },
+        repoRoot,
+      );
+      const base = {
+        changedFiles: changedRanges.size,
+        newFiles: [...newFiles],
+        affectedFunctions: [] as unknown[],
+        affectedFiles: [] as string[],
+        historicallyCoupled: [] as unknown[],
+        ownership: null,
+        boundaryViolations,
+        boundaryViolationCount,
+        summary: null as null,
+      };
+      return paginateResult(base, 'affectedFunctions', { limit: opts.limit, offset: opts.offset });
+    }
+
     const includeImplementors = opts.includeImplementors !== false;
     const { functionResults, allAffected } = buildFunctionImpactResults(
       db,
@@ -325,7 +352,7 @@ export function diffImpactData(
       db,
       changedRanges,
       noTests,
-      opts,
+      { ...opts, config },
       repoRoot,
     );
 

package/src/domain/analysis/fn-impact.ts

@@ -1,6 +1,6 @@
 import { Repository, SqliteRepository } from '../../db/index.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
-import { normalizeSymbol } from '../../shared/normalize.js';
+import { normalizeSymbol, toSymbolRef } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
 import type { BetterSqlite3Database, NodeRow, RelatedNodeRow } from '../../types.js';
 import { resolveAnalysisOpts, withRepo } from './query-helpers.js';
@@ -125,7 +125,7 @@ export function bfsTransitiveCallers(
           visited.add(c.id);
           nextFrontier.push(c.id);
           if (!levels[d]) levels[d] = [];
-          levels[d]!.push({ name: c.name, kind: c.kind, file: c.file, line: c.line });
+          levels[d]!.push(toSymbolRef(c));
           if (onVisit) onVisit(c, fid, d);
         }
         if (resolveImplementors && INTERFACE_LIKE_KINDS.has(c.kind)) {

package/src/domain/analysis/implementations.ts

@@ -1,6 +1,6 @@
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import { CORE_SYMBOL_KINDS } from '../../shared/kinds.js';
-import { normalizeSymbol } from '../../shared/normalize.js';
+import { normalizeSymbol, toSymbolRef } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
 import type { RelatedNodeRow } from '../../types.js';
 import { withRepo } from './query-helpers.js';
@@ -34,12 +34,7 @@ export function implementationsData(
 
       return {
         ...normalizeSymbol(node, repo, hc),
-        implementors: implementors.map((impl) => ({
-          name: impl.name,
-          kind: impl.kind,
-          file: impl.file,
-          line: impl.line,
-        })),
+        implementors: implementors.map(toSymbolRef),
       };
     });
 
@@ -76,12 +71,7 @@ export function interfacesData(
 
       return {
         ...normalizeSymbol(node, repo, hc),
-        interfaces: interfaces.map((iface) => ({
-          name: iface.name,
-          kind: iface.kind,
-          file: iface.file,
-          line: iface.line,
-        })),
+        interfaces: interfaces.map(toSymbolRef),
       };
     });
 

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

@@ -33,6 +33,10 @@ export class PipelineContext {
   forceFullRebuild: boolean = false;
   schemaVersion!: number;
   nativeDb?: NativeDatabase;
+  /** Whether native engine is available (deferred — DB opened only when needed). */
+  nativeAvailable: boolean = false;
+  /** True when ctx.db is a NativeDbProxy — single rusqlite connection for the entire pipeline. */
+  nativeFirstProxy: boolean = false;
 
   // ── File collection (set by collectFiles stage) ────────────────────
   allFiles!: string[];

package/src/domain/graph/builder/native-db-proxy.ts

@@ -0,0 +1,104 @@
+/**
+ * NativeDbProxy — wraps a NativeDatabase (rusqlite via napi-rs) to satisfy the
+ * BetterSqlite3Database interface.  When the native addon is available, the
+ * build pipeline uses this proxy as `ctx.db` so that every stage operates on a
+ * single rusqlite connection — no dual-connection WAL corruption, no
+ * open/close/reopen dance.
+ *
+ * When native is unavailable, the pipeline falls back to real better-sqlite3.
+ */
+
+import type { BetterSqlite3Database, NativeDatabase, SqliteStatement } from '../../../types.js';
+
+/** Sanitize params for napi-rs: better-sqlite3 treats `undefined` as NULL,
+ *  but serde_json cannot represent `undefined`. Replace with `null`. */
+function sanitize(params: unknown[]): Array<string | number | null> {
+  return params.map((p) => (p === undefined ? null : p)) as Array<string | number | null>;
+}
+
+export class NativeDbProxy implements BetterSqlite3Database {
+  readonly #ndb: NativeDatabase;
+  /** Advisory lock path — set by the pipeline so closeDb() can release it. */
+  __lockPath?: string;
+
+  constructor(nativeDb: NativeDatabase) {
+    this.#ndb = nativeDb;
+  }
+
+  prepare<TRow = unknown>(sql: string): SqliteStatement<TRow> {
+    const ndb = this.#ndb;
+    // Only INSERT statements need last_insert_rowid — skip the extra napi
+    // call for UPDATE/DELETE/other DML to halve per-statement overhead.
+    const isInsert = sql.trimStart().substring(0, 6).toUpperCase() === 'INSERT';
+    const stmt: SqliteStatement<TRow> = {
+      all(...params: unknown[]): TRow[] {
+        return ndb.queryAll(sql, sanitize(params)) as TRow[];
+      },
+      get(...params: unknown[]): TRow | undefined {
+        return (ndb.queryGet(sql, sanitize(params)) ?? undefined) as TRow | undefined;
+      },
+      run(...params: unknown[]): { changes: number; lastInsertRowid: number | bigint } {
+        ndb.queryAll(sql, sanitize(params));
+        if (isInsert) {
+          const row = ndb.queryGet('SELECT last_insert_rowid() AS rid', []) as {
+            rid: number;
+          } | null;
+          return { changes: 0, lastInsertRowid: row?.rid ?? 0 };
+        }
+        return { changes: 0, lastInsertRowid: 0 };
+      },
+      iterate(): IterableIterator<TRow> {
+        throw new Error('iterate() is not supported via NativeDbProxy');
+      },
+      raw(): SqliteStatement<TRow> {
+        return stmt; // no-op — .raw() is not used in the build pipeline
+      },
+    };
+    return stmt;
+  }
+
+  exec(sql: string): this {
+    this.#ndb.exec(sql);
+    return this;
+  }
+
+  pragma(sql: string): unknown {
+    return this.#ndb.pragma(sql);
+  }
+
+  close(): void {
+    // No-op: the pipeline manages the NativeDatabase lifecycle directly.
+    // closeDbPair() calls nativeDb.close() separately.
+  }
+
+  get open(): boolean {
+    return this.#ndb.isOpen;
+  }
+
+  get name(): string {
+    return this.#ndb.dbPath;
+  }
+
+  transaction<F extends (...args: any[]) => any>(
+    fn: F,
+  ): (...args: F extends (...a: infer A) => unknown ? A : never) => ReturnType<F> {
+    const ndb = this.#ndb;
+    return ((...args: unknown[]) => {
+      // NOTE: nested transactions (savepoints) are not supported — ensure callers
+      // do not invoke a transaction() wrapper from within an existing transaction.
+      ndb.exec('BEGIN');
+      try {
+        const result = fn(...args);
+        ndb.exec('COMMIT');
+        return result;
+      } catch (e) {
+        try {
+          ndb.exec('ROLLBACK');
+        } catch {
+          // Ignore rollback errors — the original error is more important
+        }
+        throw e;
+      }
+    }) as any;
+  }
+}