@optave/codegraph 3.3.0 → 3.4.0

package/src/domain/analysis/{module-map.js → module-map.ts}

@@ -1,12 +1,21 @@
 import path from 'node:path';
 import { openReadonlyOrFail, testFilterSQL } from '../../db/index.js';
+import { cachedStmt } from '../../db/repository/cached-stmt.js';
 import { loadConfig } from '../../infrastructure/config.js';
 import { debug } from '../../infrastructure/logger.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import { DEAD_ROLE_PREFIX } from '../../shared/kinds.js';
+import type { BetterSqlite3Database, StmtCache } from '../../types.js';
 import { findCycles } from '../graph/cycles.js';
 import { LANGUAGE_REGISTRY } from '../parser.js';
 
+// ---------------------------------------------------------------------------
+// Statement caches (one prepared statement per db instance)
+// ---------------------------------------------------------------------------
+
+const _fileNodesStmtCache: StmtCache<{ id: number; file: string }> = new WeakMap();
+const _allNodesStmtCache: StmtCache<{ id: number; file: string }> = new WeakMap();
+
 export const FALSE_POSITIVE_NAMES = new Set([
   'run',
   'get',
@@ -43,35 +52,49 @@ export const FALSE_POSITIVE_CALLER_THRESHOLD = 20;
 // Section helpers
 // ---------------------------------------------------------------------------
 
-function buildTestFileIds(db) {
-  const allFileNodes = db.prepare("SELECT id, file FROM nodes WHERE kind = 'file'").all();
-  const testFileIds = new Set();
-  const testFiles = new Set();
+const _fileNodesStmt: StmtCache<{ id: number; file: string }> = new WeakMap();
+const _allNodesIdFileStmt: StmtCache<{ id: number; file: string }> = new WeakMap();
+
+function buildTestFileIds(db: BetterSqlite3Database): Set<number> {
+  const allFileNodes = cachedStmt(
+    _fileNodesStmt,
+    db,
+    "SELECT id, file FROM nodes WHERE kind = 'file'",
+  ).all();
+  const testFileIds = new Set<number>();
+  const testFiles = new Set<string>();
   for (const n of allFileNodes) {
     if (isTestFile(n.file)) {
       testFileIds.add(n.id);
       testFiles.add(n.file);
     }
   }
-  const allNodes = db.prepare('SELECT id, file FROM nodes').all();
+  const allNodes = cachedStmt(_allNodesIdFileStmt, db, 'SELECT id, file FROM nodes').all();
   for (const n of allNodes) {
     if (testFiles.has(n.file)) testFileIds.add(n.id);
   }
   return testFileIds;
 }
 
-function countNodesByKind(db, testFileIds) {
-  let nodeRows;
+function countNodesByKind(db: BetterSqlite3Database, testFileIds: Set<number> | null) {
+  let nodeRows: Array<{ kind: string; c: number }>;
   if (testFileIds) {
-    const allNodes = db.prepare('SELECT id, kind, file FROM nodes').all();
+    const allNodes = db.prepare('SELECT id, kind, file FROM nodes').all() as Array<{
+      id: number;
+      kind: string;
+      file: string;
+    }>;
     const filtered = allNodes.filter((n) => !testFileIds.has(n.id));
-    const counts = {};
+    const counts: Record<string, number> = {};
     for (const n of filtered) counts[n.kind] = (counts[n.kind] || 0) + 1;
     nodeRows = Object.entries(counts).map(([kind, c]) => ({ kind, c }));
   } else {
-    nodeRows = db.prepare('SELECT kind, COUNT(*) as c FROM nodes GROUP BY kind').all();
+    nodeRows = db.prepare('SELECT kind, COUNT(*) as c FROM nodes GROUP BY kind').all() as Array<{
+      kind: string;
+      c: number;
+    }>;
   }
-  const byKind = {};
+  const byKind: Record<string, number> = {};
   let total = 0;
   for (const r of nodeRows) {
     byKind[r.kind] = r.c;
@@ -80,20 +103,27 @@ function countNodesByKind(db, testFileIds) {
   return { total, byKind };
 }
 
-function countEdgesByKind(db, testFileIds) {
-  let edgeRows;
+function countEdgesByKind(db: BetterSqlite3Database, testFileIds: Set<number> | null) {
+  let edgeRows: Array<{ kind: string; c: number }>;
   if (testFileIds) {
-    const allEdges = db.prepare('SELECT source_id, target_id, kind FROM edges').all();
+    const allEdges = db.prepare('SELECT source_id, target_id, kind FROM edges').all() as Array<{
+      source_id: number;
+      target_id: number;
+      kind: string;
+    }>;
     const filtered = allEdges.filter(
       (e) => !testFileIds.has(e.source_id) && !testFileIds.has(e.target_id),
     );
-    const counts = {};
+    const counts: Record<string, number> = {};
     for (const e of filtered) counts[e.kind] = (counts[e.kind] || 0) + 1;
     edgeRows = Object.entries(counts).map(([kind, c]) => ({ kind, c }));
   } else {
-    edgeRows = db.prepare('SELECT kind, COUNT(*) as c FROM edges GROUP BY kind').all();
+    edgeRows = db.prepare('SELECT kind, COUNT(*) as c FROM edges GROUP BY kind').all() as Array<{
+      kind: string;
+      c: number;
+    }>;
   }
-  const byKind = {};
+  const byKind: Record<string, number> = {};
   let total = 0;
   for (const r of edgeRows) {
     byKind[r.kind] = r.c;
@@ -102,16 +132,18 @@ function countEdgesByKind(db, testFileIds) {
   return { total, byKind };
 }
 
-function countFilesByLanguage(db, noTests) {
-  const extToLang = new Map();
+function countFilesByLanguage(db: BetterSqlite3Database, noTests: boolean) {
+  const extToLang = new Map<string, string>();
   for (const entry of LANGUAGE_REGISTRY) {
     for (const ext of entry.extensions) {
       extToLang.set(ext, entry.id);
     }
   }
-  let fileNodes = db.prepare("SELECT file FROM nodes WHERE kind = 'file'").all();
+  let fileNodes = db.prepare("SELECT file FROM nodes WHERE kind = 'file'").all() as Array<{
+    file: string;
+  }>;
   if (noTests) fileNodes = fileNodes.filter((n) => !isTestFile(n.file));
-  const byLanguage = {};
+  const byLanguage: Record<string, number> = {};
   for (const row of fileNodes) {
     const ext = path.extname(row.file).toLowerCase();
     const lang = extToLang.get(ext) || 'other';
@@ -120,7 +152,7 @@ function countFilesByLanguage(db, noTests) {
   return { total: fileNodes.length, languages: Object.keys(byLanguage).length, byLanguage };
 }
 
-function findHotspots(db, noTests, limit) {
+function findHotspots(db: BetterSqlite3Database, noTests: boolean, limit: number) {
   const testFilter = testFilterSQL('n.file', noTests);
   const hotspotRows = db
     .prepare(`
@@ -132,7 +164,7 @@ function findHotspots(db, noTests, limit) {
       ORDER BY (SELECT COUNT(*) FROM edges WHERE target_id = n.id)
              + (SELECT COUNT(*) FROM edges WHERE source_id = n.id) DESC
     `)
-    .all();
+    .all() as Array<{ file: string; fan_in: number; fan_out: number }>;
   const filtered = noTests ? hotspotRows.filter((r) => !isTestFile(r.file)) : hotspotRows;
   return filtered.slice(0, limit).map((r) => ({
     file: r.file,
@@ -141,13 +173,18 @@ function findHotspots(db, noTests, limit) {
   }));
 }
 
-function getEmbeddingsInfo(db) {
+function getEmbeddingsInfo(db: BetterSqlite3Database) {
   try {
-    const count = db.prepare('SELECT COUNT(*) as c FROM embeddings').get();
+    const count = db.prepare('SELECT COUNT(*) as c FROM embeddings').get() as
+      | { c: number }
+      | undefined;
     if (count && count.c > 0) {
-      const meta = {};
-      const metaRows = db.prepare('SELECT key, value FROM embedding_meta').all();
-      for (const r of metaRows) meta[r.key] = r.value;
+      const meta: { model?: string; dim?: string; built_at?: string } = {};
+      const metaRows = db.prepare('SELECT key, value FROM embedding_meta').all() as Array<{
+        key: string;
+        value: string;
+      }>;
+      for (const r of metaRows) (meta as Record<string, string>)[r.key] = r.value;
       return {
         count: count.c,
         model: meta.model || null,
@@ -155,33 +192,45 @@ function getEmbeddingsInfo(db) {
         builtAt: meta.built_at || null,
       };
     }
-  } catch (e) {
-    debug(`embeddings lookup skipped: ${e.message}`);
+  } catch (e: unknown) {
+    debug(`embeddings lookup skipped: ${(e as Error).message}`);
   }
   return null;
 }
 
-function computeQualityMetrics(db, testFilter, fpThreshold = FALSE_POSITIVE_CALLER_THRESHOLD) {
+function computeQualityMetrics(
+  db: BetterSqlite3Database,
+  testFilter: string,
+  fpThreshold = FALSE_POSITIVE_CALLER_THRESHOLD,
+) {
   const qualityTestFilter = testFilter.replace(/n\.file/g, 'file');
 
-  const totalCallable = db
-    .prepare(
-      `SELECT COUNT(*) as c FROM nodes WHERE kind IN ('function', 'method') ${qualityTestFilter}`,
-    )
-    .get().c;
-  const callableWithCallers = db
-    .prepare(`
+  const totalCallable = (
+    db
+      .prepare(
+        `SELECT COUNT(*) as c FROM nodes WHERE kind IN ('function', 'method') ${qualityTestFilter}`,
+      )
+      .get() as { c: number }
+  ).c;
+  const callableWithCallers = (
+    db
+      .prepare(`
       SELECT COUNT(DISTINCT e.target_id) as c FROM edges e
       JOIN nodes n ON e.target_id = n.id
       WHERE e.kind = 'calls' AND n.kind IN ('function', 'method') ${testFilter}
     `)
-    .get().c;
+      .get() as { c: number }
+  ).c;
   const callerCoverage = totalCallable > 0 ? callableWithCallers / totalCallable : 0;
 
-  const totalCallEdges = db.prepare("SELECT COUNT(*) as c FROM edges WHERE kind = 'calls'").get().c;
-  const highConfCallEdges = db
-    .prepare("SELECT COUNT(*) as c FROM edges WHERE kind = 'calls' AND confidence >= 0.7")
-    .get().c;
+  const totalCallEdges = (
+    db.prepare("SELECT COUNT(*) as c FROM edges WHERE kind = 'calls'").get() as { c: number }
+  ).c;
+  const highConfCallEdges = (
+    db
+      .prepare("SELECT COUNT(*) as c FROM edges WHERE kind = 'calls' AND confidence >= 0.7")
+      .get() as { c: number }
+  ).c;
   const callConfidence = totalCallEdges > 0 ? highConfCallEdges / totalCallEdges : 0;
 
   const fpRows = db
@@ -194,10 +243,10 @@ function computeQualityMetrics(db, testFilter, fpThreshold = FALSE_POSITIVE_CALL
       HAVING caller_count > ?
       ORDER BY caller_count DESC
     `)
-    .all(fpThreshold);
+    .all(fpThreshold) as Array<{ name: string; file: string; line: number; caller_count: number }>;
   const falsePositiveWarnings = fpRows
     .filter((r) =>
-      FALSE_POSITIVE_NAMES.has(r.name.includes('.') ? r.name.split('.').pop() : r.name),
+      FALSE_POSITIVE_NAMES.has(r.name.includes('.') ? r.name.split('.').pop()! : r.name),
     )
     .map((r) => ({ name: r.name, file: r.file, line: r.line, callerCount: r.caller_count }));
 
@@ -225,20 +274,22 @@ function computeQualityMetrics(db, testFilter, fpThreshold = FALSE_POSITIVE_CALL
   };
 }
 
-function countRoles(db, noTests) {
-  let roleRows;
+function countRoles(db: BetterSqlite3Database, noTests: boolean) {
+  let roleRows: Array<{ role: string; c: number }>;
   if (noTests) {
-    const allRoleNodes = db.prepare('SELECT role, file FROM nodes WHERE role IS NOT NULL').all();
+    const allRoleNodes = db
+      .prepare('SELECT role, file FROM nodes WHERE role IS NOT NULL')
+      .all() as Array<{ role: string; file: string }>;
     const filtered = allRoleNodes.filter((n) => !isTestFile(n.file));
-    const counts = {};
+    const counts: Record<string, number> = {};
     for (const n of filtered) counts[n.role] = (counts[n.role] || 0) + 1;
     roleRows = Object.entries(counts).map(([role, c]) => ({ role, c }));
   } else {
     roleRows = db
       .prepare('SELECT role, COUNT(*) as c FROM nodes WHERE role IS NOT NULL GROUP BY role')
-      .all();
+      .all() as Array<{ role: string; c: number }>;
   }
-  const roles = {};
+  const roles: Record<string, number> & { dead?: number } = {};
   let deadTotal = 0;
   for (const r of roleRows) {
     roles[r.role] = r.c;
@@ -248,7 +299,7 @@ function countRoles(db, noTests) {
   return roles;
 }
 
-function getComplexitySummary(db, testFilter) {
+function getComplexitySummary(db: BetterSqlite3Database, testFilter: string) {
   try {
     const cRows = db
       .prepare(
@@ -256,7 +307,12 @@ function getComplexitySummary(db, testFilter) {
          FROM function_complexity fc JOIN nodes n ON fc.node_id = n.id
          WHERE n.kind IN ('function','method') ${testFilter}`,
       )
-      .all();
+      .all() as Array<{
+      cognitive: number;
+      cyclomatic: number;
+      max_nesting: number;
+      maintainability_index: number;
+    }>;
     if (cRows.length > 0) {
       const miValues = cRows.map((r) => r.maintainability_index || 0);
       return {
@@ -269,8 +325,8 @@ function getComplexitySummary(db, testFilter) {
         minMI: +Math.min(...miValues).toFixed(1),
       };
     }
-  } catch (e) {
-    debug(`complexity summary skipped: ${e.message}`);
+  } catch (e: unknown) {
+    debug(`complexity summary skipped: ${(e as Error).message}`);
   }
   return null;
 }
@@ -279,7 +335,7 @@ function getComplexitySummary(db, testFilter) {
 // Public API
 // ---------------------------------------------------------------------------
 
-export function moduleMapData(customDbPath, limit = 20, opts = {}) {
+export function moduleMapData(customDbPath: string, limit = 20, opts: { noTests?: boolean } = {}) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;
@@ -297,7 +353,7 @@ export function moduleMapData(customDbPath, limit = 20, opts = {}) {
       ORDER BY (SELECT COUNT(*) FROM edges WHERE target_id = n.id AND kind NOT IN ('contains', 'parameter_of', 'receiver')) DESC
       LIMIT ?
     `)
-      .all(limit);
+      .all(limit) as Array<{ file: string; in_edges: number; out_edges: number }>;
 
     const topNodes = nodes.map((n) => ({
       file: n.file,
@@ -307,9 +363,16 @@ export function moduleMapData(customDbPath, limit = 20, opts = {}) {
       coupling: n.in_edges + n.out_edges,
     }));
 
-    const totalNodes = db.prepare('SELECT COUNT(*) as c FROM nodes').get().c;
-    const totalEdges = db.prepare('SELECT COUNT(*) as c FROM edges').get().c;
-    const totalFiles = db.prepare("SELECT COUNT(*) as c FROM nodes WHERE kind = 'file'").get().c;
+    const totalNodes =
+      (db.prepare('SELECT COUNT(*) as c FROM nodes').get() as { c: number } | undefined)?.c ?? 0;
+    const totalEdges =
+      (db.prepare('SELECT COUNT(*) as c FROM edges').get() as { c: number } | undefined)?.c ?? 0;
+    const totalFiles =
+      (
+        db.prepare("SELECT COUNT(*) as c FROM nodes WHERE kind = 'file'").get() as
+          | { c: number }
+          | undefined
+      )?.c ?? 0;
 
     return { limit, topNodes, stats: { totalFiles, totalNodes, totalEdges } };
   } finally {
@@ -317,7 +380,11 @@ export function moduleMapData(customDbPath, limit = 20, opts = {}) {
   }
 }
 
-export function statsData(customDbPath, opts = {}) {
+export function statsData(
+  customDbPath: string,
+  // biome-ignore lint/suspicious/noExplicitAny: config shape is dynamic
+  opts: { noTests?: boolean; config?: any } = {},
+) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;

package/src/domain/analysis/{roles.js → roles.ts}

@@ -4,14 +4,24 @@ import { isTestFile } from '../../infrastructure/test-filter.js';
 import { DEAD_ROLE_PREFIX } from '../../shared/kinds.js';
 import { normalizeSymbol } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
+import type { NodeRow } from '../../types.js';
 
-export function rolesData(customDbPath, opts = {}) {
+export function rolesData(
+  customDbPath: string,
+  opts: {
+    noTests?: boolean;
+    role?: string | null;
+    file?: string;
+    limit?: number;
+    offset?: number;
+  } = {},
+) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;
     const filterRole = opts.role || null;
     const conditions = ['role IS NOT NULL'];
-    const params = [];
+    const params: (string | number)[] = [];
 
     if (filterRole) {
       if (filterRole === DEAD_ROLE_PREFIX) {
@@ -23,7 +33,7 @@ export function rolesData(customDbPath, opts = {}) {
       }
     }
     {
-      const fc = buildFileConditionSQL(opts.file, 'file');
+      const fc = buildFileConditionSQL(opts.file || '', 'file');
       if (fc.sql) {
         // Strip leading ' AND ' since we're using conditions array
         conditions.push(fc.sql.replace(/^ AND /, ''));
@@ -31,17 +41,25 @@ export function rolesData(customDbPath, opts = {}) {
       }
     }
 
+    // NOTE: cachedStmt cannot be applied here because the SQL varies per call —
+    // the WHERE clause is built dynamically from `conditions` (role filter, file
+    // filter). A future optimisation could use a fixed SQL with CASE/COALESCE to
+    // absorb optional filters, or maintain a small Map<string, StmtCache> keyed
+    // by the unique condition combination (there are only ~4 variants). For now
+    // the dynamic prepare is acceptable given the low call frequency of `roles`.
     let rows = db
       .prepare(
         `SELECT name, kind, file, line, end_line, role FROM nodes WHERE ${conditions.join(' AND ')} ORDER BY role, file, line`,
       )
-      .all(...params);
+      .all(...params) as NodeRow[];
 
     if (noTests) rows = rows.filter((r) => !isTestFile(r.file));
 
-    const summary = {};
+    const summary: Record<string, number> = {};
     for (const r of rows) {
-      summary[r.role] = (summary[r.role] || 0) + 1;
+      // SQL guarantees role IS NOT NULL
+      const role = r.role as string;
+      summary[role] = (summary[role] || 0) + 1;
     }
 
     const hc = new Map();

package/src/domain/analysis/{symbol-lookup.js → symbol-lookup.ts}

@@ -19,31 +19,54 @@ import { isTestFile } from '../../infrastructure/test-filter.js';
 import { EVERY_SYMBOL_KIND } from '../../shared/kinds.js';
 import { getFileHash, normalizeSymbol } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
-
-const FUNCTION_KINDS = ['function', 'method', 'class', 'constant'];
+import type {
+  AdjacentEdgeRow,
+  BetterSqlite3Database,
+  ChildNodeRow,
+  ImportEdgeRow,
+  NodeRow,
+  NodeRowWithFanIn,
+  SymbolKind,
+} from '../../types.js';
+
+const FUNCTION_KINDS: SymbolKind[] = ['function', 'method', 'class', 'constant'];
 
 /**
  * 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(dbOrRepo, name, opts = {}) {
-  const kinds = opts.kind ? [opts.kind] : opts.kinds?.length ? opts.kinds : FUNCTION_KINDS;
+export function findMatchingNodes(
+  dbOrRepo: BetterSqlite3Database | InstanceType<typeof Repository>,
+  name: string,
+  opts: { noTests?: boolean; file?: string; kind?: string; kinds?: readonly string[] } = {},
+): Array<NodeRowWithFanIn & { _relevance: number }> {
+  const kinds = (
+    opts.kind ? [opts.kind] : opts.kinds?.length ? [...opts.kinds] : FUNCTION_KINDS
+  ) as SymbolKind[];
 
   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;
+  const rows = (
+    isRepo
+      ? (dbOrRepo as InstanceType<typeof Repository>).findNodesWithFanIn(`%${name}%`, {
+          kinds,
+          file: opts.file,
+        })
+      : findNodesWithFanIn(dbOrRepo as BetterSqlite3Database, `%${name}%`, {
+          kinds,
+          file: opts.file,
+        })
+  ) as NodeRowWithFanIn[];
+
+  const nodes: Array<NodeRowWithFanIn & { _relevance: number }> = (
+    opts.noTests ? rows.filter((n) => !isTestFile(n.file)) : rows
+  ) as Array<NodeRowWithFanIn & { _relevance: number }>;
 
   const lowerQuery = name.toLowerCase();
   for (const node of nodes) {
     const lowerName = node.name.toLowerCase();
-    const bareName = lowerName.includes('.') ? lowerName.split('.').pop() : lowerName;
+    const bareName = lowerName.includes('.') ? lowerName.split('.').pop()! : lowerName;
 
-    let matchScore;
+    let matchScore: number;
     if (lowerName === lowerQuery || bareName === lowerQuery) {
       matchScore = 100;
     } else if (lowerName.startsWith(lowerQuery) || bareName.startsWith(lowerQuery)) {
@@ -62,11 +85,15 @@ export function findMatchingNodes(dbOrRepo, name, opts = {}) {
   return nodes;
 }
 
-export function queryNameData(name, customDbPath, opts = {}) {
+export function queryNameData(
+  name: string,
+  customDbPath: string,
+  opts: { noTests?: boolean; limit?: number; offset?: number } = {},
+) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;
-    let nodes = db.prepare(`SELECT * FROM nodes WHERE name LIKE ?`).all(`%${name}%`);
+    let nodes = db.prepare(`SELECT * FROM nodes WHERE name LIKE ?`).all(`%${name}%`) as NodeRow[];
     if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
     if (nodes.length === 0) {
       return { query: name, results: [] };
@@ -74,9 +101,9 @@ export function queryNameData(name, customDbPath, opts = {}) {
 
     const hc = new Map();
     const results = nodes.map((node) => {
-      let callees = findAllOutgoingEdges(db, node.id);
+      let callees = findAllOutgoingEdges(db, node.id) as AdjacentEdgeRow[];
 
-      let callers = findAllIncomingEdges(db, node.id);
+      let callers = findAllIncomingEdges(db, node.id) as AdjacentEdgeRow[];
 
       if (noTests) {
         callees = callees.filter((c) => !isTestFile(c.file));
@@ -109,13 +136,13 @@ export function queryNameData(name, customDbPath, opts = {}) {
   }
 }
 
-function whereSymbolImpl(db, target, noTests) {
+function whereSymbolImpl(db: BetterSqlite3Database, target: string, noTests: boolean) {
   const placeholders = EVERY_SYMBOL_KIND.map(() => '?').join(', ');
   let nodes = db
     .prepare(
       `SELECT * FROM nodes WHERE name LIKE ? AND kind IN (${placeholders}) ORDER BY file, line`,
     )
-    .all(`%${target}%`, ...EVERY_SYMBOL_KIND);
+    .all(`%${target}%`, ...EVERY_SYMBOL_KIND) as NodeRow[];
   if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
 
   const hc = new Map();
@@ -123,7 +150,7 @@ function whereSymbolImpl(db, target, noTests) {
     const crossCount = countCrossFileCallers(db, node.id, node.file);
     const exported = crossCount > 0;
 
-    let uses = findCallers(db, node.id);
+    let uses = findCallers(db, node.id) as Array<{ name: string; file: string; line: number }>;
     if (noTests) uses = uses.filter((u) => !isTestFile(u.file));
 
     return {
@@ -134,18 +161,18 @@ function whereSymbolImpl(db, target, noTests) {
   });
 }
 
-function whereFileImpl(db, target) {
-  const fileNodes = findFileNodes(db, `%${target}%`);
+function whereFileImpl(db: BetterSqlite3Database, target: string) {
+  const fileNodes = findFileNodes(db, `%${target}%`) as NodeRow[];
   if (fileNodes.length === 0) return [];
 
   return fileNodes.map((fn) => {
-    const symbols = findNodesByFile(db, fn.file);
+    const symbols = findNodesByFile(db, fn.file) as NodeRow[];
 
-    const imports = findImportTargets(db, fn.id).map((r) => r.file);
+    const imports = (findImportTargets(db, fn.id) as ImportEdgeRow[]).map((r) => r.file);
 
-    const importedBy = findImportSources(db, fn.id).map((r) => r.file);
+    const importedBy = (findImportSources(db, fn.id) as ImportEdgeRow[]).map((r) => r.file);
 
-    const exportedIds = findCrossFileCallTargets(db, fn.file);
+    const exportedIds = findCrossFileCallTargets(db, fn.file) as Set<number>;
 
     const exported = symbols.filter((s) => exportedIds.has(s.id)).map((s) => s.name);
 
@@ -160,7 +187,11 @@ function whereFileImpl(db, target) {
   });
 }
 
-export function whereData(target, customDbPath, opts = {}) {
+export function whereData(
+  target: string,
+  customDbPath: string,
+  opts: { noTests?: boolean; file?: boolean; limit?: number; offset?: number } = {},
+) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;
@@ -175,12 +206,21 @@ export function whereData(target, customDbPath, opts = {}) {
   }
 }
 
-export function listFunctionsData(customDbPath, opts = {}) {
+export function listFunctionsData(
+  customDbPath: string,
+  opts: {
+    noTests?: boolean;
+    file?: string;
+    pattern?: string;
+    limit?: number;
+    offset?: number;
+  } = {},
+) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;
 
-    let rows = listFunctionNodes(db, { file: opts.file, pattern: opts.pattern });
+    let rows = listFunctionNodes(db, { file: opts.file, pattern: opts.pattern }) as NodeRow[];
 
     if (noTests) rows = rows.filter((r) => !isTestFile(r.file));
 
@@ -193,7 +233,11 @@ export function listFunctionsData(customDbPath, opts = {}) {
   }
 }
 
-export function childrenData(name, customDbPath, opts = {}) {
+export function childrenData(
+  name: string,
+  customDbPath: string,
+  opts: { noTests?: boolean; file?: string; kind?: string; limit?: number; offset?: number } = {},
+) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;
@@ -204,11 +248,11 @@ export function childrenData(name, customDbPath, opts = {}) {
     }
 
     const results = nodes.map((node) => {
-      let children;
+      let children: ChildNodeRow[];
       try {
-        children = findNodeChildren(db, node.id);
-      } catch (e) {
-        debug(`findNodeChildren failed for node ${node.id}: ${e.message}`);
+        children = findNodeChildren(db, node.id) as ChildNodeRow[];
+      } catch (e: unknown) {
+        debug(`findNodeChildren failed for node ${node.id}: ${(e as Error).message}`);
         children = [];
       }
       if (noTests) children = children.filter((c) => !isTestFile(c.file || node.file));