optave-codegraph 3.13.0

package/src/db/repository/nodes.ts

@@ -0,0 +1,322 @@
+import { ConfigError } from '../../shared/errors.js';
+import { EVERY_SYMBOL_KIND, VALID_ROLES } from '../../shared/kinds.js';
+import type {
+  BetterSqlite3Database,
+  ChildNodeRow,
+  ListFunctionOpts,
+  NativeDatabase,
+  NodeIdRow,
+  NodeRow,
+  NodeRowWithFanIn,
+  QueryOpts,
+  StmtCache,
+  TriageNodeRow,
+  TriageQueryOpts,
+} from '../../types.js';
+import { buildFileConditionSQL, NodeQuery } from '../query-builder.js';
+import { cachedStmt } from './cached-stmt.js';
+
+// ─── Query-builder based lookups (moved from src/db/repository.js) ─────
+
+/**
+ * Find nodes matching a name pattern, with fan-in count.
+ */
+export function findNodesWithFanIn(
+  db: BetterSqlite3Database,
+  namePattern: string,
+  opts: QueryOpts = {},
+  nativeDb?: NativeDatabase,
+): NodeRowWithFanIn[] {
+  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, nativeDb);
+}
+
+/** Validate kind and role options, throwing on invalid values. */
+function validateTriageOpts(opts: TriageQueryOpts): void {
+  if (opts.kind && !(EVERY_SYMBOL_KIND as readonly string[]).includes(opts.kind)) {
+    throw new ConfigError(
+      `Invalid kind: ${opts.kind} (expected one of ${EVERY_SYMBOL_KIND.join(', ')})`,
+    );
+  }
+  if (opts.role && !VALID_ROLES.includes(opts.role)) {
+    throw new ConfigError(`Invalid role: ${opts.role} (expected one of ${VALID_ROLES.join(', ')})`);
+  }
+}
+
+/**
+ * Fetch nodes for triage scoring: fan-in + complexity + churn.
+ */
+export function findNodesForTriage(
+  db: BetterSqlite3Database,
+  opts: TriageQueryOpts = {},
+  nativeDb?: NativeDatabase,
+): TriageNodeRow[] {
+  validateTriageOpts(opts);
+
+  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.parent_id, n.exported, n.qualified_name, n.scope, n.visibility, 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, nativeDb);
+}
+
+/**
+ * Shared query builder for function/method/class node listing.
+ */
+function _functionNodeQuery(opts: ListFunctionOpts = {}): InstanceType<typeof NodeQuery> {
+  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.
+ */
+export function listFunctionNodes(
+  db: BetterSqlite3Database,
+  opts: ListFunctionOpts = {},
+  nativeDb?: NativeDatabase,
+): NodeRow[] {
+  return _functionNodeQuery(opts).all(db, nativeDb);
+}
+
+/**
+ * Iterator version of listFunctionNodes for memory efficiency.
+ */
+export function iterateFunctionNodes(
+  db: BetterSqlite3Database,
+  opts: ListFunctionOpts = {},
+): IterableIterator<NodeRow> {
+  return _functionNodeQuery(opts).iterate(db);
+}
+
+// ─── Statement caches (one prepared statement per db instance) ────────────
+// WeakMap keys on the db object so statements are GC'd when the db closes.
+const _countNodesStmt: StmtCache<{ cnt: number }> = new WeakMap();
+const _countEdgesStmt: StmtCache<{ cnt: number }> = new WeakMap();
+const _countFilesStmt: StmtCache<{ cnt: number }> = new WeakMap();
+const _findNodeByIdStmt: StmtCache<NodeRow> = new WeakMap();
+const _findNodesByFileStmt: StmtCache<NodeRow> = new WeakMap();
+const _findFileNodesStmt: StmtCache<NodeRow> = new WeakMap();
+const _getNodeIdStmt: StmtCache<{ id: number }> = new WeakMap();
+const _getFunctionNodeIdStmt: StmtCache<{ id: number }> = new WeakMap();
+const _bulkNodeIdsByFileStmt: StmtCache<NodeIdRow> = new WeakMap();
+const _findNodeChildrenStmt: StmtCache<ChildNodeRow> = new WeakMap();
+const _findNodeByQualifiedNameStmt: StmtCache<NodeRow> = new WeakMap();
+
+/**
+ * Count total nodes.
+ */
+export function countNodes(db: BetterSqlite3Database): number {
+  return cachedStmt(_countNodesStmt, db, 'SELECT COUNT(*) AS cnt FROM nodes').get()?.cnt ?? 0;
+}
+
+/**
+ * Count total edges.
+ */
+export function countEdges(db: BetterSqlite3Database): number {
+  return cachedStmt(_countEdgesStmt, db, 'SELECT COUNT(*) AS cnt FROM edges').get()?.cnt ?? 0;
+}
+
+/**
+ * Count distinct files.
+ */
+export function countFiles(db: BetterSqlite3Database): number {
+  return (
+    cachedStmt(_countFilesStmt, db, 'SELECT COUNT(DISTINCT file) AS cnt FROM nodes').get()?.cnt ?? 0
+  );
+}
+
+// ─── Shared node lookups ───────────────────────────────────────────────
+
+/**
+ * Find a single node by ID.
+ */
+export function findNodeById(db: BetterSqlite3Database, id: number): NodeRow | undefined {
+  return cachedStmt(_findNodeByIdStmt, db, 'SELECT * FROM nodes WHERE id = ?').get(id);
+}
+
+/**
+ * Find non-file nodes for a given file path (exact match), ordered by line.
+ */
+export function findNodesByFile(db: BetterSqlite3Database, file: string): NodeRow[] {
+  return cachedStmt(
+    _findNodesByFileStmt,
+    db,
+    "SELECT * FROM nodes WHERE file = ? AND kind != 'file' ORDER BY line",
+  ).all(file);
+}
+
+/**
+ * Find file-kind nodes matching a LIKE pattern.
+ */
+export function findFileNodes(db: BetterSqlite3Database, fileLike: string): NodeRow[] {
+  return cachedStmt(
+    _findFileNodesStmt,
+    db,
+    "SELECT * FROM nodes WHERE file LIKE ? AND kind = 'file'",
+  ).all(fileLike);
+}
+
+/**
+ * Look up a node's ID by its unique (name, kind, file, line) tuple.
+ */
+export function getNodeId(
+  db: BetterSqlite3Database,
+  name: string,
+  kind: string,
+  file: string,
+  line: number,
+): number | undefined {
+  return cachedStmt(
+    _getNodeIdStmt,
+    db,
+    'SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ? AND line = ?',
+  ).get(name, kind, file, line)?.id;
+}
+
+/**
+ * Look up a function/method node's ID (kind-restricted variant of getNodeId).
+ */
+export function getFunctionNodeId(
+  db: BetterSqlite3Database,
+  name: string,
+  file: string,
+  line: number,
+): number | undefined {
+  return cachedStmt(
+    _getFunctionNodeIdStmt,
+    db,
+    "SELECT id FROM nodes WHERE name = ? AND kind IN ('function','method') AND file = ? AND line = ?",
+  ).get(name, file, line)?.id;
+}
+
+/**
+ * Bulk-fetch all node IDs for a file in one query.
+ */
+export function bulkNodeIdsByFile(db: BetterSqlite3Database, file: string): NodeIdRow[] {
+  return cachedStmt(
+    _bulkNodeIdsByFileStmt,
+    db,
+    'SELECT id, name, kind, line FROM nodes WHERE file = ?',
+  ).all(file);
+}
+
+/**
+ * Find child nodes (parameters, properties, constants) of a parent.
+ */
+export function findNodeChildren(db: BetterSqlite3Database, parentId: number): ChildNodeRow[] {
+  return cachedStmt(
+    _findNodeChildrenStmt,
+    db,
+    'SELECT name, kind, line, end_line, qualified_name, scope, visibility FROM nodes WHERE parent_id = ? ORDER BY line',
+  ).all(parentId);
+}
+
+/**
+ * Find all nodes that belong to a given scope (by scope column).
+ */
+export function findNodesByScope(
+  db: BetterSqlite3Database,
+  scopeName: string,
+  opts: QueryOpts = {},
+): NodeRow[] {
+  let sql = 'SELECT * FROM nodes WHERE scope = ?';
+  const params: unknown[] = [scopeName];
+  if (opts.kind) {
+    sql += ' AND kind = ?';
+    params.push(opts.kind);
+  }
+  const fc = buildFileConditionSQL(opts.file ?? '', 'file');
+  sql += fc.sql;
+  params.push(...fc.params);
+  sql += ' ORDER BY file, line';
+  return db.prepare<NodeRow>(sql).all(...params);
+}
+
+/**
+ * Find nodes by qualified name.
+ */
+export function findNodeByQualifiedName(
+  db: BetterSqlite3Database,
+  qualifiedName: string,
+  opts: { file?: string } = {},
+): NodeRow[] {
+  const fc = buildFileConditionSQL(opts.file ?? '', 'file');
+  if (fc.sql) {
+    return db
+      .prepare<NodeRow>(`SELECT * FROM nodes WHERE qualified_name = ?${fc.sql} ORDER BY file, line`)
+      .all(qualifiedName, ...fc.params);
+  }
+  return cachedStmt(
+    _findNodeByQualifiedNameStmt,
+    db,
+    'SELECT * FROM nodes WHERE qualified_name = ? ORDER BY file, line',
+  ).all(qualifiedName);
+}
+
+// ─── Metric helpers ──────────────────────────────────────────────────────
+
+const _getLineCountForNodeStmt: StmtCache<{ line_count: number }> = new WeakMap();
+
+/**
+ * Get line_count from node_metrics for a given node.
+ * @param {object} db
+ * @param {number} nodeId
+ * @returns {{ line_count: number } | undefined}
+ */
+export function getLineCountForNode(db: BetterSqlite3Database, nodeId: number) {
+  return cachedStmt(
+    _getLineCountForNodeStmt,
+    db,
+    'SELECT line_count FROM node_metrics WHERE node_id = ?',
+  ).get(nodeId);
+}
+
+const _getMaxEndLineForFileStmt: StmtCache<{ max_end: number | null }> = new WeakMap();
+
+/**
+ * Get the maximum end_line across all nodes in a file.
+ * @param {object} db
+ * @param {string} file
+ * @returns {{ max_end: number | null } | undefined}
+ */
+export function getMaxEndLineForFile(db: BetterSqlite3Database, file: string) {
+  return cachedStmt(
+    _getMaxEndLineForFileStmt,
+    db,
+    'SELECT MAX(end_line) as max_end FROM nodes WHERE file = ?',
+  ).get(file);
+}

package/src/db/repository/sqlite-repository.ts

@@ -0,0 +1,303 @@
+import type {
+  AdjacentEdgeRow,
+  BetterSqlite3Database,
+  CallableNodeRow,
+  CallEdgeRow,
+  ChildNodeRow,
+  ComplexityMetrics,
+  FileNodeRow,
+  ImportEdgeRow,
+  ImportGraphEdgeRow,
+  IntraFileCallEdge,
+  ListFunctionOpts,
+  NodeIdRow,
+  NodeRow,
+  NodeRowWithFanIn,
+  QueryOpts,
+  RelatedNodeRow,
+  TriageNodeRow,
+  TriageQueryOpts,
+} from '../../types.js';
+import { Repository } from './base.js';
+import { hasCfgTables } from './cfg.js';
+import { getComplexityForNode } from './complexity.js';
+import { hasDataflowTable } from './dataflow.js';
+import {
+  countCrossFileCallers,
+  findAllIncomingEdges,
+  findAllOutgoingEdges,
+  findCalleeNames,
+  findCallees,
+  findCallerNames,
+  findCallers,
+  findCrossFileCallTargets,
+  findDistinctCallers,
+  findImplementors,
+  findImportDependents,
+  findImportSources,
+  findImportTargets,
+  findInterfaces,
+  findIntraFileCallEdges,
+  getClassHierarchy,
+} from './edges.js';
+import { hasEmbeddings } from './embeddings.js';
+import { getCallableNodes, getCallEdges, getFileNodesAll, getImportEdges } from './graph-read.js';
+import {
+  bulkNodeIdsByFile,
+  countEdges,
+  countFiles,
+  countNodes,
+  findFileNodes,
+  findNodeById,
+  findNodeByQualifiedName,
+  findNodeChildren,
+  findNodesByFile,
+  findNodesByScope,
+  findNodesForTriage,
+  findNodesWithFanIn,
+  getFunctionNodeId,
+  getNodeId,
+  iterateFunctionNodes,
+  listFunctionNodes,
+} from './nodes.js';
+
+/**
+ * SqliteRepository — wraps existing `fn(db, ...)` repository functions
+ * behind the Repository interface so callers can use `repo.method(...)`.
+ */
+export class SqliteRepository extends Repository {
+  #db: BetterSqlite3Database;
+
+  constructor(db: BetterSqlite3Database) {
+    super();
+    this.#db = db;
+  }
+
+  /** Expose the underlying db for code that still needs raw access. */
+  get db(): BetterSqlite3Database {
+    return this.#db;
+  }
+
+  // ── Node lookups ──────────────────────────────────────────────────
+
+  findNodeById(id: number): NodeRow | undefined {
+    return findNodeById(this.#db, id);
+  }
+
+  findNodesByFile(file: string): NodeRow[] {
+    return findNodesByFile(this.#db, file);
+  }
+
+  findFileNodes(fileLike: string): NodeRow[] {
+    return findFileNodes(this.#db, fileLike);
+  }
+
+  findNodesWithFanIn(namePattern: string, opts?: QueryOpts): NodeRowWithFanIn[] {
+    return findNodesWithFanIn(this.#db, namePattern, opts);
+  }
+
+  countNodes(): number {
+    return countNodes(this.#db);
+  }
+
+  countEdges(): number {
+    return countEdges(this.#db);
+  }
+
+  countFiles(): number {
+    return countFiles(this.#db);
+  }
+
+  getNodeId(name: string, kind: string, file: string, line: number): number | undefined {
+    return getNodeId(this.#db, name, kind, file, line);
+  }
+
+  getFunctionNodeId(name: string, file: string, line: number): number | undefined {
+    return getFunctionNodeId(this.#db, name, file, line);
+  }
+
+  bulkNodeIdsByFile(file: string): NodeIdRow[] {
+    return bulkNodeIdsByFile(this.#db, file);
+  }
+
+  findNodeChildren(parentId: number): ChildNodeRow[] {
+    return findNodeChildren(this.#db, parentId);
+  }
+
+  findNodesByScope(scopeName: string, opts?: QueryOpts): NodeRow[] {
+    return findNodesByScope(this.#db, scopeName, opts);
+  }
+
+  findNodeByQualifiedName(qualifiedName: string, opts?: { file?: string }): NodeRow[] {
+    return findNodeByQualifiedName(this.#db, qualifiedName, opts);
+  }
+
+  listFunctionNodes(opts?: ListFunctionOpts): NodeRow[] {
+    return listFunctionNodes(this.#db, opts);
+  }
+
+  iterateFunctionNodes(opts?: ListFunctionOpts): IterableIterator<NodeRow> {
+    return iterateFunctionNodes(this.#db, opts);
+  }
+
+  findNodesForTriage(opts?: TriageQueryOpts): TriageNodeRow[] {
+    return findNodesForTriage(this.#db, opts);
+  }
+
+  // ── Edge queries ──────────────────────────────────────────────────
+
+  findCallees(nodeId: number): RelatedNodeRow[] {
+    return findCallees(this.#db, nodeId);
+  }
+
+  findCallers(nodeId: number): RelatedNodeRow[] {
+    return findCallers(this.#db, nodeId);
+  }
+
+  findCallersBatch(nodeIds: number[]): Map<number, RelatedNodeRow[]> {
+    if (nodeIds.length === 0) return new Map();
+    const placeholders = nodeIds.map(() => '?').join(',');
+    const rows = this.#db
+      .prepare(
+        `SELECT e.target_id AS queried_id, n.id, n.name, n.kind, n.file, n.line, n.end_line
+         FROM edges e JOIN nodes n ON e.source_id = n.id
+         WHERE e.target_id IN (${placeholders}) AND e.kind = 'calls'`,
+      )
+      .all(...nodeIds) as Array<RelatedNodeRow & { queried_id: number }>;
+    const result = new Map<number, RelatedNodeRow[]>();
+    for (const row of rows) {
+      const qid = row.queried_id;
+      if (!result.has(qid)) result.set(qid, []);
+      result.get(qid)!.push({
+        id: row.id,
+        name: row.name,
+        kind: row.kind,
+        file: row.file,
+        line: row.line,
+        end_line: row.end_line,
+      });
+    }
+    return result;
+  }
+
+  findDistinctCallers(nodeId: number): RelatedNodeRow[] {
+    return findDistinctCallers(this.#db, nodeId);
+  }
+
+  findAllOutgoingEdges(nodeId: number): AdjacentEdgeRow[] {
+    return findAllOutgoingEdges(this.#db, nodeId);
+  }
+
+  findAllIncomingEdges(nodeId: number): AdjacentEdgeRow[] {
+    return findAllIncomingEdges(this.#db, nodeId);
+  }
+
+  findCalleeNames(nodeId: number): string[] {
+    return findCalleeNames(this.#db, nodeId);
+  }
+
+  findCallerNames(nodeId: number): string[] {
+    return findCallerNames(this.#db, nodeId);
+  }
+
+  findImportTargets(nodeId: number): ImportEdgeRow[] {
+    return findImportTargets(this.#db, nodeId);
+  }
+
+  findImportSources(nodeId: number): ImportEdgeRow[] {
+    return findImportSources(this.#db, nodeId);
+  }
+
+  findImportDependents(nodeId: number): NodeRow[] {
+    return findImportDependents(this.#db, nodeId);
+  }
+
+  findCrossFileCallTargets(file: string): Set<number> {
+    return findCrossFileCallTargets(this.#db, file);
+  }
+
+  countCrossFileCallers(nodeId: number, file: string): number {
+    return countCrossFileCallers(this.#db, nodeId, file);
+  }
+
+  getClassHierarchy(classNodeId: number): Set<number> {
+    return getClassHierarchy(this.#db, classNodeId);
+  }
+
+  findImplementors(nodeId: number): RelatedNodeRow[] {
+    return findImplementors(this.#db, nodeId);
+  }
+
+  findInterfaces(nodeId: number): RelatedNodeRow[] {
+    return findInterfaces(this.#db, nodeId);
+  }
+
+  findIntraFileCallEdges(file: string): IntraFileCallEdge[] {
+    return findIntraFileCallEdges(this.#db, file);
+  }
+
+  // ── Graph-read queries ────────────────────────────────────────────
+
+  getCallableNodes(): CallableNodeRow[] {
+    return getCallableNodes(this.#db);
+  }
+
+  getCallEdges(): CallEdgeRow[] {
+    return getCallEdges(this.#db);
+  }
+
+  getFileNodesAll(): FileNodeRow[] {
+    return getFileNodesAll(this.#db);
+  }
+
+  getImportEdges(): ImportGraphEdgeRow[] {
+    return getImportEdges(this.#db);
+  }
+
+  // ── Optional table checks ─────────────────────────────────────────
+
+  hasCfgTables(): boolean {
+    return hasCfgTables(this.#db);
+  }
+
+  hasEmbeddings(): boolean {
+    return hasEmbeddings(this.#db);
+  }
+
+  hasDataflowTable(): boolean {
+    return hasDataflowTable(this.#db);
+  }
+
+  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;
+  }
+}