perf: route query analysis through native Rust engine (#745)

* perf: route query analysis functions through native Rust engine

Query analysis functions (fnDepsData, fnImpactData, fileDepsData,
impactAnalysisData, briefData, implementationsData, interfacesData)
were hardcoded to use openReadonlyOrFail() (better-sqlite3), completely
bypassing the native Rust engine for queries even when --engine native
was set.

Add withRepo() helper that mirrors withReadonlyDb() but routes through
openRepo(), which tries NativeRepository (rusqlite) first and falls
back to SqliteRepository (better-sqlite3). Migrate 7 analysis functions
to use it.

Infrastructure changes:
- Add getFileHash, hasImplementsEdges, hasCoChangesTable to Repository
- Update normalizeSymbol to accept Repository in addition to DbHandle
- Refactor buildTransitiveCallers to use repo.findCallers() instead of
  raw SQL prepared statements

bfsTransitiveCallers accepts both BetterSqlite3Database and Repository
for backward compatibility with check.ts and audit.ts callers.

* perf(native): add Rust NAPI methods for getFileHash, hasImplementsEdges, hasCoChangesTable

Removes conservative placeholder implementations in NativeRepository
by adding proper Rust #[napi] query methods that mirror SqliteRepository
behavior. Falls back gracefully when running against a prebuilt native
addon that predates these methods.

* style: fix quote style in native-repository typeof guards

* fix: resolve native engine parity gaps for fileHash and method hierarchy (#745)

- Port resolveMethodViaHierarchy to accept Repository (not just raw DB),
  so hierarchy-based caller discovery works on both native and WASM paths
- Add lazy better-sqlite3 fallback in NativeRepository for getFileHash,
  hasImplementsEdges, and hasCoChangesTable until Rust implements them
- Pass dbPath to NativeRepository constructor; close fallback on dispose
- Remove SqliteRepository instanceof check from fnDepsData

* fix: memoize hasImplementsEdges in SqliteRepository (#745)

Cache the result of the implements-edge check to avoid re-querying
on every call, restoring the per-connection caching behavior that
existed before the refactor.

* fix: memoize hasCoChangesTable in both repository implementations (#745)

* fix: cache toRepo wrapper to preserve per-instance memoization (#745)

Legacy raw-db callers of bfsTransitiveCallers create a SqliteRepository
via toRepo on each call. Without caching, hasImplementsEdges memoization
is lost between calls. A WeakMap keyed on the db handle now ensures the
same Repository instance is reused across calls with the same connection.

Author: carlos-alm

crates/codegraph-core/src/read_queries.rs

@@ -1128,6 +1128,51 @@ impl NativeDatabase {
         }
     }
 
+    /// Check whether the graph contains any 'implements' edges.
+    #[napi]
+    pub fn has_implements_edges(&self) -> napi::Result<bool> {
+        let conn = self.conn()?;
+        match conn
+            .prepare("SELECT 1 FROM edges WHERE kind = 'implements' LIMIT 1")
+            .and_then(|mut stmt| stmt.query_row([], |_| Ok(())))
+        {
+            Ok(()) => Ok(true),
+            Err(rusqlite::Error::SqliteFailure(_, _)) => Ok(false),
+            Err(rusqlite::Error::QueryReturnedNoRows) => Ok(false),
+            Err(e) => Err(napi::Error::from_reason(format!("has_implements_edges: {e}"))),
+        }
+    }
+
+    /// Check whether the co_changes table exists and has data.
+    #[napi]
+    pub fn has_co_changes_table(&self) -> napi::Result<bool> {
+        let conn = self.conn()?;
+        match conn
+            .prepare("SELECT 1 FROM co_changes LIMIT 1")
+            .and_then(|mut stmt| stmt.query_row([], |_| Ok(())))
+        {
+            Ok(()) => Ok(true),
+            Err(rusqlite::Error::SqliteFailure(_, _)) => Ok(false),
+            Err(rusqlite::Error::QueryReturnedNoRows) => Ok(false),
+            Err(e) => Err(napi::Error::from_reason(format!("has_co_changes_table: {e}"))),
+        }
+    }
+
+    /// Look up the stored content hash for a single file.
+    #[napi]
+    pub fn get_file_hash(&self, file: String) -> napi::Result<Option<String>> {
+        let conn = self.conn()?;
+        match conn
+            .prepare_cached("SELECT hash FROM file_hashes WHERE file = ?1")
+            .and_then(|mut stmt| stmt.query_row(rusqlite::params![file], |row| row.get::<_, String>(0)))
+        {
+            Ok(hash) => Ok(Some(hash)),
+            Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
+            Err(rusqlite::Error::SqliteFailure(_, _)) => Ok(None),
+            Err(e) => Err(napi::Error::from_reason(format!("get_file_hash: {e}"))),
+        }
+    }
+
     /// Check whether dataflow table exists and has data.
     #[napi]
     pub fn has_dataflow_table(&self) -> napi::Result<bool> {

src/db/connection.ts

@@ -334,9 +334,11 @@ function openRepoNative(customDbPath?: string): { repo: Repository; close(): voi
   const ndb = native.NativeDatabase.openReadonly(dbPath);
   try {
     warnOnVersionMismatch(() => ndb.getBuildMeta('codegraph_version'));
+    const repo = new NativeRepository(ndb, dbPath);
     return {
-      repo: new NativeRepository(ndb),
+      repo,
       close() {
+        repo.closeFallback();
         ndb.close();
       },
     };

src/db/repository/base.ts

@@ -189,4 +189,24 @@ export class Repository implements IRepository {
   getComplexityForNode(_nodeId: number): ComplexityMetrics | undefined {
     throw new Error('not implemented');
   }
+
+  // ── Convenience queries ──────────────────────────────────────────────
+  /**
+   * Look up the stored content hash for a file.
+   * Returns null when the file is not in file_hashes or the method is
+   * not yet implemented on the concrete repository.
+   */
+  getFileHash(_file: string): string | null {
+    return null;
+  }
+
+  /** Check whether the graph contains any 'implements' edges. */
+  hasImplementsEdges(): boolean {
+    return false;
+  }
+
+  /** Check whether the co_changes table exists and has data. */
+  hasCoChangesTable(): boolean {
+    return false;
+  }
 }

src/db/repository/native-repository.ts

@@ -8,9 +8,11 @@
  * back to the snake_case field names that the Repository interface expects.
  */
 
+import Database from 'better-sqlite3';
 import { ConfigError } from '../../shared/errors.js';
 import type {
   AdjacentEdgeRow,
+  BetterSqlite3Database,
   CallableNodeRow,
   CallEdgeRow,
   ChildNodeRow,
@@ -159,10 +161,33 @@ function toComplexityMetrics(r: NativeComplexityMetrics): ComplexityMetrics {
 
 export class NativeRepository extends Repository {
   #ndb: NativeDatabase;
+  #dbPath?: string;
+  #fallbackDb?: BetterSqlite3Database;
 
-  constructor(ndb: NativeDatabase) {
+  constructor(ndb: NativeDatabase, dbPath?: string) {
     super();
     this.#ndb = ndb;
+    this.#dbPath = dbPath;
+  }
+
+  /** Lazy better-sqlite3 handle for methods not yet ported to Rust. */
+  #getFallbackDb(): BetterSqlite3Database | undefined {
+    if (this.#fallbackDb) return this.#fallbackDb;
+    if (!this.#dbPath) return undefined;
+    try {
+      this.#fallbackDb = new Database(this.#dbPath, { readonly: true });
+      return this.#fallbackDb;
+    } catch {
+      return undefined;
+    }
+  }
+
+  /** Close the lazy fallback connection if it was opened. */
+  closeFallback(): void {
+    if (this.#fallbackDb) {
+      this.#fallbackDb.close();
+      this.#fallbackDb = undefined;
+    }
   }
 
   // ── Node lookups ──────────────────────────────────────────────────
@@ -358,4 +383,57 @@ export class NativeRepository extends Repository {
     const r = this.#ndb.getComplexityForNode(nodeId);
     return r ? toComplexityMetrics(r) : undefined;
   }
+
+  // ── Convenience queries ────────────────────────────────────────────
+
+  getFileHash(file: string): string | null {
+    if (typeof this.#ndb.getFileHash === 'function') return this.#ndb.getFileHash(file);
+    // Fallback to better-sqlite3 until Rust implements getFileHash
+    const db = this.#getFallbackDb();
+    if (db) {
+      const row = db.prepare('SELECT hash FROM file_hashes WHERE file = ?').get(file) as
+        | { hash: string }
+        | undefined;
+      return row?.hash ?? null;
+    }
+    return null;
+  }
+
+  #implementsEdgesCache?: boolean;
+  hasImplementsEdges(): boolean {
+    if (this.#implementsEdgesCache !== undefined) return this.#implementsEdgesCache;
+    if (typeof this.#ndb.hasImplementsEdges === 'function') {
+      this.#implementsEdgesCache = this.#ndb.hasImplementsEdges();
+      return this.#implementsEdgesCache;
+    }
+    // Fallback to better-sqlite3
+    const db = this.#getFallbackDb();
+    if (db) {
+      this.#implementsEdgesCache = !!db
+        .prepare("SELECT 1 FROM edges WHERE kind = 'implements' LIMIT 1")
+        .get();
+      return this.#implementsEdgesCache;
+    }
+    return true; // conservative: assume yes when no fallback available
+  }
+
+  #coChangesTableCache?: boolean;
+  hasCoChangesTable(): boolean {
+    if (this.#coChangesTableCache !== undefined) return this.#coChangesTableCache;
+    if (typeof this.#ndb.hasCoChangesTable === 'function') {
+      this.#coChangesTableCache = this.#ndb.hasCoChangesTable();
+      return this.#coChangesTableCache;
+    }
+    // Fallback to better-sqlite3
+    const db = this.#getFallbackDb();
+    if (db) {
+      try {
+        this.#coChangesTableCache = !!db.prepare('SELECT 1 FROM co_changes LIMIT 1').get();
+      } catch {
+        this.#coChangesTableCache = false;
+      }
+      return this.#coChangesTableCache;
+    }
+    return false;
+  }
 }

src/db/repository/sqlite-repository.ts

@@ -245,4 +245,33 @@ export class SqliteRepository extends Repository {
   getComplexityForNode(nodeId: number): ComplexityMetrics | undefined {
     return getComplexityForNode(this.#db, nodeId);
   }
+
+  // ── Convenience queries ────────────────────────────────────────────
+
+  getFileHash(file: string): string | null {
+    const row = this.#db.prepare('SELECT hash FROM file_hashes WHERE file = ?').get(file) as
+      | { hash: string }
+      | undefined;
+    return row?.hash ?? null;
+  }
+
+  #implementsEdgesCache?: boolean;
+  hasImplementsEdges(): boolean {
+    if (this.#implementsEdgesCache !== undefined) return this.#implementsEdgesCache;
+    this.#implementsEdgesCache = !!this.#db
+      .prepare("SELECT 1 FROM edges WHERE kind = 'implements' LIMIT 1")
+      .get();
+    return this.#implementsEdgesCache;
+  }
+
+  #coChangesTableCache?: boolean;
+  hasCoChangesTable(): boolean {
+    if (this.#coChangesTableCache !== undefined) return this.#coChangesTableCache;
+    try {
+      this.#coChangesTableCache = !!this.#db.prepare('SELECT 1 FROM co_changes LIMIT 1').get();
+    } catch {
+      this.#coChangesTableCache = false;
+    }
+    return this.#coChangesTableCache;
+  }
 }

src/domain/analysis/brief.ts

@@ -1,15 +1,8 @@
-import {
-  findDistinctCallers,
-  findFileNodes,
-  findImportDependents,
-  findImportSources,
-  findImportTargets,
-  findNodesByFile,
-  openReadonlyOrFail,
-} from '../../db/index.js';
+import type { Repository } from '../../db/index.js';
 import { loadConfig } from '../../infrastructure/config.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
-import type { BetterSqlite3Database, ImportEdgeRow, NodeRow, RelatedNodeRow } from '../../types.js';
+import type { ImportEdgeRow, NodeRow, RelatedNodeRow } from '../../types.js';
+import { withRepo } from './query-helpers.js';
 
 /** Symbol kinds meaningful for a file brief — excludes parameters, properties, constants. */
 const BRIEF_KINDS = new Set([
@@ -49,7 +42,7 @@ function computeRiskTier(
  * Lightweight variant — only counts, does not collect details.
  */
 function countTransitiveCallers(
-  db: BetterSqlite3Database,
+  repo: InstanceType<typeof Repository>,
   startId: number,
   noTests: boolean,
   maxDepth = 5,
@@ -60,7 +53,7 @@ function countTransitiveCallers(
   for (let d = 1; d <= maxDepth; d++) {
     const nextFrontier: number[] = [];
     for (const fid of frontier) {
-      const callers = findDistinctCallers(db, fid) as RelatedNodeRow[];
+      const callers = repo.findDistinctCallers(fid) as RelatedNodeRow[];
       for (const c of callers) {
         if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
           visited.add(c.id);
@@ -80,7 +73,7 @@ function countTransitiveCallers(
  * Depth-bounded to match countTransitiveCallers and keep hook latency predictable.
  */
 function countTransitiveImporters(
-  db: BetterSqlite3Database,
+  repo: InstanceType<typeof Repository>,
   fileNodeIds: number[],
   noTests: boolean,
   maxDepth = 5,
@@ -91,7 +84,7 @@ function countTransitiveImporters(
   for (let d = 1; d <= maxDepth; d++) {
     const nextFrontier: number[] = [];
     for (const current of frontier) {
-      const dependents = findImportDependents(db, current) as RelatedNodeRow[];
+      const dependents = repo.findImportDependents(current) as RelatedNodeRow[];
       for (const dep of dependents) {
         if (!visited.has(dep.id) && (!noTests || !isTestFile(dep.file))) {
           visited.add(dep.id);
@@ -115,38 +108,37 @@ export function briefData(
   customDbPath: string,
   opts: { noTests?: boolean; config?: any } = {},
 ) {
-  const db = openReadonlyOrFail(customDbPath);
-  try {
+  return withRepo(customDbPath, (repo) => {
     const noTests = opts.noTests || false;
     const config = opts.config || loadConfig();
     const callerDepth = config.analysis?.briefCallerDepth ?? 5;
     const importerDepth = config.analysis?.briefImporterDepth ?? 5;
     const highRiskCallers = config.analysis?.briefHighRiskCallers ?? 10;
     const mediumRiskCallers = config.analysis?.briefMediumRiskCallers ?? 3;
-    const fileNodes = findFileNodes(db, `%${file}%`) as NodeRow[];
+    const fileNodes = repo.findFileNodes(`%${file}%`) as NodeRow[];
     if (fileNodes.length === 0) {
       return { file, results: [] };
     }
 
     const results = fileNodes.map((fn) => {
       // Direct importers
-      let importedBy = findImportSources(db, fn.id) as ImportEdgeRow[];
+      let importedBy = repo.findImportSources(fn.id) as ImportEdgeRow[];
       if (noTests) importedBy = importedBy.filter((i) => !isTestFile(i.file));
       const directImporters = [...new Set(importedBy.map((i) => i.file))];
 
       // Transitive importer count
-      const totalImporterCount = countTransitiveImporters(db, [fn.id], noTests, importerDepth);
+      const totalImporterCount = countTransitiveImporters(repo, [fn.id], noTests, importerDepth);
 
       // Direct imports
-      let importsTo = findImportTargets(db, fn.id) as ImportEdgeRow[];
+      let importsTo = repo.findImportTargets(fn.id) as ImportEdgeRow[];
       if (noTests) importsTo = importsTo.filter((i) => !isTestFile(i.file));
 
       // Symbol definitions with roles and caller counts
-      const defs = (findNodesByFile(db, fn.file) as NodeRow[]).filter((d) =>
+      const defs = (repo.findNodesByFile(fn.file) as NodeRow[]).filter((d) =>
         BRIEF_KINDS.has(d.kind),
       );
       const symbols = defs.map((d) => {
-        const callerCount = countTransitiveCallers(db, d.id, noTests, callerDepth);
+        const callerCount = countTransitiveCallers(repo, d.id, noTests, callerDepth);
         return {
           name: d.name,
           kind: d.kind,
@@ -169,7 +161,5 @@ export function briefData(
     });
 
     return { file, results };
-  } finally {
-    db.close();
-  }
+  });
 }