@optave/codegraph 3.3.1 → 3.4.1

package/src/db/repository/{cfg.js → cfg.ts}

@@ -1,17 +1,34 @@
+import type { BetterSqlite3Database, StmtCache } from '../../types.js';
 import { cachedStmt } from './cached-stmt.js';
 
 // ─── Statement caches (one prepared statement per db instance) ────────────
-const _getCfgBlocksStmt = new WeakMap();
-const _getCfgEdgesStmt = new WeakMap();
-const _deleteCfgEdgesStmt = new WeakMap();
-const _deleteCfgBlocksStmt = new WeakMap();
+
+interface CfgBlockRow {
+  id: number;
+  block_index: number;
+  block_type: string;
+  start_line: number;
+  end_line: number;
+  label: string | null;
+}
+
+interface CfgEdgeRow {
+  kind: string;
+  source_index: number;
+  source_type: string;
+  target_index: number;
+  target_type: string;
+}
+
+const _getCfgBlocksStmt: StmtCache<CfgBlockRow> = new WeakMap();
+const _getCfgEdgesStmt: StmtCache<CfgEdgeRow> = new WeakMap();
+const _deleteCfgEdgesStmt: StmtCache = new WeakMap();
+const _deleteCfgBlocksStmt: StmtCache = new WeakMap();
 
 /**
  * Check whether CFG tables exist.
- * @param {object} db
- * @returns {boolean}
  */
