refactor: migrate integration tests to InMemoryRepository (#462)

* docs: move 3.16 items to new Phase 5 (Runtime & Extensibility)

Expand the deferred Phase 3 items into a dedicated phase after
TypeScript Migration with detailed descriptions for each sub-item:
event-driven pipeline, unified engine strategy, subgraph export
filtering, transitive confidence, query caching, config profiles,
pagination standardization, and plugin system.

Renumber subsequent phases 5-9 → 6-10 with all cross-references
updated.

* refactor: migrate integration tests to InMemoryRepository

Add openRepo() utility that accepts an injected Repository instance or
falls back to SQLite, enabling tests to bypass the filesystem entirely.

- Add openRepo(dbPath, opts) to src/db/connection.js
- Make findMatchingNodes and buildDependencyGraph polymorphic (accept
  db or Repository via instanceof check)
- Refactor triageData, sequenceData, communitiesData to use openRepo
- Convert triage, sequence, communities test fixtures to createTestRepo()
  fluent builder (sequence dataflow tests stay on SQLite)
- Mark ROADMAP 3.13 InMemoryRepository migration item complete

Impact: 10 functions changed, 11 affected

* fix: use instanceof SqliteRepository guard and validate openRepo opts

Impact: 2 functions changed, 18 affected

* docs: add Phase 4 (Native Analysis Acceleration) to roadmap

Add new Phase 4 covering the port of JS-only build phases to Rust:
- 4.1-4.3: AST nodes, CFG, dataflow visitor ports (~587ms savings)
- 4.4: Batch SQLite inserts (~143ms)
- 4.5: Role classification & structure (~42ms)
- 4.6: Complete complexity pre-computation
- 4.7: Fix incremental rebuild data loss on native engine
- 4.8: Incremental rebuild performance (target sub-100ms)

Bump old Phases 4-10 to 5-11 with all cross-references updated.
Benchmark evidence shows ~50% of native build time is spent in
JS visitors that run identically on both engines.

Author: carlos-alm

docs/roadmap/ROADMAP.md

@@ -3,6 +3,8 @@ import path from 'node:path';
 import Database from 'better-sqlite3';
 import { warn } from '../infrastructure/logger.js';
 import { DbError } from '../shared/errors.js';
+import { Repository } from './repository/base.js';
+import { SqliteRepository } from './repository/sqlite-repository.js';
 
 function isProcessAlive(pid) {
   try {
@@ -86,3 +88,32 @@ export function openReadonlyOrFail(customPath) {
   }
   return new Database(dbPath, { readonly: true });
 }
+
+/**
+ * Open a Repository from either an injected instance or a DB path.
+ *
+ * When `opts.repo` is a Repository instance, returns it directly (no DB opened).
+ * Otherwise opens a readonly SQLite DB and wraps it in SqliteRepository.
+ *
+ * @param {string} [customDbPath] - Path to graph.db (ignored when opts.repo is set)
+ * @param {object} [opts]
+ * @param {Repository} [opts.repo] - Pre-built Repository to use instead of SQLite
+ * @returns {{ repo: Repository, close(): void }}
+ */
+export function openRepo(customDbPath, opts = {}) {
+  if (opts.repo != null) {
+    if (!(opts.repo instanceof Repository)) {
+      throw new TypeError(
+        `openRepo: opts.repo must be a Repository instance, got ${Object.prototype.toString.call(opts.repo)}`,
+      );
+    }
+    return { repo: opts.repo, close() {} };
+  }
+  const db = openReadonlyOrFail(customDbPath);
+  return {
+    repo: new SqliteRepository(db),
+    close() {
+      db.close();
+    },
+  };
+}

src/db/connection.js

@@ -1,5 +1,5 @@
 // Barrel re-export — keeps all existing `import { ... } from '…/db/index.js'` working.
-export { closeDb, findDbPath, openDb, openReadonlyOrFail } from './connection.js';
+export { closeDb, findDbPath, openDb, openReadonlyOrFail, openRepo } from './connection.js';
 export { getBuildMeta, initSchema, MIGRATIONS, setBuildMeta } from './migrations.js';
 export {
   fanInJoinSQL,

src/db/index.js

@@ -12,6 +12,7 @@ import {
   findNodesWithFanIn,
   listFunctionNodes,
   openReadonlyOrFail,
+  Repository,
 } from '../../db/index.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import { ALL_SYMBOL_KINDS } from '../../shared/kinds.js';
@@ -23,11 +24,16 @@ const FUNCTION_KINDS = ['function', 'method', 'class'];
 /**
  * Find nodes matching a name query, ranked by relevance.
  * Scoring: exact=100, prefix=60, word-boundary=40, substring=10, plus fan-in tiebreaker.
+ *
+ * @param {object} dbOrRepo - A better-sqlite3 Database or a Repository instance
  */
-export function findMatchingNodes(db, name, opts = {}) {
+export function findMatchingNodes(dbOrRepo, name, opts = {}) {
   const kinds = opts.kind ? [opts.kind] : opts.kinds?.length ? opts.kinds : FUNCTION_KINDS;
 
-  const rows = findNodesWithFanIn(db, `%${name}%`, { kinds, file: opts.file });
+  const isRepo = dbOrRepo instanceof Repository;
+  const rows = isRepo
+    ? dbOrRepo.findNodesWithFanIn(`%${name}%`, { kinds, file: opts.file })
+    : findNodesWithFanIn(dbOrRepo, `%${name}%`, { kinds, file: opts.file });
 
   const nodes = opts.noTests ? rows.filter((n) => !isTestFile(n.file)) : rows;
 

src/domain/analysis/symbol-lookup.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { openReadonlyOrFail } from '../db/index.js';
+import { openRepo } from '../db/index.js';
 import { louvainCommunities } from '../graph/algorithms/louvain.js';
 import { buildDependencyGraph } from '../graph/builders/dependency.js';
 import { paginateResult } from '../shared/paginate.js';
@@ -26,15 +26,15 @@ function getDirectory(filePath) {
  * @returns {{ communities: object[], modularity: number, drift: object, summary: object }}
  */
 export function communitiesData(customDbPath, opts = {}) {
-  const db = openReadonlyOrFail(customDbPath);
+  const { repo, close } = openRepo(customDbPath, opts);
   let graph;
   try {
-    graph = buildDependencyGraph(db, {
+    graph = buildDependencyGraph(repo, {
       fileLevel: !opts.functions,
       noTests: opts.noTests,
     });
   } finally {
-    db.close();
+    close();
   }
 
   // Handle empty or trivial graphs

src/features/communities.js

@@ -6,7 +6,8 @@
  * sequence-diagram conventions.
  */
 
-import { findCallees, openReadonlyOrFail } from '../db/index.js';
+import { openRepo } from '../db/index.js';
+import { SqliteRepository } from '../db/repository/sqlite-repository.js';
 import { findMatchingNodes } from '../domain/queries.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
 import { paginateResult } from '../shared/paginate.js';
@@ -85,19 +86,19 @@ function buildAliases(files) {
  * @returns {{ entry, participants, messages, depth, totalMessages, truncated }}
  */
 export function sequenceData(name, dbPath, opts = {}) {
-  const db = openReadonlyOrFail(dbPath);
+  const { repo, close } = openRepo(dbPath, opts);
   try {
     const maxDepth = opts.depth || 10;
     const noTests = opts.noTests || false;
     const withDataflow = opts.dataflow || false;
 
     // Phase 1: Direct LIKE match
-    let matchNode = findMatchingNodes(db, name, opts)[0] ?? null;
+    let matchNode = findMatchingNodes(repo, name, opts)[0] ?? null;
 
     // Phase 2: Prefix-stripped matching
     if (!matchNode) {
       for (const prefix of FRAMEWORK_ENTRY_PREFIXES) {
-        matchNode = findMatchingNodes(db, `${prefix}${name}`, opts)[0] ?? null;
+        matchNode = findMatchingNodes(repo, `${prefix}${name}`, opts)[0] ?? null;
         if (matchNode) break;
       }
     }
@@ -133,7 +134,7 @@ export function sequenceData(name, dbPath, opts = {}) {
       const nextFrontier = [];
 
       for (const fid of frontier) {
-        const callees = findCallees(db, fid);
+        const callees = repo.findCallees(fid);
 
         const caller = idToNode.get(fid);
 
@@ -163,18 +164,17 @@ export function sequenceData(name, dbPath, opts = {}) {
 
       if (d === maxDepth && frontier.length > 0) {
         // Only mark truncated if at least one frontier node has further callees
-        const hasMoreCalls = frontier.some((fid) => findCallees(db, fid).length > 0);
+        const hasMoreCalls = frontier.some((fid) => repo.findCallees(fid).length > 0);
         if (hasMoreCalls) truncated = true;
       }
     }
 
     // Dataflow annotations: add return arrows
     if (withDataflow && messages.length > 0) {
-      const hasTable = db
-        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='dataflow'")
-        .get();
+      const hasTable = repo.hasDataflowTable();
 
-      if (hasTable) {
+      if (hasTable && repo instanceof SqliteRepository) {
+        const db = repo.db;
         // Build name|file lookup for O(1) target node access
         const nodeByNameFile = new Map();
         for (const n of idToNode.values()) {
@@ -281,7 +281,7 @@ export function sequenceData(name, dbPath, opts = {}) {
     }
     return result;
   } finally {
-    db.close();
+    close();
   }
 }
 

src/features/sequence.js

@@ -1,4 +1,4 @@
-import { findNodesForTriage, openReadonlyOrFail } from '../db/index.js';
+import { openRepo } from '../db/index.js';
 import { DEFAULT_WEIGHTS, scoreRisk } from '../graph/classifiers/risk.js';
 import { warn } from '../infrastructure/logger.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
@@ -14,7 +14,7 @@ import { paginateResult } from '../shared/paginate.js';
  * @returns {{ items: object[], summary: object, _pagination?: object }}
  */
 export function triageData(customDbPath, opts = {}) {
-  const db = openReadonlyOrFail(customDbPath);
+  const { repo, close } = openRepo(customDbPath, opts);
   try {
     const noTests = opts.noTests || false;
     const fileFilter = opts.file || null;
@@ -26,7 +26,7 @@ export function triageData(customDbPath, opts = {}) {
 
     let rows;
     try {
-      rows = findNodesForTriage(db, {
+      rows = repo.findNodesForTriage({
         noTests,
         file: fileFilter,
         kind: kindFilter,
@@ -115,7 +115,7 @@ export function triageData(customDbPath, opts = {}) {
       offset: opts.offset,
     });
   } finally {
-    db.close();
+    close();
   }
 }
 

src/features/triage.js

@@ -3,32 +3,39 @@
  * Replaces inline graph construction in cycles.js, communities.js, viewer.js, export.js.
  */
 
-import { getCallableNodes, getCallEdges, getFileNodesAll, getImportEdges } from '../../db/index.js';
+import {
+  getCallableNodes,
+  getCallEdges,
+  getFileNodesAll,
+  getImportEdges,
+  Repository,
+} from '../../db/index.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import { CodeGraph } from '../model.js';
 
 /**
- * @param {object} db - Open better-sqlite3 database (readonly)
+ * @param {object} dbOrRepo - Open better-sqlite3 database (readonly) or a Repository instance
  * @param {object} [opts]
  * @param {boolean} [opts.fileLevel=true] - File-level (imports) or function-level (calls)
  * @param {boolean} [opts.noTests=false] - Exclude test files
  * @param {number}  [opts.minConfidence] - Minimum edge confidence (function-level only)
  * @returns {CodeGraph}
  */
-export function buildDependencyGraph(db, opts = {}) {
+export function buildDependencyGraph(dbOrRepo, opts = {}) {
   const fileLevel = opts.fileLevel !== false;
   const noTests = opts.noTests || false;
 
   if (fileLevel) {
-    return buildFileLevelGraph(db, noTests);
+    return buildFileLevelGraph(dbOrRepo, noTests);
   }
-  return buildFunctionLevelGraph(db, noTests, opts.minConfidence);
+  return buildFunctionLevelGraph(dbOrRepo, noTests, opts.minConfidence);
 }
 
-function buildFileLevelGraph(db, noTests) {
+function buildFileLevelGraph(dbOrRepo, noTests) {
   const graph = new CodeGraph();
+  const isRepo = dbOrRepo instanceof Repository;
 
-  let nodes = getFileNodesAll(db);
+  let nodes = isRepo ? dbOrRepo.getFileNodesAll() : getFileNodesAll(dbOrRepo);
   if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
 
   const nodeIds = new Set();
@@ -37,7 +44,7 @@ function buildFileLevelGraph(db, noTests) {
     nodeIds.add(n.id);
   }
 
-  const edges = getImportEdges(db);
+  const edges = isRepo ? dbOrRepo.getImportEdges() : getImportEdges(dbOrRepo);
   for (const e of edges) {
     if (!nodeIds.has(e.source_id) || !nodeIds.has(e.target_id)) continue;
     const src = String(e.source_id);
@@ -51,10 +58,11 @@ function buildFileLevelGraph(db, noTests) {
   return graph;
 }
 
-function buildFunctionLevelGraph(db, noTests, minConfidence) {
+function buildFunctionLevelGraph(dbOrRepo, noTests, minConfidence) {
   const graph = new CodeGraph();
+  const isRepo = dbOrRepo instanceof Repository;
 
-  let nodes = getCallableNodes(db);
+  let nodes = isRepo ? dbOrRepo.getCallableNodes() : getCallableNodes(dbOrRepo);
   if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
 
   const nodeIds = new Set();
@@ -70,11 +78,16 @@ function buildFunctionLevelGraph(db, noTests, minConfidence) {
 
   let edges;
   if (minConfidence != null) {
-    edges = db
-      .prepare("SELECT source_id, target_id FROM edges WHERE kind = 'calls' AND confidence >= ?")
-      .all(minConfidence);
+    if (isRepo) {
+      // minConfidence filtering not supported by Repository — fall back to getCallEdges
+      edges = dbOrRepo.getCallEdges();
+    } else {
+      edges = dbOrRepo
+        .prepare("SELECT source_id, target_id FROM edges WHERE kind = 'calls' AND confidence >= ?")
+        .all(minConfidence);
+    }
   } else {
-    edges = getCallEdges(db);
+    edges = isRepo ? dbOrRepo.getCallEdges() : getCallEdges(dbOrRepo);
   }
 
   for (const e of edges) {