@optave/codegraph 3.1.0 → 3.1.2

package/src/db/repository/nodes.js

@@ -0,0 +1,236 @@
+import { EVERY_SYMBOL_KIND, VALID_ROLES } from '../../kinds.js';
+import { NodeQuery } from '../query-builder.js';
+
+// ─── Query-builder based lookups (moved from src/db/repository.js) ─────
+
+/**
+ * Find nodes matching a name pattern, with fan-in count.
+ * @param {object} db
+ * @param {string} namePattern - LIKE pattern (already wrapped with %)
+ * @param {object} [opts]
+ * @param {string[]} [opts.kinds]
+ * @param {string} [opts.file]
+ * @returns {object[]}
+ */
+export function findNodesWithFanIn(db, namePattern, opts = {}) {
+  const q = new NodeQuery()
+    .select('n.*, COALESCE(fi.cnt, 0) AS fan_in')
+    .withFanIn()
+    .where('n.name LIKE ?', namePattern);
+
+  if (opts.kinds) {
+    q.kinds(opts.kinds);
+  }
+  if (opts.file) {
+    q.fileFilter(opts.file);
+  }
+
+  return q.all(db);
+}
+
+/**
+ * Fetch nodes for triage scoring: fan-in + complexity + churn.
+ * @param {object} db
+ * @param {object} [opts]
+ * @returns {object[]}
+ */
+export function findNodesForTriage(db, opts = {}) {
+  if (opts.kind && !EVERY_SYMBOL_KIND.includes(opts.kind)) {
+    throw new Error(`Invalid kind: ${opts.kind} (expected one of ${EVERY_SYMBOL_KIND.join(', ')})`);
+  }
+  if (opts.role && !VALID_ROLES.includes(opts.role)) {
+    throw new Error(`Invalid role: ${opts.role} (expected one of ${VALID_ROLES.join(', ')})`);
+  }
+
+  const kindsToUse = opts.kind ? [opts.kind] : ['function', 'method', 'class'];
+  const q = new NodeQuery()
+    .select(
+      `n.id, n.name, n.kind, n.file, n.line, n.end_line, n.role,
+              COALESCE(fi.cnt, 0) AS fan_in,
+              COALESCE(fc.cognitive, 0) AS cognitive,
+              COALESCE(fc.maintainability_index, 0) AS mi,
+              COALESCE(fc.cyclomatic, 0) AS cyclomatic,
+              COALESCE(fc.max_nesting, 0) AS max_nesting,
+              COALESCE(fcc.commit_count, 0) AS churn`,
+    )
+    .kinds(kindsToUse)
+    .withFanIn()
+    .withComplexity()
+    .withChurn()
+    .excludeTests(opts.noTests)
+    .fileFilter(opts.file)
+    .roleFilter(opts.role)
+    .orderBy('n.file, n.line');
+
+  return q.all(db);
+}
+
+/**
+ * Shared query builder for function/method/class node listing.
+ * @param {object} [opts]
+ * @returns {NodeQuery}
+ */
+function _functionNodeQuery(opts = {}) {
+  return new NodeQuery()
+    .select('name, kind, file, line, end_line, role')
+    .kinds(['function', 'method', 'class'])
+    .fileFilter(opts.file)
+    .nameLike(opts.pattern)
+    .excludeTests(opts.noTests)
+    .orderBy('file, line');
+}
+
+/**
+ * List function/method/class nodes with basic info.
+ * @param {object} db
+ * @param {object} [opts]
+ * @returns {object[]}
+ */
+export function listFunctionNodes(db, opts = {}) {
+  return _functionNodeQuery(opts).all(db);
+}
+
+/**
+ * Iterator version of listFunctionNodes for memory efficiency.
+ * @param {object} db
+ * @param {object} [opts]
+ * @returns {IterableIterator}
+ */
+export function iterateFunctionNodes(db, opts = {}) {
+  return _functionNodeQuery(opts).iterate(db);
+}
+
+/**
+ * Count total nodes.
+ * @param {object} db
+ * @returns {number}
+ */
+export function countNodes(db) {
+  return db.prepare('SELECT COUNT(*) AS cnt FROM nodes').get().cnt;
+}
+
+/**
+ * Count total edges.
+ * @param {object} db
+ * @returns {number}
+ */
+export function countEdges(db) {
+  return db.prepare('SELECT COUNT(*) AS cnt FROM edges').get().cnt;
+}
+
+/**
+ * Count distinct files.
+ * @param {object} db
+ * @returns {number}
+ */
+export function countFiles(db) {
+  return db.prepare('SELECT COUNT(DISTINCT file) AS cnt FROM nodes').get().cnt;
+}
+
+// ─── Shared node lookups ───────────────────────────────────────────────
+
+/**
+ * Find a single node by ID.
+ * @param {object} db
+ * @param {number} id
+ * @returns {object|undefined}
+ */
+export function findNodeById(db, id) {
+  return db.prepare('SELECT * FROM nodes WHERE id = ?').get(id);
+}
+
+/**
+ * Find non-file nodes for a given file path (exact match), ordered by line.
+ * @param {object} db
+ * @param {string} file - Exact file path
+ * @returns {object[]}
+ */
+export function findNodesByFile(db, file) {
+  return db
+    .prepare("SELECT * FROM nodes WHERE file = ? AND kind != 'file' ORDER BY line")
+    .all(file);
+}
+
+/**
+ * Find file-kind nodes matching a LIKE pattern.
+ * @param {object} db
+ * @param {string} fileLike - LIKE pattern (caller wraps with %)
+ * @returns {object[]}
+ */
+export function findFileNodes(db, fileLike) {
+  return db.prepare("SELECT * FROM nodes WHERE file LIKE ? AND kind = 'file'").all(fileLike);
+}
+
+// ─── Statement caches (one prepared statement per db instance) ────────────
+// WeakMap keys on the db object so statements are GC'd when the db closes.
+const _getNodeIdStmt = new WeakMap();
+const _getFunctionNodeIdStmt = new WeakMap();
+const _bulkNodeIdsByFileStmt = new WeakMap();
+
+/**
+ * Look up a node's ID by its unique (name, kind, file, line) tuple.
+ * Shared by builder, watcher, structure, complexity, cfg, engine.
+ * @param {object} db
+ * @param {string} name
+ * @param {string} kind
+ * @param {string} file
+ * @param {number} line
+ * @returns {number|undefined}
+ */
+export function getNodeId(db, name, kind, file, line) {
+  let stmt = _getNodeIdStmt.get(db);
+  if (!stmt) {
+    stmt = db.prepare('SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ? AND line = ?');
+    _getNodeIdStmt.set(db, stmt);
+  }
+  return stmt.get(name, kind, file, line)?.id;
+}
+
+/**
+ * Look up a function/method node's ID (kind-restricted variant of getNodeId).
+ * Used by complexity.js, cfg.js where only function/method kinds are expected.
+ * @param {object} db
+ * @param {string} name
+ * @param {string} file
+ * @param {number} line
+ * @returns {number|undefined}
+ */
+export function getFunctionNodeId(db, name, file, line) {
+  let stmt = _getFunctionNodeIdStmt.get(db);
+  if (!stmt) {
+    stmt = db.prepare(
+      "SELECT id FROM nodes WHERE name = ? AND kind IN ('function','method') AND file = ? AND line = ?",
+    );
+    _getFunctionNodeIdStmt.set(db, stmt);
+  }
+  return stmt.get(name, file, line)?.id;
+}
+
+/**
+ * Bulk-fetch all node IDs for a file in one query.
+ * Returns rows suitable for building a `name|kind|line -> id` lookup map.
+ * Shared by builder, ast.js, ast-analysis/engine.js.
+ * @param {object} db
+ * @param {string} file
+ * @returns {{ id: number, name: string, kind: string, line: number }[]}
+ */
+export function bulkNodeIdsByFile(db, file) {
+  let stmt = _bulkNodeIdsByFileStmt.get(db);
+  if (!stmt) {
+    stmt = db.prepare('SELECT id, name, kind, line FROM nodes WHERE file = ?');
+    _bulkNodeIdsByFileStmt.set(db, stmt);
+  }
+  return stmt.all(file);
+}
+
+/**
+ * Find child nodes (parameters, properties, constants) of a parent.
+ * @param {object} db
+ * @param {number} parentId
+ * @returns {{ name: string, kind: string, line: number, end_line: number|null }[]}
+ */
+export function findNodeChildren(db, parentId) {
+  return db
+    .prepare('SELECT name, kind, line, end_line FROM nodes WHERE parent_id = ? ORDER BY line')
+    .all(parentId);
+}

