feat: type analysis modules, parser WASM maps, extract canStripTypes (#554 follow-up)

src/db/index.js

@@ -56,6 +56,8 @@ export {
   getFileNodesAll,
   getFunctionNodeId,
   getImportEdges,
+  getLineCountForNode,
+  getMaxEndLineForFile,
   getNodeId,
   hasCfgTables,
   hasCoChanges,

src/db/repository/index.js

@@ -42,6 +42,8 @@ export {
   findNodesForTriage,
   findNodesWithFanIn,
   getFunctionNodeId,
+  getLineCountForNode,
+  getMaxEndLineForFile,
   getNodeId,
   iterateFunctionNodes,
   listFunctionNodes,

src/db/repository/nodes.js

@@ -297,3 +297,37 @@ export function findNodeByQualifiedName(db, qualifiedName, opts = {}) {
     'SELECT * FROM nodes WHERE qualified_name = ? ORDER BY file, line',
   ).all(qualifiedName);
 }
+
+// ─── Metric helpers ──────────────────────────────────────────────────────
+
+const _getLineCountForNodeStmt = new WeakMap();
+
+/**
+ * Get line_count from node_metrics for a given node.
+ * @param {object} db
+ * @param {number} nodeId
+ * @returns {{ line_count: number } | undefined}
+ */
+export function getLineCountForNode(db, nodeId) {
+  return cachedStmt(
+    _getLineCountForNodeStmt,
+    db,
+    'SELECT line_count FROM node_metrics WHERE node_id = ?',
+  ).get(nodeId);
+}
+
+const _getMaxEndLineForFileStmt = new WeakMap();
+
+/**
+ * Get the maximum end_line across all nodes in a file.
+ * @param {object} db
+ * @param {string} file
+ * @returns {{ max_end: number | null } | undefined}
+ */
+export function getMaxEndLineForFile(db, file) {
+  return cachedStmt(
+    _getMaxEndLineForFileStmt,
+    db,
+    'SELECT MAX(end_line) as max_end FROM nodes WHERE file = ?',
+  ).get(file);
+}

src/domain/analysis/brief.ts

@@ -0,0 +1,177 @@
+import type BetterSqlite3 from 'better-sqlite3';
+import {
+  findDistinctCallers,
+  findFileNodes,
+  findImportDependents,
+  findImportSources,
+  findImportTargets,
+  findNodesByFile,
+  openReadonlyOrFail,
+} from '../../db/index.js';
+import { loadConfig } from '../../infrastructure/config.js';
+import { isTestFile } from '../../infrastructure/test-filter.js';
+import type { ImportEdgeRow, NodeRow, RelatedNodeRow } from '../../types.js';
+
+/** Symbol kinds meaningful for a file brief — excludes parameters, properties, constants. */
+const BRIEF_KINDS = new Set([
+  'function',
+  'method',
+  'class',
+  'interface',
+  'type',
+  'struct',
+  'enum',
+  'trait',
+  'record',
+  'module',
+]);
+
+/**
+ * Compute file risk tier from symbol roles and max fan-in.
+ */
+function computeRiskTier(
+  symbols: Array<{ role: string | null; callerCount: number }>,
+  highThreshold = 10,
+  mediumThreshold = 3,
+): 'high' | 'medium' | 'low' {
+  let maxCallers = 0;
+  let hasCoreRole = false;
+  for (const s of symbols) {
+    if (s.callerCount > maxCallers) maxCallers = s.callerCount;
+    if (s.role === 'core') hasCoreRole = true;
+  }
+  if (maxCallers >= highThreshold || hasCoreRole) return 'high';
+  if (maxCallers >= mediumThreshold) return 'medium';
+  return 'low';
+}
+
+/**
+ * BFS to count transitive callers for a single node.
+ * Lightweight variant — only counts, does not collect details.
+ */
+function countTransitiveCallers(
+  db: BetterSqlite3.Database,
+  startId: number,
+  noTests: boolean,
+  maxDepth = 5,
+): number {
+  const visited = new Set([startId]);
+  let frontier = [startId];
+
+  for (let d = 1; d <= maxDepth; d++) {
+    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);
+        }
+      }
+    }
+    frontier = nextFrontier;
+    if (frontier.length === 0) break;
+  }
+
+  return visited.size - 1;
+}
+
+/**
+ * Count transitive file-level import dependents via BFS.
+ * Depth-bounded to match countTransitiveCallers and keep hook latency predictable.
+ */
+function countTransitiveImporters(
+  db: BetterSqlite3.Database,
+  fileNodeIds: number[],
+  noTests: boolean,
+  maxDepth = 5,
+): number {
+  const visited = new Set(fileNodeIds);
+  let frontier = [...fileNodeIds];
+
+  for (let d = 1; d <= maxDepth; d++) {
+    const nextFrontier: number[] = [];
+    for (const current of frontier) {
+      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);
+          nextFrontier.push(dep.id);
+        }
+      }
+    }
+    frontier = nextFrontier;
+    if (frontier.length === 0) break;
+  }
+
+  return visited.size - fileNodeIds.length;
+}
+
+/**
+ * Produce a token-efficient file brief: symbols with roles and caller counts,
+ * importer info with transitive count, and file risk tier.
+ */
+export function briefData(
+  file: string,
+  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;
+    const config = opts.config || loadConfig();
+    const callerDepth = config.analysis?.briefCallerDepth ?? 5;
+    const importerDepth = config.analysis?.briefImporterDepth ?? 5;
+    const highRiskCallers = config.analysis?.briefHighRiskCallers ?? 10;
+    const mediumRiskCallers = config.analysis?.briefMediumRiskCallers ?? 3;
+    const fileNodes = findFileNodes(db, `%${file}%`) as NodeRow[];
+    if (fileNodes.length === 0) {
+      return { file, results: [] };
+    }
+
+    const results = fileNodes.map((fn) => {
+      // Direct importers
+      let importedBy = findImportSources(db, fn.id) as ImportEdgeRow[];
+      if (noTests) importedBy = importedBy.filter((i) => !isTestFile(i.file));
+      const directImporters = [...new Set(importedBy.map((i) => i.file))];
+
+      // Transitive importer count
+      const totalImporterCount = countTransitiveImporters(db, [fn.id], noTests, importerDepth);
+
+      // Direct imports
+      let importsTo = findImportTargets(db, fn.id) as ImportEdgeRow[];
+      if (noTests) importsTo = importsTo.filter((i) => !isTestFile(i.file));
+
+      // Symbol definitions with roles and caller counts
+      const defs = (findNodesByFile(db, fn.file) as NodeRow[]).filter((d) =>
+        BRIEF_KINDS.has(d.kind),
+      );
+      const symbols = defs.map((d) => {
+        const callerCount = countTransitiveCallers(db, d.id, noTests, callerDepth);
+        return {
+          name: d.name,
+          kind: d.kind,
+          line: d.line,
+          role: d.role || null,
+          callerCount,
+        };
+      });
+
+      const riskTier = computeRiskTier(symbols, highRiskCallers, mediumRiskCallers);
+
+      return {
+        file: fn.file,
+        risk: riskTier,
+        imports: importsTo.map((i) => i.file),
+        importedBy: directImporters,
+        totalImporterCount,
+        symbols,
+      };
+    });
+
+    return { file, results };
+  } finally {
+    db.close();
+  }
+}