@optave/codegraph 3.3.1 → 3.4.1

package/src/domain/analysis/fn-impact.ts

@@ -0,0 +1,241 @@
+import {
+  findDistinctCallers,
+  findFileNodes,
+  findImplementors,
+  findImportDependents,
+  findNodeById,
+  openReadonlyOrFail,
+} from '../../db/index.js';
+import { loadConfig } from '../../infrastructure/config.js';
+import { isTestFile } from '../../infrastructure/test-filter.js';
+import { normalizeSymbol } from '../../shared/normalize.js';
+import { paginateResult } from '../../shared/paginate.js';
+import type { BetterSqlite3Database, NodeRow, RelatedNodeRow } from '../../types.js';
+import { findMatchingNodes } from './symbol-lookup.js';
+
+// --- Shared BFS: transitive callers ---
+
+const INTERFACE_LIKE_KINDS = new Set(['interface', 'trait']);
+
+/**
+ * Check whether the graph contains any 'implements' edges.
+ * Cached per db handle so the query runs at most once per connection.
+ */
+const _hasImplementsCache: WeakMap<BetterSqlite3Database, boolean> = new WeakMap();
+function hasImplementsEdges(db: BetterSqlite3Database): boolean {
+  if (_hasImplementsCache.has(db)) return _hasImplementsCache.get(db)!;
+  const row = db.prepare("SELECT 1 FROM edges WHERE kind = 'implements' LIMIT 1").get();
+  const result = !!row;
+  _hasImplementsCache.set(db, result);
+  return result;
+}
+
+/**
+ * BFS traversal to find transitive callers of a node.
+ * When an interface/trait node is encountered (either as the start node or
+ * during traversal), its concrete implementors are also added to the frontier
+ * so that changes to an interface signature propagate to all implementors.
+ */
+export function bfsTransitiveCallers(
+  db: BetterSqlite3Database,
+  startId: number,
+  {
+    noTests = false,
+    maxDepth = 3,
+    includeImplementors = true,
+    onVisit,
+  }: {
+    noTests?: boolean;
+    maxDepth?: number;
+    includeImplementors?: boolean;
+    onVisit?: (
+      caller: RelatedNodeRow & { viaImplements?: boolean },
+      parentId: number,
+      depth: number,
+    ) => void;
+  } = {},
+) {
+  // Skip all implementor lookups when the graph has no implements edges
+  const resolveImplementors = includeImplementors && hasImplementsEdges(db);
+
+  const visited = new Set([startId]);
+  const levels: Record<
+    number,
+    Array<{ name: string; kind: string; file: string; line: number; viaImplements?: boolean }>
+  > = {};
+  let frontier = [startId];
+
+  // Seed: if start node is an interface/trait, include its implementors at depth 1.
+  // Implementors go into a separate list so their callers appear at depth 2, not depth 1.
+  const implNextFrontier: number[] = [];
+  if (resolveImplementors) {
+    const startNode = findNodeById(db, startId) as NodeRow | undefined;
+    if (startNode && INTERFACE_LIKE_KINDS.has(startNode.kind)) {
+      const impls = findImplementors(db, startId) as RelatedNodeRow[];
+      for (const impl of impls) {
+        if (!visited.has(impl.id) && (!noTests || !isTestFile(impl.file))) {
+          visited.add(impl.id);
+          implNextFrontier.push(impl.id);
+          if (!levels[1]) levels[1] = [];
+          levels[1].push({
+            name: impl.name,
+            kind: impl.kind,
+            file: impl.file,
+            line: impl.line,
+            viaImplements: true,
+          });
+          if (onVisit) onVisit({ ...impl, viaImplements: true }, startId, 1);
+        }
+      }
+    }
+  }
+
+  for (let d = 1; d <= maxDepth; d++) {
+    // On the first wave, merge seeded implementors so their callers appear at d=2
+    if (d === 1 && implNextFrontier.length > 0) {
+      frontier = [...frontier, ...implNextFrontier];
+    }
+    const nextFrontier: number[] = [];
+    for (const fid of frontier) {
+      const callers = findDistinctCallers(db, fid) as RelatedNodeRow[];
+      for (const c of callers) {
+        if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
+          visited.add(c.id);
+          nextFrontier.push(c.id);
+          if (!levels[d]) levels[d] = [];
+          levels[d]!.push({ name: c.name, kind: c.kind, file: c.file, line: c.line });
+          if (onVisit) onVisit(c, fid, d);
+        }
+
+        // If a caller is an interface/trait, also pull in its implementors
+        // Implementors are one extra hop away, so record at d+1
+        if (resolveImplementors && INTERFACE_LIKE_KINDS.has(c.kind)) {
+          const impls = findImplementors(db, c.id) as RelatedNodeRow[];
+          for (const impl of impls) {
+            if (!visited.has(impl.id) && (!noTests || !isTestFile(impl.file))) {
+              visited.add(impl.id);
+              nextFrontier.push(impl.id);
+              const implDepth = d + 1;
+              if (!levels[implDepth]) levels[implDepth] = [];
+              levels[implDepth].push({
+                name: impl.name,
+                kind: impl.kind,
+                file: impl.file,
+                line: impl.line,
+                viaImplements: true,
+              });
+              if (onVisit) onVisit({ ...impl, viaImplements: true }, c.id, implDepth);
+            }
+          }
+        }
+      }
+    }
+    frontier = nextFrontier;
+    if (frontier.length === 0) break;
+  }
+
+  return { totalDependents: visited.size - 1, levels };
+}
+
+export function impactAnalysisData(
+  file: string,
+  customDbPath: string,
+  opts: { noTests?: boolean } = {},
+) {
+  const db = openReadonlyOrFail(customDbPath);
+  try {
+    const noTests = opts.noTests || false;
+    const fileNodes = findFileNodes(db, `%${file}%`) as NodeRow[];
+    if (fileNodes.length === 0) {
+      return { file, sources: [], levels: {}, totalDependents: 0 };
+    }
+
+    const visited = new Set<number>();
+    const queue: number[] = [];
+    const levels = new Map<number, number>();
+
+    for (const fn of fileNodes) {
+      visited.add(fn.id);
+      queue.push(fn.id);
+      levels.set(fn.id, 0);
+    }
+
+    while (queue.length > 0) {
+      const current = queue.shift()!;
+      const level = levels.get(current)!;
+      const dependents = findImportDependents(db, current) as RelatedNodeRow[];
+      for (const dep of dependents) {
+        if (!visited.has(dep.id) && (!noTests || !isTestFile(dep.file))) {
+          visited.add(dep.id);
+          queue.push(dep.id);
+          levels.set(dep.id, level + 1);
+        }
+      }
+    }
+
+    const byLevel: Record<number, Array<{ file: string }>> = {};
+    for (const [id, level] of levels) {
+      if (level === 0) continue;
+      if (!byLevel[level]) byLevel[level] = [];
+      const node = findNodeById(db, id) as NodeRow | undefined;
+      if (node) byLevel[level].push({ file: node.file });
+    }
+
+    return {
+      file,
+      sources: fileNodes.map((f) => f.file),
+      levels: byLevel,
+      totalDependents: visited.size - fileNodes.length,
+    };
+  } finally {
+    db.close();
+  }
+}
+
+export function fnImpactData(
+  name: string,
+  customDbPath: string,
+  opts: {
+    depth?: number;
+    noTests?: boolean;
+    file?: string;
+    kind?: string;
+    includeImplementors?: boolean;
+    limit?: number;
+    offset?: number;
+    config?: any;
+  } = {},
+) {
+  const db = openReadonlyOrFail(customDbPath);
+  try {
+    const config = opts.config || loadConfig();
+    const maxDepth = opts.depth || config.analysis?.fnImpactDepth || 5;
+    const noTests = opts.noTests || false;
+    const hc = new Map();
+
+    const nodes = findMatchingNodes(db, name, { noTests, file: opts.file, kind: opts.kind });
+    if (nodes.length === 0) {
+      return { name, results: [] };
+    }
+
+    const includeImplementors = opts.includeImplementors !== false;
+
+    const results = nodes.map((node) => {
+      const { levels, totalDependents } = bfsTransitiveCallers(db, node.id, {
+        noTests,
+        maxDepth,
+        includeImplementors,
+      });
+      return {
+        ...normalizeSymbol(node, db, hc),
+        levels,
+        totalDependents,
+      };
+    });
+
+    const base = { name, results };
+    return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
+  } finally {
+    db.close();
+  }
+}

