@optave/codegraph 3.11.0 → 3.11.1

package/src/features/cfg.ts

@@ -18,7 +18,13 @@ import {
 } from '../db/index.js';
 import { debug, info } from '../infrastructure/logger.js';
 import { paginateResult } from '../shared/paginate.js';
-import type { BetterSqlite3Database, Definition, NodeRow, TreeSitterNode } from '../types.js';
+import type {
+  BetterSqlite3Database,
+  CfgRulesConfig,
+  Definition,
+  NodeRow,
+  TreeSitterNode,
+} from '../types.js';
 import { findNodes } from './shared/find-nodes.js';
 
 export { _makeCfgRules as makeCfgRules, CFG_RULES };
@@ -122,9 +128,8 @@ async function initCfgParsers(
   let getParserFn: unknown = null;
 
   if (needsFallback) {
-    const { createParsers } = await import('../domain/parser.js');
-    parsers = await createParsers();
     const mod = await import('../domain/parser.js');
+    parsers = await mod.createParsers();
     getParserFn = mod.getParser;
   }
 
@@ -187,7 +192,7 @@ interface VisitorCfgResult {
 
 function buildVisitorCfgMap(
   tree: { rootNode: TreeSitterNode } | null | undefined,
-  cfgRules: unknown,
+  cfgRules: CfgRulesConfig,
   symbols: FileSymbols,
   langId: string,
 ): Map<number, VisitorCfgResult[]> | null {
@@ -203,9 +208,8 @@ function buildVisitorCfgMap(
   if (!needsVisitor) return null;
 
   const visitor = createCfgVisitor(cfgRules);
-  const typedRules = cfgRules as { functionNodes: string[] };
   const walkerOpts = {
-    functionNodeTypes: new Set(typedRules.functionNodes),
+    functionNodeTypes: new Set(cfgRules.functionNodes),
     nestingNodeTypes: new Set<string>(),
     getFunctionName: (node: TreeSitterNode) => {
       const nameNode = node.childForFieldName?.('name');
@@ -365,79 +369,91 @@ function persistVisitorFileCfg(
   return count;
 }
 
-export async function buildCFGData(
+/**
+ * Build a single native bulk-insert entry for one definition.
+ * Returns null when the def has no CFG blocks or no associated node row.
+ */
+function buildNativeCfgEntry(
   db: BetterSqlite3Database,
-  fileSymbols: Map<string, FileSymbols>,
-  rootDir: string,
-  engineOpts?: {
-    nativeDb?: { bulkInsertCfg?(entries: Array<Record<string, unknown>>): number };
-    suspendJsDb?: () => void;
-    resumeJsDb?: () => void;
-  },
-): Promise<void> {
-  // Fast path: when all function/method defs already have native CFG data,
-  // skip WASM parser init, tree parsing, and JS visitor entirely — just persist.
-  const allNative = allCfgNative(fileSymbols);
+  def: Definition,
+  relPath: string,
+): Record<string, unknown> | null {
+  if (def.kind !== 'function' && def.kind !== 'method') return null;
+  if (!def.line) return null;
+
+  const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
+  if (!nodeId) return null;
+
+  const cfg = def.cfg as { blocks?: CfgBuildBlock[]; edges?: CfgBuildEdge[] } | undefined;
+  if (!cfg?.blocks?.length) return null;
+
+  return {
+    nodeId,
+    blocks: cfg.blocks.map((b) => ({
+      index: b.index,
+      blockType: b.type,
+      startLine: b.startLine ?? undefined,
+      endLine: b.endLine ?? undefined,
+      label: b.label ?? undefined,
+    })),
+    edges: (cfg.edges || []).map((e) => ({
+      sourceIndex: e.sourceIndex,
+      targetIndex: e.targetIndex,
+      kind: e.kind,
+    })),
+  };
+}
 
-  // ── Native bulk-insert fast path ──────────────────────────────────────
-  // The Rust bulkInsertCfg handles delete-before-insert atomically on a
-  // single rusqlite connection, so there is no dual-connection WAL conflict.
+/**
+ * Native bulk-insert fast path. The Rust bulkInsertCfg handles
+ * delete-before-insert atomically on a single rusqlite connection, so there
+ * is no dual-connection WAL conflict. Returns true if this path handled the
+ * request (caller should return early); false to fall through to WASM/JS.
+ */
+function tryNativeBulkInsertCfg(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, FileSymbols>,
+  engineOpts:
+    | {
+        nativeDb?: { bulkInsertCfg?(entries: Array<Record<string, unknown>>): number };
+        suspendJsDb?: () => void;
+        resumeJsDb?: () => void;
+      }
+    | undefined,
+): boolean {
   const nativeDb = engineOpts?.nativeDb;
-  if (allNative && nativeDb?.bulkInsertCfg) {
-    const entries: Array<Record<string, unknown>> = [];
-    for (const [relPath, symbols] of fileSymbols) {
-      const ext = path.extname(relPath).toLowerCase();
-      if (!CFG_EXTENSIONS.has(ext)) continue;
+  if (!nativeDb?.bulkInsertCfg) return false;
 
-      for (const def of symbols.definitions) {
-        if (def.kind !== 'function' && def.kind !== 'method') continue;
-        if (!def.line) continue;
-
-        const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
-        if (!nodeId) continue;
-
-        const cfg = def.cfg as { blocks?: CfgBuildBlock[]; edges?: CfgBuildEdge[] } | undefined;
-        if (!cfg?.blocks?.length) continue;
-
-        entries.push({
-          nodeId,
-          blocks: cfg.blocks.map((b) => ({
-            index: b.index,
-            blockType: b.type,
-            startLine: b.startLine ?? undefined,
-            endLine: b.endLine ?? undefined,
-            label: b.label ?? undefined,
-          })),
-          edges: (cfg.edges || []).map((e) => ({
-            sourceIndex: e.sourceIndex,
-            targetIndex: e.targetIndex,
-            kind: e.kind,
-          })),
-        });
-      }
-    }
+  const entries: Array<Record<string, unknown>> = [];
+  for (const [relPath, symbols] of fileSymbols) {
+    const ext = path.extname(relPath).toLowerCase();
+    if (!CFG_EXTENSIONS.has(ext)) continue;
 
-    if (entries.length > 0) {
-      let inserted = 0;
-      try {
-        engineOpts?.suspendJsDb?.();
-        inserted = nativeDb.bulkInsertCfg(entries);
-      } finally {
-        engineOpts?.resumeJsDb?.();
-      }
-      info(`CFG (native bulk): ${inserted} functions analyzed`);
+    for (const def of symbols.definitions) {
+      const entry = buildNativeCfgEntry(db, def, relPath);
+      if (entry) entries.push(entry);
     }
-    return;
   }
 
-  const extToLang = buildExtToLangMap();
-  let parsers: unknown = null;
-  let getParserFn: unknown = null;
-
-  if (!allNative) {
-    ({ parsers, getParserFn } = await initCfgParsers(fileSymbols));
+  if (entries.length > 0) {
+    let inserted = 0;
+    try {
+      engineOpts?.suspendJsDb?.();
+      inserted = nativeDb.bulkInsertCfg(entries);
+    } finally {
+      engineOpts?.resumeJsDb?.();
+    }
+    info(`CFG (native bulk): ${inserted} functions analyzed`);
   }
+  return true;
+}
 
+interface CfgInsertStatements {
+  insertBlock: ReturnType<BetterSqlite3Database['prepare']>;
+  insertEdge: ReturnType<BetterSqlite3Database['prepare']>;
+}
+
+function prepareCfgInsertStatements(db: BetterSqlite3Database): CfgInsertStatements {
   const insertBlock = db.prepare(
     `INSERT INTO cfg_blocks (function_node_id, block_index, block_type, start_line, end_line, label)
      VALUES (?, ?, ?, ?, ?, ?)`,
@@ -446,15 +462,31 @@ export async function buildCFGData(
     `INSERT INTO cfg_edges (function_node_id, source_block_id, target_block_id, kind)
      VALUES (?, ?, ?, ?)`,
   );
-  let analyzed = 0;
+  return { insertBlock, insertEdge };
+}
 
+/**
+ * Persist CFG for every CFG-eligible file inside a single transaction.
+ * Dispatches to native fast path or visitor path per file.
+ */
+function persistAllFileCfgs(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, FileSymbols>,
+  rootDir: string,
+  allNative: boolean,
+  extToLang: Map<string, string>,
+  parsers: unknown,
+  getParserFn: unknown,
+  stmts: CfgInsertStatements,
+): number {
+  let analyzed = 0;
   const tx = db.transaction(() => {
     for (const [relPath, symbols] of fileSymbols) {
       const ext = path.extname(relPath).toLowerCase();
       if (!CFG_EXTENSIONS.has(ext)) continue;
 
       if (allNative && !symbols._tree) {
-        analyzed += persistNativeFileCfg(db, symbols, relPath, insertBlock, insertEdge);
+        analyzed += persistNativeFileCfg(db, symbols, relPath, stmts.insertBlock, stmts.insertEdge);
         continue;
       }
 
@@ -466,13 +498,52 @@ export async function buildCFGData(
         extToLang,
         parsers,
         getParserFn,
-        insertBlock,
-        insertEdge,
+        stmts.insertBlock,
+        stmts.insertEdge,
       );
     }
   });
-
   tx();
+  return analyzed;
+}
+
+export async function buildCFGData(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, FileSymbols>,
+  rootDir: string,
+  engineOpts?: {
+    nativeDb?: { bulkInsertCfg?(entries: Array<Record<string, unknown>>): number };
+    suspendJsDb?: () => void;
+    resumeJsDb?: () => void;
+  },
+): Promise<void> {
+  // Fast path: when all function/method defs already have native CFG data,
+  // skip WASM parser init, tree parsing, and JS visitor entirely — just persist.
+  const allNative = allCfgNative(fileSymbols);
+
+  if (allNative && tryNativeBulkInsertCfg(db, fileSymbols, engineOpts)) {
+    return;
+  }
+
+  const extToLang = buildExtToLangMap();
+  let parsers: unknown = null;
+  let getParserFn: unknown = null;
+
+  if (!allNative) {
+    ({ parsers, getParserFn } = await initCfgParsers(fileSymbols));
+  }
+
+  const stmts = prepareCfgInsertStatements(db);
+  const analyzed = persistAllFileCfgs(
+    db,
+    fileSymbols,
+    rootDir,
+    allNative,
+    extToLang,
+    parsers,
+    getParserFn,
+    stmts,
+  );
 
   if (analyzed > 0) {
     info(`CFG: ${analyzed} functions analyzed`);

package/src/features/check.ts

@@ -22,6 +22,29 @@ interface ParsedDiff {
   newFiles: Set<string>;
 }
 
+const HUNK_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+const NEW_FILE_RE = /^\+\+\+ b\/(.+)/;
+
+function pushHunkRanges(
+  line: string,
+  currentFile: string,
+  changedRanges: Map<string, DiffRange[]>,
+  oldRanges: Map<string, DiffRange[]>,
+): void {
+  const hunkMatch = line.match(HUNK_RE);
+  if (!hunkMatch) return;
+  const oldStart = parseInt(hunkMatch[1]!, 10);
+  const oldCount = parseInt(hunkMatch[2] || '1', 10);
+  if (oldCount > 0) {
+    oldRanges.get(currentFile)!.push({ start: oldStart, end: oldStart + oldCount - 1 });
+  }
+  const newStart = parseInt(hunkMatch[3]!, 10);
+  const newCount = parseInt(hunkMatch[4] || '1', 10);
+  if (newCount > 0) {
+    changedRanges.get(currentFile)!.push({ start: newStart, end: newStart + newCount - 1 });
+  }
+}
+
 export function parseDiffOutput(diffOutput: string): ParsedDiff {
   const changedRanges = new Map<string, DiffRange[]>();
   const oldRanges = new Map<string, DiffRange[]>();
@@ -38,7 +61,7 @@ export function parseDiffOutput(diffOutput: string): ParsedDiff {
       prevIsDevNull = false;
       continue;
     }
-    const fileMatch = line.match(/^\+\+\+ b\/(.+)/);
+    const fileMatch = line.match(NEW_FILE_RE);
     if (fileMatch) {
       currentFile = fileMatch[1]!;
       if (!changedRanges.has(currentFile)) changedRanges.set(currentFile, []);
@@ -47,19 +70,7 @@ export function parseDiffOutput(diffOutput: string): ParsedDiff {
       prevIsDevNull = false;
       continue;
     }
-    const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
-    if (hunkMatch && currentFile) {
-      const oldStart = parseInt(hunkMatch[1]!, 10);
-      const oldCount = parseInt(hunkMatch[2] || '1', 10);
-      if (oldCount > 0) {
-        oldRanges.get(currentFile)!.push({ start: oldStart, end: oldStart + oldCount - 1 });
-      }
-      const newStart = parseInt(hunkMatch[3]!, 10);
-      const newCount = parseInt(hunkMatch[4] || '1', 10);
-      if (newCount > 0) {
-        changedRanges.get(currentFile)!.push({ start: newStart, end: newStart + newCount - 1 });
-      }
-    }
+    if (currentFile) pushHunkRanges(line, currentFile, changedRanges, oldRanges);
   }
   return { changedRanges, oldRanges, newFiles };
 }
@@ -96,6 +107,26 @@ interface BlastRadiusResult {
   violations: BlastRadiusViolation[];
 }
 
+type DefRow = {
+  id: number;
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  end_line: number | null;
+};
+
+function rangesOverlap(defLine: number, endLine: number, ranges: DiffRange[]): boolean {
+  for (const range of ranges) {
+    if (range.start <= endLine && range.end >= defLine) return true;
+  }
+  return false;
+}
+
+function defEndLine(def: DefRow, nextDef: DefRow | undefined): number {
+  return def.end_line || (nextDef ? nextDef.line - 1 : 999999);
+}
+
 export function checkMaxBlastRadius(
   db: BetterSqlite3Database,
   changedRanges: Map<string, DiffRange[]>,
@@ -105,34 +136,18 @@ export function checkMaxBlastRadius(
 ): BlastRadiusResult {
   const violations: BlastRadiusViolation[] = [];
   let maxFound = 0;
+  const defsStmt = db.prepare(
+    `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) as Array<{
-      id: number;
-      name: string;
-      kind: string;
-      file: string;
-      line: number;
-      end_line: number | null;
-    }>;
+    const defs = defsStmt.all(file) as DefRow[];
 
     for (let i = 0; i < defs.length; i++) {
       const def = defs[i]!;
-      const nextDef = defs[i + 1];
-      const endLine = def.end_line || (nextDef ? nextDef.line - 1 : 999999);
-      let overlaps = false;
-      for (const range of ranges) {
-        if (range.start <= endLine && range.end >= def.line) {
-          overlaps = true;
-          break;
-        }
-      }
-      if (!overlaps) continue;
+      const endLine = defEndLine(def, defs[i + 1]);
+      if (!rangesOverlap(def.line, endLine, ranges)) continue;
 
       const { totalDependents: totalCallers } = bfsTransitiveCallers(db, def.id, {
         noTests,
@@ -364,11 +379,13 @@ function runPredicates(
   return predicates;
 }
 
-const EMPTY_CHECK: CheckResult = {
-  predicates: [],
-  summary: { total: 0, passed: 0, failed: 0, changedFiles: 0, newFiles: 0 },
-  passed: true,
-};
+function makeEmptyCheck(): CheckResult {
+  return {
+    predicates: [],
+    summary: { total: 0, passed: 0, failed: 0, changedFiles: 0, newFiles: 0 },
+    passed: true,
+  };
+}
 
 export function checkData(customDbPath: string | undefined, opts: CheckOpts = {}): CheckResult {
   const db = openReadonlyOrFail(customDbPath);
@@ -394,10 +411,10 @@ export function checkData(customDbPath: string | undefined, opts: CheckOpts = {}
       return { error: `Failed to run git diff: ${(e as Error).message}` };
     }
 
-    if (!diffOutput.trim()) return EMPTY_CHECK;
+    if (!diffOutput.trim()) return makeEmptyCheck();
 
     const diff = parseDiffOutput(diffOutput);
-    if (diff.changedRanges.size === 0) return EMPTY_CHECK;
+    if (diff.changedRanges.size === 0) return makeEmptyCheck();
 
     const predicates = runPredicates(db, diff, flags, repoRoot, noTests, maxDepth);
 

package/src/features/cochange.ts

@@ -137,77 +137,50 @@ export function computeCoChanges(
   return { pairs: results, fileCommitCounts };
 }
 
-export function analyzeCoChanges(
-  customDbPath?: string,
-  opts: {
-    since?: string;
-    minSupport?: number;
-    maxFilesPerCommit?: number;
-    full?: boolean;
-  } = {},
-):
-  | { pairsFound: number; commitsScanned: number; since: string; minSupport: number }
-  | { error: string } {
-  const dbPath = findDbPath(customDbPath);
-  const db = openDb(dbPath);
-  initSchema(db);
-
-  const repoRoot = path.resolve(path.dirname(dbPath), '..');
-
-  if (!fs.existsSync(path.join(repoRoot, '.git'))) {
-    closeDb(db);
-    return { error: `Not a git repository: ${repoRoot}` };
-  }
-
-  const since = opts.since || '1 year ago';
-  const minSupport = opts.minSupport ?? 3;
-  const maxFilesPerCommit = opts.maxFilesPerCommit ?? 50;
-
-  // Check for incremental state
-  let afterSha: string | null = null;
-  if (!opts.full) {
-    try {
-      const row = db
-        .prepare<{ value: string }>(
-          "SELECT value FROM co_change_meta WHERE key = 'last_analyzed_commit'",
-        )
-        .get();
-      if (row) afterSha = row.value;
-    } catch {
-      /* table may not exist yet */
-    }
+/** Read the SHA of the most recently analyzed commit (incremental state). */
+function loadLastAnalyzedSha(db: BetterSqlite3Database): string | null {
+  try {
+    const row = db
+      .prepare<{ value: string }>(
+        "SELECT value FROM co_change_meta WHERE key = 'last_analyzed_commit'",
+      )
+      .get();
+    return row ? row.value : null;
+  } catch {
+    /* table may not exist yet */
+    return null;
   }
+}
 
-  // If full re-scan, clear existing data
-  if (opts.full) {
-    db.exec('DELETE FROM co_changes');
-    db.exec('DELETE FROM co_change_meta');
-    db.exec('DELETE FROM file_commit_counts');
-  }
+/** Wipe all co-change tables for a full re-scan. */
+function clearCoChangeTables(db: BetterSqlite3Database): void {
+  db.exec('DELETE FROM co_changes');
+  db.exec('DELETE FROM co_change_meta');
+  db.exec('DELETE FROM file_commit_counts');
+}
 
-  // Collect known files from the graph for filtering
-  let knownFiles: Set<string> | null = null;
+/** Collect the set of files currently tracked by the graph for filtering. */
+function loadKnownFiles(db: BetterSqlite3Database): Set<string> | null {
   try {
     const rows = db.prepare<{ file: string }>('SELECT DISTINCT file FROM nodes').all();
-    knownFiles = new Set(rows.map((r) => r.file));
+    return new Set(rows.map((r) => r.file));
   } catch {
     /* nodes table may not exist */
+    return null;
   }
+}
 
-  const { commits } = scanGitHistory(repoRoot, { since, afterSha });
-  const { pairs: coChanges, fileCommitCounts } = computeCoChanges(commits, {
-    minSupport,
-    maxFilesPerCommit,
-    knownFiles,
-  });
-
-  // Upsert per-file commit counts so Jaccard can be recomputed from totals
+/** Upsert per-file commit counts and pair counts (Jaccard recomputed later). */
+function persistCoChangeResults(
+  db: BetterSqlite3Database,
+  fileCommitCounts: Map<string, number>,
+  coChanges: Map<string, CoChangePair>,
+): void {
   const fileCountUpsert = db.prepare(`
     INSERT INTO file_commit_counts (file, commit_count) VALUES (?, ?)
     ON CONFLICT(file) DO UPDATE SET commit_count = commit_count + excluded.commit_count
   `);
 
-  // Upsert pair counts (accumulate commit_count, jaccard placeholder — recomputed below)
   const pairUpsert = db.prepare(`
     INSERT INTO co_changes (file_a, file_b, commit_count, jaccard, last_commit_epoch)
     VALUES (?, ?, ?, 0, ?)
@@ -226,24 +199,31 @@ export function analyzeCoChanges(
     }
   });
   insertMany();
+}
 
-  // Recompute Jaccard for all affected pairs from total file commit counts
-  const affectedFiles = [...fileCommitCounts.keys()];
-  if (affectedFiles.length > 0) {
-    const ph = affectedFiles.map(() => '?').join(',');
-    db.prepare(`
-      UPDATE co_changes SET jaccard = (
-        SELECT CAST(co_changes.commit_count AS REAL) / (
-          COALESCE(fa.commit_count, 0) + COALESCE(fb.commit_count, 0) - co_changes.commit_count
-        )
-        FROM file_commit_counts fa, file_commit_counts fb
-        WHERE fa.file = co_changes.file_a AND fb.file = co_changes.file_b
+/** Recompute Jaccard for every pair touching any file in `affectedFiles`. */
+function recomputeJaccardForAffected(db: BetterSqlite3Database, affectedFiles: string[]): void {
+  if (affectedFiles.length === 0) return;
+  const ph = affectedFiles.map(() => '?').join(',');
+  db.prepare(`
+    UPDATE co_changes SET jaccard = (
+      SELECT CAST(co_changes.commit_count AS REAL) / (
+        COALESCE(fa.commit_count, 0) + COALESCE(fb.commit_count, 0) - co_changes.commit_count
       )
-      WHERE file_a IN (${ph}) OR file_b IN (${ph})
-    `).run(...affectedFiles, ...affectedFiles);
-  }
+      FROM file_commit_counts fa, file_commit_counts fb
+      WHERE fa.file = co_changes.file_a AND fb.file = co_changes.file_b
+    )
+    WHERE file_a IN (${ph}) OR file_b IN (${ph})
+  `).run(...affectedFiles, ...affectedFiles);
+}
 
-  // Update metadata
+/** Update co_change_meta with the latest analyzer run parameters. */
+function updateCoChangeMeta(
+  db: BetterSqlite3Database,
+  commits: CommitEntry[],
+  since: string,
+  minSupport: number,
+): void {
   const metaUpsert = db.prepare(`
     INSERT INTO co_change_meta (key, value) VALUES (?, ?)
     ON CONFLICT(key) DO UPDATE SET value = excluded.value
@@ -254,6 +234,49 @@ export function analyzeCoChanges(
   metaUpsert.run('analyzed_at', new Date().toISOString());
   metaUpsert.run('since', since);
   metaUpsert.run('min_support', String(minSupport));
+}
+
+export function analyzeCoChanges(
+  customDbPath?: string,
+  opts: {
+    since?: string;
+    minSupport?: number;
+    maxFilesPerCommit?: number;
+    full?: boolean;
+  } = {},
+):
+  | { pairsFound: number; commitsScanned: number; since: string; minSupport: number }
+  | { error: string } {
+  const dbPath = findDbPath(customDbPath);
+  const db = openDb(dbPath);
+  initSchema(db);
+
+  const repoRoot = path.resolve(path.dirname(dbPath), '..');
+
+  if (!fs.existsSync(path.join(repoRoot, '.git'))) {
+    closeDb(db);
+    return { error: `Not a git repository: ${repoRoot}` };
+  }
+
+  const since = opts.since || '1 year ago';
+  const minSupport = opts.minSupport ?? 3;
+  const maxFilesPerCommit = opts.maxFilesPerCommit ?? 50;
+
+  const afterSha = opts.full ? null : loadLastAnalyzedSha(db);
+  if (opts.full) clearCoChangeTables(db);
+
+  const knownFiles = loadKnownFiles(db);
+
+  const { commits } = scanGitHistory(repoRoot, { since, afterSha });
+  const { pairs: coChanges, fileCommitCounts } = computeCoChanges(commits, {
+    minSupport,
+    maxFilesPerCommit,
+    knownFiles,
+  });
+
+  persistCoChangeResults(db, fileCommitCounts, coChanges);
+  recomputeJaccardForAffected(db, [...fileCommitCounts.keys()]);
+  updateCoChangeMeta(db, commits, since, minSupport);
 
   const totalPairs = db
     .prepare<{ cnt: number }>('SELECT COUNT(*) as cnt FROM co_changes')