-export function hasCfgTables(db) {
+export function hasCfgTables(db: BetterSqlite3Database): boolean {
   try {
     db.prepare('SELECT 1 FROM cfg_blocks LIMIT 0').get();
     return true;
@@ -22,11 +39,8 @@ export function hasCfgTables(db) {
 
 /**
  * Get CFG blocks for a function node.
- * @param {object} db
- * @param {number} functionNodeId
- * @returns {object[]}
  */
-export function getCfgBlocks(db, functionNodeId) {
+export function getCfgBlocks(db: BetterSqlite3Database, functionNodeId: number): CfgBlockRow[] {
   return cachedStmt(
     _getCfgBlocksStmt,
     db,
@@ -38,11 +52,8 @@ export function getCfgBlocks(db, functionNodeId) {
 
 /**
  * Get CFG edges for a function node (with block info).
- * @param {object} db
- * @param {number} functionNodeId
- * @returns {object[]}
  */
-export function getCfgEdges(db, functionNodeId) {
+export function getCfgEdges(db: BetterSqlite3Database, functionNodeId: number): CfgEdgeRow[] {
   return cachedStmt(
     _getCfgEdgesStmt,
     db,
@@ -59,10 +70,8 @@ export function getCfgEdges(db, functionNodeId) {
 
 /**
  * Delete all CFG data for a function node.
- * @param {object} db
- * @param {number} functionNodeId
  */
-export function deleteCfgForNode(db, functionNodeId) {
+export function deleteCfgForNode(db: BetterSqlite3Database, functionNodeId: number): void {
   cachedStmt(_deleteCfgEdgesStmt, db, 'DELETE FROM cfg_edges WHERE function_node_id = ?').run(
     functionNodeId,
   );

package/src/db/repository/{cochange.js → cochange.ts}

@@ -1,16 +1,15 @@
+import type { BetterSqlite3Database, StmtCache } from '../../types.js';
 import { cachedStmt } from './cached-stmt.js';
 
 // ─── Statement caches (one prepared statement per db instance) ────────────
-const _hasCoChangesStmt = new WeakMap();
-const _getCoChangeMetaStmt = new WeakMap();
-const _upsertCoChangeMetaStmt = new WeakMap();
+const _hasCoChangesStmt: StmtCache<{ 1: number }> = new WeakMap();
+const _getCoChangeMetaStmt: StmtCache<{ key: string; value: string }> = new WeakMap();
+const _upsertCoChangeMetaStmt: StmtCache = new WeakMap();
 
 /**
  * Check whether the co_changes table has data.
- * @param {object} db
- * @returns {boolean}
  */
-export function hasCoChanges(db) {
+export function hasCoChanges(db: BetterSqlite3Database): boolean {
   try {
     return !!cachedStmt(_hasCoChangesStmt, db, 'SELECT 1 FROM co_changes LIMIT 1').get();
   } catch {
@@ -20,11 +19,9 @@ export function hasCoChanges(db) {
 
 /**
  * Get all co-change metadata as a key-value map.
- * @param {object} db
- * @returns {Record<string, string>}
  */
-export function getCoChangeMeta(db) {
-  const meta = {};
+export function getCoChangeMeta(db: BetterSqlite3Database): Record<string, string> {
+  const meta: Record<string, string> = {};
   try {
     for (const row of cachedStmt(
       _getCoChangeMetaStmt,
@@ -41,11 +38,8 @@ export function getCoChangeMeta(db) {
 
 /**
  * Upsert a co-change metadata key-value pair.
- * @param {object} db
- * @param {string} key
- * @param {string} value
  */
-export function upsertCoChangeMeta(db, key, value) {
+export function upsertCoChangeMeta(db: BetterSqlite3Database, key: string, value: string): void {
   cachedStmt(
     _upsertCoChangeMetaStmt,
     db,

package/src/db/repository/{complexity.js → complexity.ts}

@@ -1,16 +1,17 @@
+import type { BetterSqlite3Database, ComplexityMetrics, StmtCache } from '../../types.js';
 import { cachedStmt } from './cached-stmt.js';
 
 // ─── Statement caches (one prepared statement per db instance) ────────────
-const _getComplexityForNodeStmt = new WeakMap();
+const _getComplexityForNodeStmt: StmtCache<ComplexityMetrics> = new WeakMap();
 
 /**
  * Get complexity metrics for a node.
  * Used by contextData and explainFunctionImpl in queries.js.
- * @param {object} db
- * @param {number} nodeId
- * @returns {{ cognitive: number, cyclomatic: number, max_nesting: number, maintainability_index: number, halstead_volume: number }|undefined}
  */
-export function getComplexityForNode(db, nodeId) {
+export function getComplexityForNode(
+  db: BetterSqlite3Database,
+  nodeId: number,
+): ComplexityMetrics | undefined {
   return cachedStmt(
     _getComplexityForNodeStmt,
     db,

package/src/db/repository/dataflow.ts

@@ -0,0 +1,19 @@
+import type { BetterSqlite3Database, StmtCache } from '../../types.js';
+import { cachedStmt } from './cached-stmt.js';
+
+// ─── Statement caches (one prepared statement per db instance) ────────────
+const _hasDataflowTableStmt: StmtCache<{ c: number }> = new WeakMap();
+
+/**
+ * Check whether the dataflow table exists and has data.
+ */
+export function hasDataflowTable(db: BetterSqlite3Database): boolean {
+  try {
+    return (
+      (cachedStmt(_hasDataflowTableStmt, db, 'SELECT COUNT(*) AS c FROM dataflow').get()?.c ?? 0) >
+      0
+    );
+  } catch {
+    return false;
+  }
+}

package/src/db/repository/{edges.js → edges.ts}

@@ -1,33 +1,38 @@
+import type {
+  AdjacentEdgeRow,
+  BetterSqlite3Database,
+  ImportEdgeRow,
+  IntraFileCallEdge,
+  NodeRow,
+  RelatedNodeRow,
+  StmtCache,
+} from '../../types.js';
 import { cachedStmt } from './cached-stmt.js';
 
 // ─── Prepared-statement caches (one per db instance) ────────────────────
-const _findCalleesStmt = new WeakMap();
-const _findCallersStmt = new WeakMap();
-const _findDistinctCallersStmt = new WeakMap();
-const _findAllOutgoingStmt = new WeakMap();
-const _findAllIncomingStmt = new WeakMap();
-const _findCalleeNamesStmt = new WeakMap();
-const _findCallerNamesStmt = new WeakMap();
-const _findImportTargetsStmt = new WeakMap();
-const _findImportSourcesStmt = new WeakMap();
-const _findImportDependentsStmt = new WeakMap();
-const _findCrossFileCallTargetsStmt = new WeakMap();
-const _countCrossFileCallersStmt = new WeakMap();
-const _getClassAncestorsStmt = new WeakMap();
-const _findIntraFileCallEdgesStmt = new WeakMap();
-const _findImplementorsStmt = new WeakMap();
-const _findInterfacesStmt = new WeakMap();
+const _findCalleesStmt: StmtCache<RelatedNodeRow> = new WeakMap();
+const _findCallersStmt: StmtCache<RelatedNodeRow> = new WeakMap();
+const _findDistinctCallersStmt: StmtCache<RelatedNodeRow> = new WeakMap();
+const _findAllOutgoingStmt: StmtCache<AdjacentEdgeRow> = new WeakMap();
+const _findAllIncomingStmt: StmtCache<AdjacentEdgeRow> = new WeakMap();
+const _findCalleeNamesStmt: StmtCache<{ name: string }> = new WeakMap();
+const _findCallerNamesStmt: StmtCache<{ name: string }> = new WeakMap();
+const _findImportTargetsStmt: StmtCache<ImportEdgeRow> = new WeakMap();
+const _findImportSourcesStmt: StmtCache<ImportEdgeRow> = new WeakMap();
+const _findImportDependentsStmt: StmtCache<NodeRow> = new WeakMap();
+const _findCrossFileCallTargetsStmt: StmtCache<{ target_id: number }> = new WeakMap();
+const _countCrossFileCallersStmt: StmtCache<{ cnt: number }> = new WeakMap();
+const _getClassAncestorsStmt: StmtCache<{ id: number; name: string }> = new WeakMap();
+const _findIntraFileCallEdgesStmt: StmtCache<IntraFileCallEdge> = new WeakMap();
+const _findImplementorsStmt: StmtCache<RelatedNodeRow> = new WeakMap();
+const _findInterfacesStmt: StmtCache<RelatedNodeRow> = new WeakMap();
 
 // ─── Call-edge queries ──────────────────────────────────────────────────
 
 /**
  * Find all callees of a node (outgoing 'calls' edges).
- * Returns full node info including end_line for source display.
- * @param {object} db
- * @param {number} nodeId
- * @returns {{ id: number, name: string, kind: string, file: string, line: number, end_line: number|null }[]}
  */
-export function findCallees(db, nodeId) {
+export function findCallees(db: BetterSqlite3Database, nodeId: number): RelatedNodeRow[] {
   return cachedStmt(
     _findCalleesStmt,
     db,
@@ -39,11 +44,8 @@ export function findCallees(db, nodeId) {
 
 /**
  * Find all callers of a node (incoming 'calls' edges).
- * @param {object} db
- * @param {number} nodeId
- * @returns {{ id: number, name: string, kind: string, file: string, line: number }[]}
  */
-export function findCallers(db, nodeId) {
+export function findCallers(db: BetterSqlite3Database, nodeId: number): RelatedNodeRow[] {
   return cachedStmt(
     _findCallersStmt,
     db,
@@ -55,11 +57,8 @@ export function findCallers(db, nodeId) {
 
 /**
  * Find distinct callers of a node (for impact analysis BFS).
- * @param {object} db
- * @param {number} nodeId
- * @returns {{ id: number, name: string, kind: string, file: string, line: number }[]}
  */
-export function findDistinctCallers(db, nodeId) {
+export function findDistinctCallers(db: BetterSqlite3Database, nodeId: number): RelatedNodeRow[] {
   return cachedStmt(
     _findDistinctCallersStmt,
     db,
@@ -73,11 +72,8 @@ export function findDistinctCallers(db, nodeId) {
 
 /**
  * Find all outgoing edges with edge kind (for queryNameData).
- * @param {object} db
- * @param {number} nodeId
- * @returns {{ name: string, kind: string, file: string, line: number, edge_kind: string }[]}
  */
-export function findAllOutgoingEdges(db, nodeId) {
+export function findAllOutgoingEdges(db: BetterSqlite3Database, nodeId: number): AdjacentEdgeRow[] {
   return cachedStmt(
     _findAllOutgoingStmt,
     db,
@@ -89,11 +85,8 @@ export function findAllOutgoingEdges(db, nodeId) {
 
 /**
  * Find all incoming edges with edge kind (for queryNameData).
- * @param {object} db
- * @param {number} nodeId
- * @returns {{ name: string, kind: string, file: string, line: number, edge_kind: string }[]}
  */
-export function findAllIncomingEdges(db, nodeId) {
+export function findAllIncomingEdges(db: BetterSqlite3Database, nodeId: number): AdjacentEdgeRow[] {
   return cachedStmt(
     _findAllIncomingStmt,
     db,
@@ -107,11 +100,8 @@ export function findAllIncomingEdges(db, nodeId) {
 
 /**
  * Get distinct callee names for a node, sorted alphabetically.
- * @param {object} db
- * @param {number} nodeId
- * @returns {string[]}
  */
-export function findCalleeNames(db, nodeId) {
+export function findCalleeNames(db: BetterSqlite3Database, nodeId: number): string[] {
   return cachedStmt(
     _findCalleeNamesStmt,
     db,
@@ -126,11 +116,8 @@ export function findCalleeNames(db, nodeId) {
 
 /**
  * Get distinct caller names for a node, sorted alphabetically.
- * @param {object} db
- * @param {number} nodeId
- * @returns {string[]}
  */
-export function findCallerNames(db, nodeId) {
+export function findCallerNames(db: BetterSqlite3Database, nodeId: number): string[] {
   return cachedStmt(
     _findCallerNamesStmt,
     db,
@@ -147,11 +134,8 @@ export function findCallerNames(db, nodeId) {
 
 /**
  * Find outgoing import edges (files this node imports).
- * @param {object} db
- * @param {number} nodeId
- * @returns {{ file: string, edge_kind: string }[]}
  */
-export function findImportTargets(db, nodeId) {
+export function findImportTargets(db: BetterSqlite3Database, nodeId: number): ImportEdgeRow[] {
   return cachedStmt(
     _findImportTargetsStmt,
     db,
@@ -163,11 +147,8 @@ export function findImportTargets(db, nodeId) {
 
 /**
  * Find incoming import edges (files that import this node).
- * @param {object} db
- * @param {number} nodeId
- * @returns {{ file: string, edge_kind: string }[]}
  */
-export function findImportSources(db, nodeId) {
+export function findImportSources(db: BetterSqlite3Database, nodeId: number): ImportEdgeRow[] {
   return cachedStmt(
     _findImportSourcesStmt,
     db,
@@ -179,12 +160,8 @@ export function findImportSources(db, nodeId) {
 
 /**
  * Find nodes that import a given node (BFS-ready, returns full node info).
- * Used by impactAnalysisData for transitive import traversal.
- * @param {object} db
- * @param {number} nodeId
- * @returns {object[]}
  */
-export function findImportDependents(db, nodeId) {
+export function findImportDependents(db: BetterSqlite3Database, nodeId: number): NodeRow[] {
   return cachedStmt(
     _findImportDependentsStmt,
     db,
@@ -197,12 +174,8 @@ export function findImportDependents(db, nodeId) {
 
 /**
  * Get IDs of symbols in a file that are called from other files.
- * Used for "exported" detection in explain/where/exports.
- * @param {object} db
- * @param {string} file
- * @returns {Set<number>}
  */
-export function findCrossFileCallTargets(db, file) {
+export function findCrossFileCallTargets(db: BetterSqlite3Database, file: string): Set<number> {
   return new Set(
     cachedStmt(
       _findCrossFileCallTargetsStmt,
@@ -219,29 +192,27 @@ export function findCrossFileCallTargets(db, file) {
 
 /**
  * Count callers that are in a different file than the target node.
- * Used by whereSymbolImpl to determine if a symbol is exported.
- * @param {object} db
- * @param {number} nodeId
- * @param {string} file - The target node's file
- * @returns {number}
  */
-export function countCrossFileCallers(db, nodeId, file) {
-  return cachedStmt(
-    _countCrossFileCallersStmt,
-    db,
-    `SELECT COUNT(*) AS cnt FROM edges e JOIN nodes n ON e.source_id = n.id
+export function countCrossFileCallers(
+  db: BetterSqlite3Database,
+  nodeId: number,
+  file: string,
+): number {
+  return (
+    cachedStmt(
+      _countCrossFileCallersStmt,
+      db,
+      `SELECT COUNT(*) AS cnt FROM edges e JOIN nodes n ON e.source_id = n.id
      WHERE e.target_id = ? AND e.kind = 'calls' AND n.file != ?`,
-  ).get(nodeId, file).cnt;
+    ).get(nodeId, file)?.cnt ?? 0
+  );
 }
 
 /**
  * Get all ancestor class IDs via extends edges (BFS).
- * @param {object} db
- * @param {number} classNodeId
- * @returns {Set<number>}
  */
-export function getClassHierarchy(db, classNodeId) {
-  const ancestors = new Set();
+export function getClassHierarchy(db: BetterSqlite3Database, classNodeId: number): Set<number> {
+  const ancestors = new Set<number>();
   const queue = [classNodeId];
   const stmt = cachedStmt(
     _getClassAncestorsStmt,
@@ -250,7 +221,7 @@ export function getClassHierarchy(db, classNodeId) {
      WHERE e.source_id = ? AND e.kind = 'extends'`,
   );
   while (queue.length > 0) {
-    const current = queue.shift();
+    const current = queue.shift() as number;
     const parents = stmt.all(current);
     for (const p of parents) {
       if (!ancestors.has(p.id)) {
@@ -266,12 +237,8 @@ export function getClassHierarchy(db, classNodeId) {
 
 /**
  * Find all concrete types that implement a given interface/trait node.
- * Follows incoming 'implements' edges (source = implementor, target = interface).
- * @param {object} db
- * @param {number} nodeId - The interface/trait node ID
- * @returns {{ id: number, name: string, kind: string, file: string, line: number }[]}
  */
-export function findImplementors(db, nodeId) {
+export function findImplementors(db: BetterSqlite3Database, nodeId: number): RelatedNodeRow[] {
   return cachedStmt(
     _findImplementorsStmt,
     db,
@@ -283,12 +250,8 @@ export function findImplementors(db, nodeId) {
 
 /**
  * Find all interfaces/traits that a given class/struct implements.
- * Follows outgoing 'implements' edges (source = class, target = interface).
- * @param {object} db
- * @param {number} nodeId - The class/struct node ID
- * @returns {{ id: number, name: string, kind: string, file: string, line: number }[]}
  */
-export function findInterfaces(db, nodeId) {
+export function findInterfaces(db: BetterSqlite3Database, nodeId: number): RelatedNodeRow[] {
   return cachedStmt(
     _findInterfacesStmt,
     db,
@@ -300,12 +263,11 @@ export function findInterfaces(db, nodeId) {
 
 /**
  * Find intra-file call edges (caller → callee within the same file).
- * Used by explainFileImpl for data flow visualization.
- * @param {object} db
- * @param {string} file
- * @returns {{ caller_name: string, callee_name: string }[]}
  */
-export function findIntraFileCallEdges(db, file) {
+export function findIntraFileCallEdges(
+  db: BetterSqlite3Database,
+  file: string,
+): IntraFileCallEdge[] {
   return cachedStmt(
     _findIntraFileCallEdgesStmt,
     db,

package/src/db/repository/{embeddings.js → embeddings.ts}

@@ -1,16 +1,15 @@
+import type { BetterSqlite3Database, StmtCache } from '../../types.js';
 import { cachedStmt } from './cached-stmt.js';
 
 // ─── Statement caches (one prepared statement per db instance) ────────────
-const _hasEmbeddingsStmt = new WeakMap();
-const _getEmbeddingCountStmt = new WeakMap();
-const _getEmbeddingMetaStmt = new WeakMap();
+const _hasEmbeddingsStmt: StmtCache<{ 1: number }> = new WeakMap();
+const _getEmbeddingCountStmt: StmtCache<{ c: number }> = new WeakMap();
+const _getEmbeddingMetaStmt: StmtCache<{ value: string }> = new WeakMap();
 
 /**
  * Check whether the embeddings table has data.
- * @param {object} db
- * @returns {boolean}
  */
-export function hasEmbeddings(db) {
+export function hasEmbeddings(db: BetterSqlite3Database): boolean {
   try {
     return !!cachedStmt(_hasEmbeddingsStmt, db, 'SELECT 1 FROM embeddings LIMIT 1').get();
   } catch {
@@ -20,12 +19,12 @@ export function hasEmbeddings(db) {
 
 /**
  * Get the count of embeddings.
- * @param {object} db
- * @returns {number}
  */
-export function getEmbeddingCount(db) {
+export function getEmbeddingCount(db: BetterSqlite3Database): number {
   try {
-    return cachedStmt(_getEmbeddingCountStmt, db, 'SELECT COUNT(*) AS c FROM embeddings').get().c;
+    return (
+      cachedStmt(_getEmbeddingCountStmt, db, 'SELECT COUNT(*) AS c FROM embeddings').get()?.c ?? 0
+    );
   } catch {
     return 0;
   }
@@ -33,11 +32,8 @@ export function getEmbeddingCount(db) {
 
 /**
  * Get a single embedding metadata value by key.
- * @param {object} db
- * @param {string} key
- * @returns {string|undefined}
  */
-export function getEmbeddingMeta(db, key) {
+export function getEmbeddingMeta(db: BetterSqlite3Database, key: string): string | undefined {
   try {
     const row = cachedStmt(
       _getEmbeddingMetaStmt,

package/src/db/repository/{graph-read.js → graph-read.ts}

@@ -1,20 +1,26 @@
 import { CORE_SYMBOL_KINDS } from '../../shared/kinds.js';
+import type {
+  BetterSqlite3Database,
+  CallableNodeRow,
+  CallEdgeRow,
+  FileNodeRow,
+  ImportGraphEdgeRow,
+  StmtCache,
+} from '../../types.js';
 import { cachedStmt } from './cached-stmt.js';
 
 // ─── Statement caches (one prepared statement per db instance) ────────────
-const _getCallableNodesStmt = new WeakMap();
-const _getCallEdgesStmt = new WeakMap();
-const _getFileNodesAllStmt = new WeakMap();
-const _getImportEdgesStmt = new WeakMap();
+const _getCallableNodesStmt: StmtCache<CallableNodeRow> = new WeakMap();
+const _getCallEdgesStmt: StmtCache<CallEdgeRow> = new WeakMap();
+const _getFileNodesAllStmt: StmtCache<FileNodeRow> = new WeakMap();
+const _getImportEdgesStmt: StmtCache<ImportGraphEdgeRow> = new WeakMap();
 
-const CALLABLE_KINDS_SQL = CORE_SYMBOL_KINDS.map((k) => `'${k}'`).join(',');
+const CALLABLE_KINDS_SQL = CORE_SYMBOL_KINDS.map((k: string) => `'${k}'`).join(',');
 
 /**
  * Get callable nodes (all core symbol kinds) for graph construction.
- * @param {object} db
- * @returns {{ id: number, name: string, kind: string, file: string }[]}
  */
-export function getCallableNodes(db) {
+export function getCallableNodes(db: BetterSqlite3Database): CallableNodeRow[] {
   return cachedStmt(
     _getCallableNodesStmt,
     db,
@@ -24,10 +30,8 @@ export function getCallableNodes(db) {
 
 /**
  * Get all 'calls' edges.
- * @param {object} db
- * @returns {{ source_id: number, target_id: number, confidence: number|null }[]}
  */
-export function getCallEdges(db) {
+export function getCallEdges(db: BetterSqlite3Database): CallEdgeRow[] {
   return cachedStmt(
     _getCallEdgesStmt,
     db,
@@ -37,10 +41,8 @@ export function getCallEdges(db) {
 
 /**
  * Get all file-kind nodes.
- * @param {object} db
- * @returns {{ id: number, name: string, file: string }[]}
  */
-export function getFileNodesAll(db) {
+export function getFileNodesAll(db: BetterSqlite3Database): FileNodeRow[] {
   return cachedStmt(
     _getFileNodesAllStmt,
     db,
@@ -50,10 +52,8 @@ export function getFileNodesAll(db) {
 
 /**
  * Get all import edges.
- * @param {object} db
- * @returns {{ source_id: number, target_id: number }[]}
  */
-export function getImportEdges(db) {
+export function getImportEdges(db: BetterSqlite3Database): ImportGraphEdgeRow[] {
   return cachedStmt(
     _getImportEdgesStmt,
     db,