@optave/codegraph 3.3.0 → 3.4.0

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

@@ -10,6 +10,7 @@ import {
   findNodeById,
   openReadonlyOrFail,
 } from '../../db/index.js';
+import { cachedStmt } from '../../db/repository/cached-stmt.js';
 import { evaluateBoundaries } from '../../features/boundaries.js';
 import { coChangeForFiles } from '../../features/cochange.js';
 import { ownersForFiles } from '../../features/owners.js';
@@ -18,39 +19,70 @@ import { debug } from '../../infrastructure/logger.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, StmtCache } from '../../types.js';
 import { findMatchingNodes } from './symbol-lookup.js';
 
-// ─── Shared BFS: transitive callers ────────────────────────────────────
+const _defsStmtCache: StmtCache<NodeRow> = new WeakMap();
+
+// --- 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.
- *
- * @param {import('better-sqlite3').Database} db - Open read-only SQLite database handle (not a Repository)
- * @param {number} startId - Starting node ID
- * @param {{ noTests?: boolean, maxDepth?: number, includeImplementors?: boolean, onVisit?: (caller: object, parentId: number, depth: number) => void }} options
- * @returns {{ totalDependents: number, levels: Record<number, Array<{name:string, kind:string, file:string, line:number}>> }}
  */
 export function bfsTransitiveCallers(
-  db,
-  startId,
-  { noTests = false, maxDepth = 3, includeImplementors = true, onVisit } = {},
+  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 = {};
+  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 = [];
-  if (includeImplementors) {
-    const startNode = findNodeById(db, startId);
+  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);
+      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);
@@ -74,22 +106,22 @@ export function bfsTransitiveCallers(
     if (d === 1 && implNextFrontier.length > 0) {
       frontier = [...frontier, ...implNextFrontier];
     }
-    const nextFrontier = [];
+    const nextFrontier: number[] = [];
     for (const fid of frontier) {
-      const callers = findDistinctCallers(db, fid);
+      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 });
+          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 (includeImplementors && INTERFACE_LIKE_KINDS.has(c.kind)) {
-          const impls = findImplementors(db, c.id);
+        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);
@@ -116,18 +148,22 @@ export function bfsTransitiveCallers(
   return { totalDependents: visited.size - 1, levels };
 }
 