package/src/domain/analysis/impact.ts

@@ -0,0 +1,11 @@
+/**
+ * impact.ts — Re-export barrel for backward compatibility.
+ *
+ * The implementation has been split into focused modules:
+ * - fn-impact.ts: bfsTransitiveCallers, impactAnalysisData, fnImpactData
+ * - diff-impact.ts: diffImpactData and git diff analysis helpers
+ * - presentation/diff-impact-mermaid.ts: diffImpactMermaid (Mermaid diagram generation)
+ */
+
+export { diffImpactData } from './diff-impact.js';
+export { bfsTransitiveCallers, fnImpactData, impactAnalysisData } from './fn-impact.js';

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

@@ -3,17 +3,17 @@ import { isTestFile } from '../../infrastructure/test-filter.js';
 import { CORE_SYMBOL_KINDS } from '../../shared/kinds.js';
 import { normalizeSymbol } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
+import type { RelatedNodeRow } from '../../types.js';
 import { findMatchingNodes } from './symbol-lookup.js';
 
 /**
  * Find all concrete types implementing a given interface/trait.
- *
- * @param {string} name - Interface/trait name (partial match)
- * @param {string|undefined} customDbPath
- * @param {{ noTests?: boolean, file?: string, kind?: string, limit?: number, offset?: number }} opts
- * @returns {{ name: string, results: Array<{ name: string, kind: string, file: string, line: number, implementors: Array<{ name: string, kind: string, file: string, line: number }> }> }}
  */