package/src/db.js

@@ -1,399 +1,58 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import Database from 'better-sqlite3';
-import { debug, warn } from './logger.js';
-
-// ─── Schema Migrations ─────────────────────────────────────────────────
-export const MIGRATIONS = [
-  {
-    version: 1,
-    up: `
-      CREATE TABLE IF NOT EXISTS nodes (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        name TEXT NOT NULL,
-        kind TEXT NOT NULL,
-        file TEXT NOT NULL,
-        line INTEGER,
-        end_line INTEGER,
-        UNIQUE(name, kind, file, line)
-      );
-      CREATE TABLE IF NOT EXISTS edges (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        source_id INTEGER NOT NULL,
-        target_id INTEGER NOT NULL,
-        kind TEXT NOT NULL,
-        confidence REAL DEFAULT 1.0,
-        dynamic INTEGER DEFAULT 0,
-        FOREIGN KEY(source_id) REFERENCES nodes(id),
-        FOREIGN KEY(target_id) REFERENCES nodes(id)
-      );
-      CREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes(name);
-      CREATE INDEX IF NOT EXISTS idx_nodes_file ON nodes(file);
-      CREATE INDEX IF NOT EXISTS idx_nodes_kind ON nodes(kind);
-      CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id);
-      CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id);
-      CREATE INDEX IF NOT EXISTS idx_edges_kind ON edges(kind);
-      CREATE TABLE IF NOT EXISTS node_metrics (
-        node_id INTEGER PRIMARY KEY,
-        line_count INTEGER,
-        symbol_count INTEGER,
-        import_count INTEGER,
-        export_count INTEGER,
-        fan_in INTEGER,
-        fan_out INTEGER,
-        cohesion REAL,
-        file_count INTEGER,
-        FOREIGN KEY(node_id) REFERENCES nodes(id)
-      );
-      CREATE INDEX IF NOT EXISTS idx_node_metrics_node ON node_metrics(node_id);
-    `,
-  },
-  {
-    version: 2,
-    up: `
-      CREATE INDEX IF NOT EXISTS idx_nodes_name_kind_file ON nodes(name, kind, file);
-      CREATE INDEX IF NOT EXISTS idx_nodes_file_kind ON nodes(file, kind);
-      CREATE INDEX IF NOT EXISTS idx_edges_source_kind ON edges(source_id, kind);
-      CREATE INDEX IF NOT EXISTS idx_edges_target_kind ON edges(target_id, kind);
-    `,
-  },
-  {
-    version: 3,
-    up: `
-      CREATE TABLE IF NOT EXISTS file_hashes (
-        file TEXT PRIMARY KEY,
-        hash TEXT NOT NULL,
-        mtime INTEGER NOT NULL
-      );
-    `,
-  },
-  {
-    version: 4,
-    up: `ALTER TABLE file_hashes ADD COLUMN size INTEGER DEFAULT 0;`,
-  },
-  {
-    version: 5,
-    up: `
-      CREATE TABLE IF NOT EXISTS co_changes (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        file_a TEXT NOT NULL,
-        file_b TEXT NOT NULL,
-        commit_count INTEGER NOT NULL,
-        jaccard REAL NOT NULL,
-        last_commit_epoch INTEGER,
-        UNIQUE(file_a, file_b)
-      );
-      CREATE INDEX IF NOT EXISTS idx_co_changes_file_a ON co_changes(file_a);
-      CREATE INDEX IF NOT EXISTS idx_co_changes_file_b ON co_changes(file_b);
-      CREATE INDEX IF NOT EXISTS idx_co_changes_jaccard ON co_changes(jaccard DESC);
-      CREATE TABLE IF NOT EXISTS co_change_meta (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      );
-    `,
-  },
-  {
-    version: 6,
-    up: `
-      CREATE TABLE IF NOT EXISTS file_commit_counts (
-        file TEXT PRIMARY KEY,
-        commit_count INTEGER NOT NULL DEFAULT 0
-      );
-    `,
-  },
-  {
-    version: 7,
-    up: `
-      CREATE TABLE IF NOT EXISTS build_meta (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      );
-    `,
-  },
-  {
-    version: 8,
-    up: `
-      CREATE TABLE IF NOT EXISTS function_complexity (
-        node_id INTEGER PRIMARY KEY,
-        cognitive INTEGER NOT NULL,
-        cyclomatic INTEGER NOT NULL,
-        max_nesting INTEGER NOT NULL,
-        FOREIGN KEY(node_id) REFERENCES nodes(id)
-      );
-      CREATE INDEX IF NOT EXISTS idx_fc_cognitive ON function_complexity(cognitive DESC);
-      CREATE INDEX IF NOT EXISTS idx_fc_cyclomatic ON function_complexity(cyclomatic DESC);
-    `,
-  },
-  {
-    version: 9,
-    up: `
-      ALTER TABLE function_complexity ADD COLUMN loc INTEGER DEFAULT 0;
-      ALTER TABLE function_complexity ADD COLUMN sloc INTEGER DEFAULT 0;
-      ALTER TABLE function_complexity ADD COLUMN comment_lines INTEGER DEFAULT 0;
-      ALTER TABLE function_complexity ADD COLUMN halstead_n1 INTEGER DEFAULT 0;
-      ALTER TABLE function_complexity ADD COLUMN halstead_n2 INTEGER DEFAULT 0;
-      ALTER TABLE function_complexity ADD COLUMN halstead_big_n1 INTEGER DEFAULT 0;
-      ALTER TABLE function_complexity ADD COLUMN halstead_big_n2 INTEGER DEFAULT 0;
-      ALTER TABLE function_complexity ADD COLUMN halstead_vocabulary INTEGER DEFAULT 0;
-      ALTER TABLE function_complexity ADD COLUMN halstead_length INTEGER DEFAULT 0;
-      ALTER TABLE function_complexity ADD COLUMN halstead_volume REAL DEFAULT 0;
-      ALTER TABLE function_complexity ADD COLUMN halstead_difficulty REAL DEFAULT 0;
-      ALTER TABLE function_complexity ADD COLUMN halstead_effort REAL DEFAULT 0;
-      ALTER TABLE function_complexity ADD COLUMN halstead_bugs REAL DEFAULT 0;
-      ALTER TABLE function_complexity ADD COLUMN maintainability_index REAL DEFAULT 0;
-      CREATE INDEX IF NOT EXISTS idx_fc_mi ON function_complexity(maintainability_index ASC);
-    `,
-  },
-  {
-    version: 10,
-    up: `
-      CREATE TABLE IF NOT EXISTS dataflow (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        source_id INTEGER NOT NULL,
-        target_id INTEGER NOT NULL,
-        kind TEXT NOT NULL,
-        param_index INTEGER,
-        expression TEXT,
-        line INTEGER,
-        confidence REAL DEFAULT 1.0,
-        FOREIGN KEY(source_id) REFERENCES nodes(id),
-        FOREIGN KEY(target_id) REFERENCES nodes(id)
-      );
-      CREATE INDEX IF NOT EXISTS idx_dataflow_source ON dataflow(source_id);
-      CREATE INDEX IF NOT EXISTS idx_dataflow_target ON dataflow(target_id);
-      CREATE INDEX IF NOT EXISTS idx_dataflow_kind ON dataflow(kind);
-      CREATE INDEX IF NOT EXISTS idx_dataflow_source_kind ON dataflow(source_id, kind);
-    `,
-  },
-  {
-    version: 11,
-    up: `
-      ALTER TABLE nodes ADD COLUMN parent_id INTEGER REFERENCES nodes(id);
-      CREATE INDEX IF NOT EXISTS idx_nodes_parent ON nodes(parent_id);
-      CREATE INDEX IF NOT EXISTS idx_nodes_kind_parent ON nodes(kind, parent_id);
-    `,
-  },
-  {
-    version: 12,
-    up: `
-      CREATE TABLE IF NOT EXISTS cfg_blocks (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        function_node_id INTEGER NOT NULL,
-        block_index INTEGER NOT NULL,
-        block_type TEXT NOT NULL,
-        start_line INTEGER,
-        end_line INTEGER,
-        label TEXT,
-        FOREIGN KEY(function_node_id) REFERENCES nodes(id),
-        UNIQUE(function_node_id, block_index)
-      );
-      CREATE INDEX IF NOT EXISTS idx_cfg_blocks_fn ON cfg_blocks(function_node_id);
-
-      CREATE TABLE IF NOT EXISTS cfg_edges (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        function_node_id INTEGER NOT NULL,
-        source_block_id INTEGER NOT NULL,
-        target_block_id INTEGER NOT NULL,
-        kind TEXT NOT NULL,
-        FOREIGN KEY(function_node_id) REFERENCES nodes(id),
-        FOREIGN KEY(source_block_id) REFERENCES cfg_blocks(id),
-        FOREIGN KEY(target_block_id) REFERENCES cfg_blocks(id)
-      );
-      CREATE INDEX IF NOT EXISTS idx_cfg_edges_fn ON cfg_edges(function_node_id);
-      CREATE INDEX IF NOT EXISTS idx_cfg_edges_src ON cfg_edges(source_block_id);
-      CREATE INDEX IF NOT EXISTS idx_cfg_edges_tgt ON cfg_edges(target_block_id);
-    `,
-  },
-  {
-    version: 13,
-    up: `
-      CREATE TABLE IF NOT EXISTS ast_nodes (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        file TEXT NOT NULL,
-        line INTEGER NOT NULL,
-        kind TEXT NOT NULL,
-        name TEXT NOT NULL,
-        text TEXT,
-        receiver TEXT,
-        parent_node_id INTEGER,
-        FOREIGN KEY(parent_node_id) REFERENCES nodes(id)
-      );
-      CREATE INDEX IF NOT EXISTS idx_ast_kind ON ast_nodes(kind);
-      CREATE INDEX IF NOT EXISTS idx_ast_name ON ast_nodes(name);
-      CREATE INDEX IF NOT EXISTS idx_ast_file ON ast_nodes(file);
-      CREATE INDEX IF NOT EXISTS idx_ast_parent ON ast_nodes(parent_node_id);
-      CREATE INDEX IF NOT EXISTS idx_ast_kind_name ON ast_nodes(kind, name);
-    `,
-  },
-  {
-    version: 14,
-    up: `
-      ALTER TABLE nodes ADD COLUMN exported INTEGER DEFAULT 0;
-      CREATE INDEX IF NOT EXISTS idx_nodes_exported ON nodes(exported);
-    `,
-  },
-];
-
-export function getBuildMeta(db, key) {
-  try {
-    const row = db.prepare('SELECT value FROM build_meta WHERE key = ?').get(key);
-    return row ? row.value : null;
-  } catch {
-    return null;
-  }
-}
-
-export function setBuildMeta(db, entries) {
-  const upsert = db.prepare('INSERT OR REPLACE INTO build_meta (key, value) VALUES (?, ?)');
-  const tx = db.transaction(() => {
-    for (const [key, value] of Object.entries(entries)) {
-      upsert.run(key, String(value));
-    }
-  });
-  tx();
-}
-
-export function openDb(dbPath) {
-  const dir = path.dirname(dbPath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  acquireAdvisoryLock(dbPath);
-  const db = new Database(dbPath);
-  db.pragma('journal_mode = WAL');
-  db.pragma('busy_timeout = 5000');
-  db.__lockPath = `${dbPath}.lock`;
-  return db;
-}
-
-export function closeDb(db) {
-  db.close();
-  if (db.__lockPath) releaseAdvisoryLock(db.__lockPath);
-}
-
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function acquireAdvisoryLock(dbPath) {
-  const lockPath = `${dbPath}.lock`;
-  try {
-    if (fs.existsSync(lockPath)) {
-      const content = fs.readFileSync(lockPath, 'utf-8').trim();
-      const pid = Number(content);
-      if (pid && pid !== process.pid && isProcessAlive(pid)) {
-        warn(`Another process (PID ${pid}) may be using this database. Proceeding with caution.`);
-      }
-    }
-  } catch {
-    /* ignore read errors */
-  }
-  try {
-    fs.writeFileSync(lockPath, String(process.pid), 'utf-8');
-  } catch {
-    /* best-effort */
-  }
-}
-
-function releaseAdvisoryLock(lockPath) {
-  try {
-    const content = fs.readFileSync(lockPath, 'utf-8').trim();
-    if (Number(content) === process.pid) {
-      fs.unlinkSync(lockPath);
-    }
-  } catch {
-    /* ignore */
-  }
-}
-
-export function initSchema(db) {
-  db.exec(`CREATE TABLE IF NOT EXISTS schema_version (version INTEGER NOT NULL DEFAULT 0)`);
-
-  const row = db.prepare('SELECT version FROM schema_version').get();
-  let currentVersion = row ? row.version : 0;
-
-  if (!row) {
-    db.prepare('INSERT INTO schema_version (version) VALUES (0)').run();
-  }
-
-  for (const migration of MIGRATIONS) {
-    if (migration.version > currentVersion) {
-      debug(`Running migration v${migration.version}`);
-      db.exec(migration.up);
-      db.prepare('UPDATE schema_version SET version = ?').run(migration.version);
-      currentVersion = migration.version;
-    }
-  }
-
-  try {
-    db.exec('ALTER TABLE nodes ADD COLUMN end_line INTEGER');
-  } catch {
-    /* already exists */
-  }
-  try {
-    db.exec('ALTER TABLE edges ADD COLUMN confidence REAL DEFAULT 1.0');
-  } catch {
-    /* already exists */
-  }
-  try {
-    db.exec('ALTER TABLE edges ADD COLUMN dynamic INTEGER DEFAULT 0');
-  } catch {
-    /* already exists */
-  }
-  try {
-    db.exec('ALTER TABLE nodes ADD COLUMN role TEXT');
-  } catch {
-    /* already exists */
-  }
-  try {
-    db.exec('CREATE INDEX IF NOT EXISTS idx_nodes_role ON nodes(role)');
-  } catch {
-    /* already exists */
-  }
-  try {
-    db.exec('ALTER TABLE nodes ADD COLUMN parent_id INTEGER REFERENCES nodes(id)');
-  } catch {
-    /* already exists */
-  }
-  try {
-    db.exec('CREATE INDEX IF NOT EXISTS idx_nodes_parent ON nodes(parent_id)');
-  } catch {
-    /* already exists */
-  }
-  try {
-    db.exec('CREATE INDEX IF NOT EXISTS idx_nodes_kind_parent ON nodes(kind, parent_id)');
-  } catch {
-    /* already exists */
-  }
-}
-
-export function findDbPath(customPath) {
-  if (customPath) return path.resolve(customPath);
-  let dir = process.cwd();
-  while (true) {
-    const candidate = path.join(dir, '.codegraph', 'graph.db');
-    if (fs.existsSync(candidate)) return candidate;
-    const parent = path.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return path.join(process.cwd(), '.codegraph', 'graph.db');
-}
-
-/**
- * Open a database in readonly mode, with a user-friendly error if the DB doesn't exist.
- */
-export function openReadonlyOrFail(customPath) {
-  const dbPath = findDbPath(customPath);
-  if (!fs.existsSync(dbPath)) {
-    console.error(
-      `No codegraph database found at ${dbPath}.\n` +
-        `Run "codegraph build" first to analyze your codebase.`,
-    );
-    process.exit(1);
-  }
-  return new Database(dbPath, { readonly: true });
-}
+// Barrel re-export — keeps all existing `import { ... } from './db.js'` working.
+export { closeDb, findDbPath, openDb, openReadonlyOrFail } from './db/connection.js';
+export { getBuildMeta, initSchema, MIGRATIONS, setBuildMeta } from './db/migrations.js';
+export {
+  fanInJoinSQL,
+  fanOutJoinSQL,
+  kindInClause,
+  NodeQuery,
+  testFilterSQL,
+} from './db/query-builder.js';
+export {
+  bulkNodeIdsByFile,
+  countCrossFileCallers,
+  countEdges,
+  countFiles,
+  countNodes,
+  deleteCfgForNode,
+  findAllIncomingEdges,
+  findAllOutgoingEdges,
+  findCalleeNames,
+  findCallees,
+  findCallerNames,
+  findCallers,
+  findCrossFileCallTargets,
+  findDistinctCallers,
+  findFileNodes,
+  findImportDependents,
+  findImportSources,
+  findImportTargets,
+  findIntraFileCallEdges,
+  findNodeById,
+  findNodeChildren,
+  findNodesByFile,
+  findNodesForTriage,
+  findNodesWithFanIn,
+  getCallableNodes,
+  getCallEdges,
+  getCfgBlocks,
+  getCfgEdges,
+  getClassHierarchy,
+  getCoChangeMeta,
+  getComplexityForNode,
+  getEmbeddingCount,
+  getEmbeddingMeta,
+  getFileNodesAll,
+  getFunctionNodeId,
+  getImportEdges,
+  getNodeId,
+  hasCfgTables,
+  hasCoChanges,
+  hasDataflowTable,
+  hasEmbeddings,
+  iterateFunctionNodes,
+  listFunctionNodes,
+  purgeFileData,
+  purgeFilesData,
+  upsertCoChangeMeta,
+} from './db/repository/index.js';