-export function impactAnalysisData(file, customDbPath, opts = {}) {
+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}%`);
+    const fileNodes = findFileNodes(db, `%${file}%`) as NodeRow[];
     if (fileNodes.length === 0) {
       return { file, sources: [], levels: {}, totalDependents: 0 };
     }
 
-    const visited = new Set();
-    const queue = [];
-    const levels = new Map();
+    const visited = new Set<number>();
+    const queue: number[] = [];
+    const levels = new Map<number, number>();
 
     for (const fn of fileNodes) {
       visited.add(fn.id);
@@ -136,9 +172,9 @@ export function impactAnalysisData(file, customDbPath, opts = {}) {
     }
 
     while (queue.length > 0) {
-      const current = queue.shift();
-      const level = levels.get(current);
-      const dependents = findImportDependents(db, current);
+      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);
@@ -148,11 +184,11 @@ export function impactAnalysisData(file, customDbPath, opts = {}) {
       }
     }
 
-    const byLevel = {};
+    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);
+      const node = findNodeById(db, id) as NodeRow | undefined;
       if (node) byLevel[level].push({ file: node.file });
     }
 
@@ -167,7 +203,21 @@ export function impactAnalysisData(file, customDbPath, opts = {}) {
   }
 }
 
-export function fnImpactData(name, customDbPath, opts = {}) {
+export function fnImpactData(
+  name: string,
+  customDbPath: string,
+  opts: {
+    depth?: number;
+    noTests?: boolean;
+    file?: string;
+    kind?: string;
+    includeImplementors?: boolean;
+    limit?: number;
+    offset?: number;
+    // biome-ignore lint/suspicious/noExplicitAny: config shape is dynamic
+    config?: any;
+  } = {},
+) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const config = opts.config || loadConfig();
@@ -202,16 +252,13 @@ export function fnImpactData(name, customDbPath, opts = {}) {
   }
 }
 
-// ─── diffImpactData helpers ─────────────────────────────────────────────
+// --- diffImpactData helpers ---
 
 /**
  * Walk up from repoRoot until a .git directory is found.
  * Returns true if a git root exists, false otherwise.
- *
- * @param {string} repoRoot
- * @returns {boolean}
  */
-function findGitRoot(repoRoot) {
+function findGitRoot(repoRoot: string): boolean {
   let checkDir = repoRoot;
   while (checkDir) {
     if (fs.existsSync(path.join(checkDir, '.git'))) {
@@ -227,12 +274,11 @@ function findGitRoot(repoRoot) {
 /**
  * Execute git diff and return the raw output string.
  * Returns `{ output: string }` on success or `{ error: string }` on failure.
- *
- * @param {string} repoRoot
- * @param {{ staged?: boolean, ref?: string }} opts
- * @returns {{ output: string } | { error: string }}
  */
-function runGitDiff(repoRoot, opts) {
+function runGitDiff(
+  repoRoot: string,
+  opts: { staged?: boolean; ref?: string },
+): { output: string; error?: never } | { error: string; output?: never } {
   try {
     const args = opts.staged
       ? ['diff', '--cached', '--unified=0', '--no-color']
@@ -244,21 +290,18 @@ function runGitDiff(repoRoot, opts) {
       stdio: ['pipe', 'pipe', 'pipe'],
     });
     return { output };
-  } catch (e) {
-    return { error: `Failed to run git diff: ${e.message}` };
+  } catch (e: unknown) {
+    return { error: `Failed to run git diff: ${(e as Error).message}` };
   }
 }
 
 /**
  * Parse raw git diff output into a changedRanges map and newFiles set.
- *
- * @param {string} diffOutput
- * @returns {{ changedRanges: Map<string, Array<{start: number, end: number}>>, newFiles: Set<string> }}
  */
-function parseGitDiff(diffOutput) {
-  const changedRanges = new Map();
-  const newFiles = new Set();
-  let currentFile = null;
+function parseGitDiff(diffOutput: string) {
+  const changedRanges = new Map<string, Array<{ start: number; end: number }>>();
+  const newFiles = new Set<string>();
+  let currentFile: string | null = null;
   let prevIsDevNull = false;
 
   for (const line of diffOutput.split('\n')) {
@@ -272,17 +315,17 @@ function parseGitDiff(diffOutput) {
     }
     const fileMatch = line.match(/^\+\+\+ b\/(.+)/);
     if (fileMatch) {
-      currentFile = fileMatch[1];
+      currentFile = fileMatch[1]!;
       if (!changedRanges.has(currentFile)) changedRanges.set(currentFile, []);
-      if (prevIsDevNull) newFiles.add(currentFile);
+      if (prevIsDevNull) newFiles.add(currentFile!);
       prevIsDevNull = false;
       continue;
     }
     const hunkMatch = line.match(/^@@ .+ \+(\d+)(?:,(\d+))? @@/);
     if (hunkMatch && currentFile) {
-      const start = parseInt(hunkMatch[1], 10);
+      const start = parseInt(hunkMatch[1]!, 10);
       const count = parseInt(hunkMatch[2] || '1', 10);
-      changedRanges.get(currentFile).push({ start, end: start + count - 1 });
+      changedRanges.get(currentFile)!.push({ start, end: start + count - 1 });
     }
   }
 
@@ -291,24 +334,24 @@ function parseGitDiff(diffOutput) {
 
 /**
  * Find all function/method/class nodes whose line ranges overlap any changed range.
- *
- * @param {import('better-sqlite3').Database} db
- * @param {Map<string, Array<{start: number, end: number}>} changedRanges
- * @param {boolean} noTests
- * @returns {Array<object>}
  */
-function findAffectedFunctions(db, changedRanges, noTests) {
-  const affectedFunctions = [];
+function findAffectedFunctions(
+  db: BetterSqlite3Database,
+  changedRanges: Map<string, Array<{ start: number; end: number }>>,
+  noTests: boolean,
+): NodeRow[] {
+  const affectedFunctions: NodeRow[] = [];
+  const defsStmt = cachedStmt(
+    _defsStmtCache,
+    db,
+    `SELECT * FROM nodes WHERE file = ? AND kind IN ('function', 'method', 'class') ORDER BY line`,
+  );
   for (const [file, ranges] of changedRanges) {
     if (noTests && isTestFile(file)) continue;
-    const defs = db
-      .prepare(
-        `SELECT * FROM nodes WHERE file = ? AND kind IN ('function', 'method', 'class') ORDER BY line`,
-      )
-      .all(file);
+    const defs = defsStmt.all(file) as NodeRow[];
     for (let i = 0; i < defs.length; i++) {
-      const def = defs[i];
-      const endLine = def.end_line || (defs[i + 1] ? defs[i + 1].line - 1 : 999999);
+      const def = defs[i]!;
+      const endLine = def.end_line || (defs[i + 1] ? defs[i + 1]!.line - 1 : 999999);
       for (const range of ranges) {
         if (range.start <= endLine && range.end >= def.line) {
           affectedFunctions.push(def);
@@ -322,24 +365,18 @@ function findAffectedFunctions(db, changedRanges, noTests) {
 
 /**
  * Run BFS per affected function, collecting per-function results and the full affected set.
- *
- * @param {import('better-sqlite3').Database} db
- * @param {Array<object>} affectedFunctions
- * @param {boolean} noTests
- * @param {number} maxDepth
- * @returns {{ functionResults: Array<object>, allAffected: Set<string> }}
  */
 function buildFunctionImpactResults(
-  db,
-  affectedFunctions,
-  noTests,
-  maxDepth,
+  db: BetterSqlite3Database,
+  affectedFunctions: NodeRow[],
+  noTests: boolean,
+  maxDepth: number,
   includeImplementors = true,
 ) {
-  const allAffected = new Set();
+  const allAffected = new Set<string>();
   const functionResults = affectedFunctions.map((fn) => {
-    const edges = [];
-    const idToKey = new Map();
+    const edges: Array<{ from: string; to: string }> = [];
+    const idToKey = new Map<number, string>();
     idToKey.set(fn.id, `${fn.file}::${fn.name}:${fn.line}`);
 
     const { levels, totalDependents } = bfsTransitiveCallers(db, fn.id, {
@@ -350,7 +387,7 @@ function buildFunctionImpactResults(
         allAffected.add(`${c.file}:${c.name}`);
         const callerKey = `${c.file}::${c.name}:${c.line}`;
         idToKey.set(c.id, callerKey);
-        edges.push({ from: idToKey.get(parentId), to: callerKey });
+        edges.push({ from: idToKey.get(parentId)!, to: callerKey });
       },
     });
 
@@ -371,14 +408,13 @@ function buildFunctionImpactResults(
 /**
  * Look up historically co-changed files for the set of changed files.
  * Returns an empty array if the co_changes table is unavailable.
- *
- * @param {import('better-sqlite3').Database} db
- * @param {Map<string, any>} changedRanges
- * @param {Set<string>} affectedFiles
- * @param {boolean} noTests
- * @returns {Array<object>}
  */
-function lookupCoChanges(db, changedRanges, affectedFiles, noTests) {
+function lookupCoChanges(
+  db: BetterSqlite3Database,
+  changedRanges: Map<string, unknown>,
+  affectedFiles: Set<string>,
+  noTests: boolean,
+) {
   try {
     db.prepare('SELECT 1 FROM co_changes LIMIT 1').get();
     const changedFilesList = [...changedRanges.keys()];
@@ -387,9 +423,9 @@ function lookupCoChanges(db, changedRanges, affectedFiles, noTests) {
       limit: 20,
       noTests,
     });
-    return coResults.filter((r) => !affectedFiles.has(r.file));
-  } catch (e) {
-    debug(`co_changes lookup skipped: ${e.message}`);
+    return coResults.filter((r: { file: string }) => !affectedFiles.has(r.file));
+  } catch (e: unknown) {
+    debug(`co_changes lookup skipped: ${(e as Error).message}`);
     return [];
   }
 }
@@ -397,13 +433,12 @@ function lookupCoChanges(db, changedRanges, affectedFiles, noTests) {
 /**
  * Look up CODEOWNERS for changed and affected files.
  * Returns null if no owners are found or lookup fails.
- *
- * @param {Map<string, any>} changedRanges
- * @param {Set<string>} affectedFiles
- * @param {string} repoRoot
- * @returns {{ owners: object, affectedOwners: Array<string>, suggestedReviewers: Array<string> } | null}
  */
-function lookupOwnership(changedRanges, affectedFiles, repoRoot) {
+function lookupOwnership(
+  changedRanges: Map<string, unknown>,
+  affectedFiles: Set<string>,
+  repoRoot: string,
+) {
   try {
     const allFilePaths = [...new Set([...changedRanges.keys(), ...affectedFiles])];
     const ownerResult = ownersForFiles(allFilePaths, repoRoot);
@@ -415,8 +450,8 @@ function lookupOwnership(changedRanges, affectedFiles, repoRoot) {
       };
     }
     return null;
-  } catch (e) {
-    debug(`CODEOWNERS lookup skipped: ${e.message}`);
+  } catch (e: unknown) {
+    debug(`CODEOWNERS lookup skipped: ${(e as Error).message}`);
     return null;
   }
 }
@@ -424,15 +459,15 @@ function lookupOwnership(changedRanges, affectedFiles, repoRoot) {
 /**
  * Check manifesto boundary violations scoped to the changed files.
  * Returns `{ boundaryViolations, boundaryViolationCount }`.
- *
- * @param {import('better-sqlite3').Database} db
- * @param {Map<string, any>} changedRanges
- * @param {boolean} noTests
- * @param {object} opts — full diffImpactData opts (may contain `opts.config`)
- * @param {string} repoRoot
- * @returns {{ boundaryViolations: Array<object>, boundaryViolationCount: number }}
  */
-function checkBoundaryViolations(db, changedRanges, noTests, opts, repoRoot) {
+function checkBoundaryViolations(
+  db: BetterSqlite3Database,
+  changedRanges: Map<string, unknown>,
+  noTests: boolean,
+  // biome-ignore lint/suspicious/noExplicitAny: opts shape varies by caller
+  opts: any,
+  repoRoot: string,
+) {
   try {
     const cfg = opts.config || loadConfig(repoRoot);
     const boundaryConfig = cfg.manifesto?.boundaries;
@@ -446,19 +481,32 @@ function checkBoundaryViolations(db, changedRanges, noTests, opts, repoRoot) {
         boundaryViolationCount: result.violationCount,
       };
     }
-  } catch (e) {
-    debug(`boundary check skipped: ${e.message}`);
+  } catch (e: unknown) {
+    debug(`boundary check skipped: ${(e as Error).message}`);
   }
   return { boundaryViolations: [], boundaryViolationCount: 0 };
 }
 
-// ─── diffImpactData ─────────────────────────────────────────────────────
+// --- diffImpactData ---
 
 /**
  * Fix #2: Shell injection vulnerability.
  * Uses execFileSync instead of execSync to prevent shell interpretation of user input.
  */
-export function diffImpactData(customDbPath, opts = {}) {
+export function diffImpactData(
+  customDbPath: string,
+  opts: {
+    noTests?: boolean;
+    depth?: number;
+    staged?: boolean;
+    ref?: string;
+    includeImplementors?: boolean;
+    limit?: number;
+    offset?: number;
+    // biome-ignore lint/suspicious/noExplicitAny: config shape is dynamic
+    config?: any;
+  } = {},
+) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;
@@ -473,7 +521,7 @@ export function diffImpactData(customDbPath, opts = {}) {
     }
 
     const gitResult = runGitDiff(repoRoot, opts);
-    if (gitResult.error) return { error: gitResult.error };
+    if ('error' in gitResult) return { error: gitResult.error };
 
     if (!gitResult.output.trim()) {
       return {
@@ -507,8 +555,8 @@ export function diffImpactData(customDbPath, opts = {}) {
       includeImplementors,
     );
 
-    const affectedFiles = new Set();
-    for (const key of allAffected) affectedFiles.add(key.split(':')[0]);
+    const affectedFiles = new Set<string>();
+    for (const key of allAffected) affectedFiles.add(key.split(':')[0]!);
 
     const historicallyCoupled = lookupCoChanges(db, changedRanges, affectedFiles, noTests);
     const ownership = lookupOwnership(changedRanges, affectedFiles, repoRoot);
@@ -544,9 +592,23 @@ export function diffImpactData(customDbPath, opts = {}) {
   }
 }
 
-export function diffImpactMermaid(customDbPath, opts = {}) {
-  const data = diffImpactData(customDbPath, opts);
-  if (data.error) return data.error;
+export function diffImpactMermaid(
+  customDbPath: string,
+  opts: {
+    noTests?: boolean;
+    depth?: number;
+    staged?: boolean;
+    ref?: string;
+    includeImplementors?: boolean;
+    limit?: number;
+    offset?: number;
+    // biome-ignore lint/suspicious/noExplicitAny: config shape is dynamic
+    config?: any;
+  } = {},
+): string {
+  // biome-ignore lint/suspicious/noExplicitAny: paginateResult returns dynamic shape
+  const data: any = diffImpactData(customDbPath, opts);
+  if ('error' in data) return data.error as string;
   if (data.changedFiles === 0 || data.affectedFunctions.length === 0) {
     return 'flowchart TB\n    none["No impacted functions detected"]';
   }
@@ -556,31 +618,31 @@ export function diffImpactMermaid(customDbPath, opts = {}) {
 
   // Assign stable Mermaid node IDs
   let nodeCounter = 0;
-  const nodeIdMap = new Map();
-  const nodeLabels = new Map();
-  function nodeId(key, label) {
+  const nodeIdMap = new Map<string, string>();
+  const nodeLabels = new Map<string, string>();
+  function nodeId(key: string, label?: string): string {
     if (!nodeIdMap.has(key)) {
       nodeIdMap.set(key, `n${nodeCounter++}`);
       if (label) nodeLabels.set(key, label);
     }
-    return nodeIdMap.get(key);
+    return nodeIdMap.get(key)!;
   }
 
   // Register all nodes (changed functions + their callers)
   for (const fn of data.affectedFunctions) {
     nodeId(`${fn.file}::${fn.name}:${fn.line}`, fn.name);
     for (const callers of Object.values(fn.levels || {})) {
-      for (const c of callers) {
+      for (const c of callers as Array<{ name: string; file: string; line: number }>) {
         nodeId(`${c.file}::${c.name}:${c.line}`, c.name);
       }
     }
   }
 
   // Collect all edges and determine blast radius
-  const allEdges = new Set();
-  const edgeFromNodes = new Set();
-  const edgeToNodes = new Set();
-  const changedKeys = new Set();
+  const allEdges = new Set<string>();
+  const edgeFromNodes = new Set<string>();
+  const edgeToNodes = new Set<string>();
+  const changedKeys = new Set<string>();
 
   for (const fn of data.affectedFunctions) {
     changedKeys.add(`${fn.file}::${fn.name}:${fn.line}`);
@@ -595,7 +657,7 @@ export function diffImpactMermaid(customDbPath, opts = {}) {
   }
 
   // Blast radius: caller nodes that are never a source (leaf nodes of the impact tree)
-  const blastRadiusKeys = new Set();
+  const blastRadiusKeys = new Set<string>();
   for (const key of edgeToNodes) {
     if (!edgeFromNodes.has(key) && !changedKeys.has(key)) {
       blastRadiusKeys.add(key);
@@ -603,7 +665,7 @@ export function diffImpactMermaid(customDbPath, opts = {}) {
   }
 
   // Intermediate callers: not changed, not blast radius
-  const intermediateKeys = new Set();
+  const intermediateKeys = new Set<string>();
   for (const key of edgeToNodes) {
     if (!changedKeys.has(key) && !blastRadiusKeys.has(key)) {
       intermediateKeys.add(key);
@@ -611,10 +673,10 @@ export function diffImpactMermaid(customDbPath, opts = {}) {
   }
 
   // Group changed functions by file
-  const fileGroups = new Map();
+  const fileGroups = new Map<string, typeof data.affectedFunctions>();
   for (const fn of data.affectedFunctions) {
     if (!fileGroups.has(fn.file)) fileGroups.set(fn.file, []);
-    fileGroups.get(fn.file).push(fn);
+    fileGroups.get(fn.file)!.push(fn);
   }
 
   // Emit changed-file subgraphs
@@ -651,7 +713,7 @@ export function diffImpactMermaid(customDbPath, opts = {}) {
 
   // Emit edges (impact flows from changed fn toward callers)
   for (const edgeKey of allEdges) {
-    const [from, to] = edgeKey.split('|');
+    const [from, to] = edgeKey.split('|') as [string, string];
     lines.push(`    ${nodeIdMap.get(from)} --> ${nodeIdMap.get(to)}`);
   }
 

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 {