-export function implementationsData(name, customDbPath, opts = {}) {
+export function implementationsData(
+  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;
@@ -30,7 +30,7 @@ export function implementationsData(name, customDbPath, opts = {}) {
     }
 
     const results = nodes.map((node) => {
-      let implementors = findImplementors(db, node.id);
+      let implementors = findImplementors(db, node.id) as RelatedNodeRow[];
       if (noTests) implementors = implementors.filter((n) => !isTestFile(n.file));
 
       return {
@@ -53,13 +53,12 @@ export function implementationsData(name, customDbPath, opts = {}) {
 
 /**
  * Find all interfaces/traits that a given class/struct implements.
- *
- * @param {string} name - Class/struct name (partial match)
- * @param {string|undefined} customDbPath
- * @param {{ noTests?: boolean, file?: string, kind?: string, limit?: number, offset?: number }} opts
- * @returns {{ name: string, results: Array<{ name: string, kind: string, file: string, line: number, interfaces: Array<{ name: string, kind: string, file: string, line: number }> }> }}
  */
-export function interfacesData(name, customDbPath, opts = {}) {
+export function interfacesData(
+  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;
@@ -76,7 +75,7 @@ export function interfacesData(name, customDbPath, opts = {}) {
     }
 
     const results = nodes.map((node) => {
-      let interfaces = findInterfaces(db, node.id);
+      let interfaces = findInterfaces(db, node.id) as RelatedNodeRow[];
       if (noTests) interfaces = interfaces.filter((n) => !isTestFile(n.file));
 
       return {

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,7 @@ export function moduleMapData(customDbPath, limit = 20, opts = {}) {
   }
 }
 
-export function statsData(customDbPath, opts = {}) {
+export function statsData(customDbPath: string, opts: { noTests?: boolean; config?: any } = {}) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;