@monoes/monograph 1.5.6 → 1.5.8

package/src/__tests__/web/api.jobs.test.ts

@@ -1,47 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { createJobRegistry, type JobRegistry } from '../../web/async-jobs.js';
-
-describe('JobRegistry', () => {
-  let registry: JobRegistry;
-
-  beforeEach(() => {
-    registry = createJobRegistry();
-  });
-
-  it('creates a job and returns an id', () => {
-    const job = registry.create('analyze', { repoPath: '/tmp/repo' });
-    expect(job.id).toBeDefined();
-    expect(job.status).toBe('queued');
-    expect(job.type).toBe('analyze');
-  });
-
-  it('retrieves a job by id', () => {
-    const job = registry.create('analyze', { repoPath: '/tmp/repo' });
-    const found = registry.get(job.id);
-    expect(found).toBeDefined();
-    expect(found?.id).toBe(job.id);
-  });
-
-  it('updates job status to running and done', () => {
-    const job = registry.create('analyze', { repoPath: '/tmp/repo' });
-    registry.update(job.id, { status: 'running' });
-    expect(registry.get(job.id)?.status).toBe('running');
-    registry.update(job.id, { status: 'done', result: { nodes: 42 } });
-    expect(registry.get(job.id)?.status).toBe('done');
-    expect((registry.get(job.id)?.result as any)?.nodes).toBe(42);
-  });
-
-  it('cancels a job', () => {
-    const job = registry.create('analyze', { repoPath: '/tmp/repo' });
-    registry.cancel(job.id);
-    expect(registry.get(job.id)?.status).toBe('cancelled');
-  });
-
-  it('returns undefined for unknown job', () => {
-    expect(registry.get('nonexistent')).toBeUndefined();
-  });
-
-  it('cancel returns false for unknown job', () => {
-    expect(registry.cancel('nonexistent')).toBe(false);
-  });
-});

package/src/__tests__/web/api.progress.test.ts

@@ -1,25 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createJobRegistry } from '../../web/async-jobs.js';
-
-describe('JobRegistry SSE progress', () => {
-  it('emitProgress stores progress events on the job', () => {
-    const reg = createJobRegistry();
-    const job = reg.create('analyze', {});
-    reg.emitProgress(job.id, { phase: 'scan', percent: 10, message: 'scanning' });
-    reg.emitProgress(job.id, { phase: 'parse', percent: 50 });
-    const events = reg.getProgress(job.id);
-    expect(events).toHaveLength(2);
-    expect(events[0]).toMatchObject({ phase: 'scan', percent: 10 });
-    expect(events[1]).toMatchObject({ phase: 'parse', percent: 50 });
-  });
-
-  it('getProgress returns empty array for unknown job', () => {
-    const reg = createJobRegistry();
-    expect(reg.getProgress('nonexistent')).toEqual([]);
-  });
-
-  it('emitProgress is a no-op for unknown job', () => {
-    const reg = createJobRegistry();
-    expect(() => reg.emitProgress('nonexistent', { phase: 'scan' })).not.toThrow();
-  });
-});

package/src/__tests__/web/api.stream.test.ts

@@ -1,35 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import Database from 'better-sqlite3';
-import { streamGraph } from '../../web/api.js';
-
-function makeDb(): Database.Database {
-  const db = new Database(':memory:');
-  db.exec(`
-    CREATE TABLE nodes (id TEXT PRIMARY KEY, name TEXT, label TEXT, file_path TEXT, start_line INTEGER, end_line INTEGER, community_id INTEGER);
-    CREATE TABLE edges (id TEXT PRIMARY KEY, source_id TEXT, target_id TEXT, relation TEXT, confidence TEXT, confidence_score REAL);
-    INSERT INTO nodes VALUES ('n1', 'A', 'Class', '/a.ts', 1, 10, null);
-    INSERT INTO nodes VALUES ('n2', 'B', 'Function', '/b.ts', 1, 5, null);
-    INSERT INTO edges VALUES ('e1', 'n1', 'n2', 'CALLS', 'EXTRACTED', 1.0);
-  `);
-  return db;
-}
-
-describe('streamGraph', () => {
-  it('calls onRecord for each node and edge', async () => {
-    const db = makeDb();
-    const records: unknown[] = [];
-    await streamGraph(db, (record) => { records.push(record); });
-    expect(records.length).toBeGreaterThanOrEqual(3); // 2 nodes + 1 edge
-    expect(records.some((r: any) => r.type === 'node')).toBe(true);
-    expect(records.some((r: any) => r.type === 'edge')).toBe(true);
-  });
-
-  it('each record has a type field', async () => {
-    const db = makeDb();
-    const records: unknown[] = [];
-    await streamGraph(db, (record) => { records.push(record); });
-    for (const r of records) {
-      expect(['node', 'edge']).toContain((r as any).type);
-    }
-  });
-});

package/src/__tests__/wiki/providers-reasoning.test.ts

@@ -1,46 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { callLLM } from '../../wiki/providers.js';
-
-describe('reasoning model support', () => {
-  it('strips temperature for o1 model', async () => {
-    let capturedBody: any;
-    const mockFetch = vi.fn().mockImplementation((_url: any, opts: any) => {
-      capturedBody = JSON.parse(opts.body);
-      return Promise.resolve({
-        ok: true,
-        json: async () => ({
-          choices: [{ message: { content: 'result' } }],
-          usage: { prompt_tokens: 10, completion_tokens: 5 },
-        }),
-      });
-    });
-    global.fetch = mockFetch as any;
-
-    await callLLM('test', { provider: 'openai', model: 'o1-mini', apiKey: 'test' });
-
-    expect(capturedBody.temperature).toBeUndefined();
-    expect(capturedBody.max_completion_tokens).toBeDefined();
-    expect(capturedBody.max_tokens).toBeUndefined();
-  });
-
-  it('uses standard params for non-reasoning models', async () => {
-    let capturedBody: any;
-    const mockFetch = vi.fn().mockImplementation((_url: any, opts: any) => {
-      capturedBody = JSON.parse(opts.body);
-      return Promise.resolve({
-        ok: true,
-        json: async () => ({
-          choices: [{ message: { content: 'result' } }],
-          usage: { prompt_tokens: 10, completion_tokens: 5 },
-        }),
-      });
-    });
-    global.fetch = mockFetch as any;
-
-    await callLLM('test', { provider: 'openai', model: 'gpt-4o', apiKey: 'test' });
-
-    expect(capturedBody.temperature).toBeDefined();
-    expect(capturedBody.max_tokens).toBeDefined();
-    expect(capturedBody.max_completion_tokens).toBeUndefined();
-  });
-});

package/src/__tests__/wiki/wiki-review-mode.test.ts

@@ -1,22 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { generateWiki, type WikiGeneratorOptions } from '../../wiki/wiki-generator.js';
-
-describe('wiki review mode', () => {
-  it('WikiGeneratorOptions accepts reviewOnly flag', () => {
-    const opts: WikiGeneratorOptions = {
-      repoPath: '/tmp',
-      reviewOnly: true,
-    };
-    expect(opts.reviewOnly).toBe(true);
-  });
-
-  it('generateWiki returns early with groupings when reviewOnly is true', async () => {
-    const result = await generateWiki({
-      repoPath: '/tmp',
-      reviewOnly: true,
-      db: { prepare: () => ({ all: () => [] }) } as any,
-    });
-    expect(result).toHaveProperty('reviewMode', true);
-    expect(result).toHaveProperty('proposedGroupings');
-  });
-});

package/src/analysis/benchmark.ts

@@ -1,132 +0,0 @@
-import type Database from 'better-sqlite3';
-
-const CHARS_PER_TOKEN = 4;
-const DEFAULT_WORDS_PER_NODE = 50;
-const DEFAULT_QUESTIONS = [
-  'how does authentication work',
-  'what is the main entry point',
-  'how are errors handled',
-  'what connects the data layer to the api',
-  'what are the core abstractions',
-];
-
-export function estimateTokens(text: string): number {
-  return Math.floor(text.length / CHARS_PER_TOKEN);
-}
-
-export interface BenchmarkOptions {
-  corpusWordCount?: number;
-  questions?: string[];
-  depth?: number;
-}
-
-export interface PerQuestionResult {
-  question: string;
-  query_tokens: number;
-  reduction: number;
-}
-
-export interface BenchmarkResult {
-  corpus_tokens: number;
-  corpus_words: number;
-  nodes: number;
-  edges: number;
-  avg_query_tokens: number;
-  reduction_ratio: number;
-  per_question: PerQuestionResult[];
-}
-
-function buildAdjacency(db: Database.Database): Map<string, string[]> {
-  const adj = new Map<string, string[]>();
-  const edges = db.prepare('SELECT source_id, target_id FROM edges').all() as { source_id: string; target_id: string }[];
-  for (const { source_id, target_id } of edges) {
-    const list = adj.get(source_id) ?? [];
-    list.push(target_id);
-    adj.set(source_id, list);
-    if (!adj.has(target_id)) adj.set(target_id, []);
-  }
-  return adj;
-}
-
-function querySubgraphTokens(
-  db: Database.Database,
-  question: string,
-  depth: number,
-): number {
-  const terms = question.toLowerCase().split(/\s+/).filter(t => t.length > 2);
-  if (terms.length === 0) return 0;
-
-  const likeClause = terms.map(() => 'LOWER(name) LIKE ?').join(' OR ');
-  const params = terms.map(t => `%${t}%`);
-  const startRows = db.prepare(
-    `SELECT id, name, label, file_path FROM nodes WHERE ${likeClause} LIMIT 3`
-  ).all(...params) as { id: string; name: string; label: string; file_path: string | null }[];
-
-  if (startRows.length === 0) return 0;
-
-  const adj = buildAdjacency(db);
-  const visited = new Set(startRows.map(r => r.id));
-  let frontier = new Set(startRows.map(r => r.id));
-
-  for (let d = 0; d < depth; d++) {
-    const next = new Set<string>();
-    for (const id of frontier) {
-      for (const neighbor of adj.get(id) ?? []) {
-        if (!visited.has(neighbor)) {
-          next.add(neighbor);
-          visited.add(neighbor);
-        }
-      }
-    }
-    frontier = next;
-    if (frontier.size === 0) break;
-  }
-
-  const ids = [...visited];
-  if (ids.length === 0) return 0;
-  const placeholders = ids.map(() => '?').join(',');
-  const rows = db.prepare(
-    `SELECT name, label, file_path FROM nodes WHERE id IN (${placeholders})`
-  ).all(...ids) as { name: string; label: string; file_path: string | null }[];
-
-  const lines = rows.map(r => `NODE ${r.label} ${r.name} src=${r.file_path ?? ''}`);
-  return estimateTokens(lines.join('\n'));
-}
-
-export function runBenchmark(db: Database.Database, options: BenchmarkOptions = {}): BenchmarkResult {
-  const { corpusWordCount, questions = DEFAULT_QUESTIONS, depth = 3 } = options;
-
-  const nodeCount = (db.prepare('SELECT COUNT(*) AS n FROM nodes').get() as { n: number }).n;
-  const edgeCount = (db.prepare('SELECT COUNT(*) AS n FROM edges').get() as { n: number }).n;
-
-  const corpusWords = corpusWordCount ?? nodeCount * DEFAULT_WORDS_PER_NODE;
-  const corpusTokens = Math.floor(corpusWords * 4 / 3);
-
-  const perQuestion: PerQuestionResult[] = [];
-  for (const q of questions) {
-    const qt = querySubgraphTokens(db, q, depth);
-    perQuestion.push({
-      question: q,
-      query_tokens: qt,
-      reduction: corpusTokens > 0 && qt > 0 ? Math.round((corpusTokens / qt) * 10) / 10 : 0,
-    });
-  }
-
-  const answered = perQuestion.filter(p => p.query_tokens > 0);
-  const avgQueryTokens = answered.length > 0
-    ? Math.floor(answered.reduce((s, p) => s + p.query_tokens, 0) / answered.length)
-    : 0;
-  const reductionRatio = corpusTokens > 0 && avgQueryTokens > 0
-    ? Math.round((corpusTokens / avgQueryTokens) * 10) / 10
-    : 0;
-
-  return {
-    corpus_tokens: corpusTokens,
-    corpus_words: corpusWords,
-    nodes: nodeCount,
-    edges: edgeCount,
-    avg_query_tokens: avgQueryTokens,
-    reduction_ratio: reductionRatio,
-    per_question: perQuestion,
-  };
-}

package/src/analysis/changed-files.ts

@@ -1,73 +0,0 @@
-import { execFileSync } from 'child_process';
-import * as path from 'path';
-
-export class ChangedFilesError extends Error {
-  constructor(message: string, public readonly kind: 'invalid_ref' | 'git_failed' | 'parse_error') {
-    super(message);
-    this.name = 'ChangedFilesError';
-  }
-}
-
-// Leading '-' is rejected explicitly (not just by the character class) so a
-// value like "--output=/tmp/pwned" can't be passed through and interpreted
-// by git as a command-line option instead of a ref (git option injection).
-const VALID_REF_RE = /^[a-zA-Z0-9\-_./@~^]+$/;
-
-export function validateGitRef(ref: string): string {
-  if (ref.startsWith('-')) {
-    throw new ChangedFilesError(
-      `Invalid git ref: "${ref}". Refs must not start with '-' (would be interpreted as a git option)`,
-      'invalid_ref',
-    );
-  }
-  if (VALID_REF_RE.test(ref)) {
-    return ref;
-  }
-  throw new ChangedFilesError(
-    `Invalid git ref: "${ref}". Must match ${VALID_REF_RE.source}`,
-    'invalid_ref',
-  );
-}
-
-export async function getChangedFiles(root: string, sinceRef: string): Promise<Set<string>> {
-  validateGitRef(sinceRef);
-
-  let output: string;
-  try {
-    // execFileSync with array argv — no shell involved, so a `root` (cwd)
-    // containing '"' or '$(...)' cannot break out and execute arbitrary
-    // commands.
-    output = execFileSync('git', ['diff', '--name-only', '-z', sinceRef, 'HEAD'], {
-      cwd: root,
-      encoding: 'utf8',
-    });
-  } catch (err) {
-    throw new ChangedFilesError(
-      `git diff failed: ${err instanceof Error ? err.message : String(err)}`,
-      'git_failed',
-    );
-  }
-
-  try {
-    // Use NUL delimiter (-z) to handle non-ASCII filenames and paths with spaces;
-    // git's default core.quotePath=true wraps such names in quotes with octal escapes.
-    const files = output
-      .split('\0')
-      .filter((line) => line.length > 0)
-      .map((relative) => path.resolve(root, relative));
-    return new Set(files);
-  } catch (err) {
-    throw new ChangedFilesError(
-      `Failed to parse git diff output: ${err instanceof Error ? err.message : String(err)}`,
-      'parse_error',
-    );
-  }
-}
-
-export function filterResultsByChangedFiles<T extends { filePath?: string | null }>(
-  results: T[],
-  changedPaths: Set<string>,
-): T[] {
-  return results.filter((item) => item.filePath != null && changedPaths.has(item.filePath));
-}
-

package/src/analysis/changed-workspaces.ts

@@ -1,94 +0,0 @@
-import { execFileSync } from 'child_process';
-import { existsSync, readdirSync, readFileSync } from 'fs';
-import { join, relative, resolve } from 'path';
-
-export interface WorkspacePackage {
-  name: string;
-  root: string;
-  hasChanges: boolean;
-}
-
-function findWorkspaceRoots(projectRoot: string): string[] {
-  // Detect pnpm/npm/yarn workspaces
-  let pkg: Record<string, unknown>;
-  try {
-    pkg = JSON.parse(
-      readFileSync(join(projectRoot, 'package.json'), 'utf8'),
-    );
-  } catch { return []; }
-
-  const workspaceGlobs: string[] =
-    (pkg['workspaces'] as string[] | { packages: string[] } | undefined) instanceof Array
-      ? pkg['workspaces'] as string[]
-      : (pkg['workspaces'] as { packages?: string[] } | undefined)?.packages ?? [];
-
-  if (workspaceGlobs.length === 0) return [];
-
-  const roots: string[] = [];
-  for (const glob of workspaceGlobs) {
-    // Simple glob: support "packages/*" and "apps/*"
-    if (glob.endsWith('/*')) {
-      const dir = join(projectRoot, glob.slice(0, -2));
-      try {
-        const entries = readdirSync(dir, { withFileTypes: true });
-        for (const e of entries) {
-          if (e.isDirectory()) roots.push(join(dir, e.name));
-        }
-      } catch { /* ignore */ }
-    } else {
-      const absPath = join(projectRoot, glob);
-      if (existsSync(absPath)) roots.push(absPath);
-    }
-  }
-  return roots;
-}
-
-export function getChangedWorkspaces(
-  projectRoot: string,
-  sinceRef: string,
-  workspaceRoots?: string[],
-): WorkspacePackage[] {
-  // Validate git ref (same allowlist as changed-files.ts). Leading '-' is
-  // rejected explicitly so a value like "--output=/tmp/pwned" can't be
-  // interpreted by git as a command-line option (git option injection).
-  if (sinceRef.startsWith('-')) {
-    throw new Error(`Invalid git ref: "${sinceRef}". Refs must not start with '-' (would be interpreted as a git option)`);
-  }
-  if (!/^[a-zA-Z0-9\-_./@~^]+$/.test(sinceRef)) {
-    throw new Error(`Invalid git ref: "${sinceRef}"`);
-  }
-
-  let changedFiles: Set<string>;
-  try {
-    // execFileSync with array argv — no shell involved, so a `projectRoot`
-    // containing '"' or '$(...)' cannot break out and execute arbitrary
-    // commands.
-    const raw = execFileSync(
-      'git',
-      ['-C', projectRoot, 'diff', '--name-only', `${sinceRef}...HEAD`],
-      { encoding: 'utf8' }
-    );
-    changedFiles = new Set(raw.split('\n').map(l => l.trim()).filter(Boolean));
-  } catch {
-    changedFiles = new Set();
-  }
-
-  const roots = workspaceRoots ?? findWorkspaceRoots(projectRoot);
-
-  return roots.map(root => {
-    const relRoot = relative(projectRoot, root).replace(/\\/g, '/') + '/';
-    const hasChanges = [...changedFiles].some(f => f.startsWith(relRoot));
-    const pkgName = root.split(/[\\/]/).pop() ?? root;
-    return { name: pkgName, root: resolve(root), hasChanges };
-  });
-}
-
-export function resolveChangedWorkspaceRoots(
-  projectRoot: string,
-  sinceRef: string,
-  workspaceRoots?: string[],
-): string[] {
-  return getChangedWorkspaces(projectRoot, sinceRef, workspaceRoots)
-    .filter(w => w.hasChanges)
-    .map(w => w.root);
-}

package/src/analysis/churn-cache.ts

@@ -1,179 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { execSync } from 'node:child_process';
-
-const CHURN_CACHE_VERSION = 3;
-const MAX_CHURN_CACHE_BYTES = 64 * 1024 * 1024;
-
-export interface CachedCommitEvent {
-  timestamp: number;
-  linesAdded: number;
-  linesDeleted: number;
-  authorIdx: number | null;
-}
-
-export interface CachedFileChurn {
-  path: string;
-  events: CachedCommitEvent[];
-}
-
-export interface ChurnCache {
-  version: number;
-  lastIndexedSha: string;
-  gitAfter: string;
-  files: CachedFileChurn[];
-  shallowClone: boolean;
-  authorPool: string[];
-}
-
-export interface CachedChurnResult {
-  files: Map<string, { commits: number; linesAdded: number; linesDeleted: number; weightedCommits: number }>;
-  shallowClone: boolean;
-  authorPool: string[];
-  cacheHit: boolean;
-}
-
-function loadChurnCache(cacheDir: string, gitAfter: string): ChurnCache | null {
-  const file = join(cacheDir, 'churn.json');
-  if (!existsSync(file)) return null;
-  try {
-    const raw = readFileSync(file, 'utf8');
-    if (raw.length > MAX_CHURN_CACHE_BYTES) return null;
-    const cache: ChurnCache = JSON.parse(raw);
-    if (cache.version !== CHURN_CACHE_VERSION) return null;
-    if (cache.gitAfter !== gitAfter) return null;
-    return cache;
-  } catch { return null; }
-}
-
-function saveChurnCache(cacheDir: string, sha: string, gitAfter: string, cache: ChurnCache): void {
-  mkdirSync(cacheDir, { recursive: true });
-  const tmp = join(cacheDir, 'churn.json.tmp');
-  writeFileSync(tmp, JSON.stringify({ ...cache, version: CHURN_CACHE_VERSION, lastIndexedSha: sha, gitAfter }));
-  renameSync(tmp, join(cacheDir, 'churn.json'));
-}
-
-function getHeadSha(root: string): string | null {
-  try {
-    return execSync('git rev-parse HEAD', { cwd: root, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
-  } catch { return null; }
-}
-
-function isAncestor(root: string, ancestor: string, descendant: string): boolean {
-  try {
-    execSync(`git merge-base --is-ancestor ${ancestor} ${descendant}`, { cwd: root, stdio: 'ignore' });
-    return true;
-  } catch { return false; }
-}
-
-function runGitLog(root: string, gitAfter: string, range: string | null): ChurnCache | null {
-  try {
-    const rangeArg = range ? [range] : [];
-    const stdout = execSync(
-      ['git', 'log', ...rangeArg, '--numstat', '--no-merges', '--no-renames',
-       '--use-mailmap', '--format=format:%at|%ae', `--after=${gitAfter}`].join(' '),
-      { cwd: root, maxBuffer: 256 * 1024 * 1024 }
-    ).toString();
-    return parseGitLog(stdout);
-  } catch { return null; }
-}
-
-function parseGitLog(stdout: string): ChurnCache {
-  const files: Map<string, CachedCommitEvent[]> = new Map();
-  const authorPool: string[] = [];
-  const authorIndex: Map<string, number> = new Map();
-  let currentTs = Math.floor(Date.now() / 1000);
-  let currentAuthorIdx: number | null = null;
-
-  for (const rawLine of stdout.split('\n')) {
-    const line = rawLine.trim();
-    if (!line) continue;
-    const headerMatch = line.match(/^(\d+)\|(.+)$/);
-    if (headerMatch) {
-      currentTs = parseInt(headerMatch[1], 10);
-      const email = headerMatch[2];
-      if (!authorIndex.has(email)) { authorIndex.set(email, authorPool.length); authorPool.push(email); }
-      currentAuthorIdx = authorIndex.get(email)!;
-      continue;
-    }
-    const parts = line.split('\t');
-    if (parts.length < 3) continue;
-    const added = parseInt(parts[0], 10);
-    const deleted = parseInt(parts[1], 10);
-    if (isNaN(added) || isNaN(deleted)) continue;
-    const path = parts[2];
-    if (!files.has(path)) files.set(path, []);
-    files.get(path)!.push({ timestamp: currentTs, linesAdded: added, linesDeleted: deleted, authorIdx: currentAuthorIdx });
-  }
-
-  // Build files array without intermediate Array.from allocation
-  const filesArr: CachedFileChurn[] = [];
-  for (const [path, events] of files) filesArr.push({ path, events });
-
-  return { version: CHURN_CACHE_VERSION, lastIndexedSha: '', gitAfter: '', shallowClone: false, authorPool, files: filesArr };
-}
-
-function mergeChurnCaches(base: ChurnCache, delta: ChurnCache): ChurnCache {
-  const authorMap = new Map<number, number>();
-  const baseIndex = new Map(base.authorPool.map((e, i) => [e, i]));
-  for (let i = 0; i < delta.authorPool.length; i++) {
-    const email = delta.authorPool[i];
-    if (!baseIndex.has(email)) { baseIndex.set(email, base.authorPool.length); base.authorPool.push(email); }
-    authorMap.set(i, baseIndex.get(email)!);
-  }
-  // Build fileMap without intermediate array from base.files.map()
-  const fileMap = new Map<string, CachedFileChurn>();
-  for (const f of base.files) fileMap.set(f.path, f);
-  for (const df of delta.files) {
-    const remapped = df.events.map(e => ({ ...e, authorIdx: e.authorIdx !== null ? (authorMap.get(e.authorIdx) ?? null) : null }));
-    if (fileMap.has(df.path)) fileMap.get(df.path)!.events.push(...remapped);
-    else fileMap.set(df.path, { path: df.path, events: remapped });
-  }
-  // Build result array without intermediate Array.from allocation
-  const mergedFiles: CachedFileChurn[] = [];
-  for (const f of fileMap.values()) mergedFiles.push(f);
-  return { ...base, files: mergedFiles };
-}
-
-// Precomputed constant: -Math.LN2 / HALF_LIFE_DAYS avoids per-call division in hot loop
-const DECAY_FACTOR = -Math.LN2 / 90;
-const SECS_PER_DAY = 86400;
-
-function buildChurnResult(cache: ChurnCache): Omit<CachedChurnResult, 'cacheHit'> {
-  const now = Math.floor(Date.now() / 1000);
-  const files = new Map<string, { commits: number; linesAdded: number; linesDeleted: number; weightedCommits: number }>();
-  for (const { path, events } of cache.files) {
-    let commits = 0, linesAdded = 0, linesDeleted = 0, weightedCommits = 0;
-    for (const e of events) {
-      const ageDays = (now - e.timestamp) / SECS_PER_DAY;
-      // Math.exp is faster than Math.pow(0.5, x) for recency decay in hot loop
-      weightedCommits += Math.exp(DECAY_FACTOR * ageDays);
-      commits++; linesAdded += e.linesAdded; linesDeleted += e.linesDeleted;
-    }
-    files.set(path, { commits, linesAdded, linesDeleted, weightedCommits: Math.round(weightedCommits * 100) / 100 });
-  }
-  return { files, shallowClone: cache.shallowClone, authorPool: cache.authorPool };
-}
-
-export function analyzeChurnCached(root: string, gitAfter: string, cacheDir: string, noCache = false): CachedChurnResult | null {
-  const headSha = getHeadSha(root);
-  if (!headSha) return null;
-  if (!noCache) {
-    const cached = loadChurnCache(cacheDir, gitAfter);
-    if (cached) {
-      if (cached.lastIndexedSha === headSha) return { ...buildChurnResult(cached), cacheHit: true };
-      if (isAncestor(root, cached.lastIndexedSha, headSha)) {
-        const delta = runGitLog(root, gitAfter, `${cached.lastIndexedSha}..HEAD`);
-        if (delta) {
-          const merged = mergeChurnCaches(cached, delta);
-          saveChurnCache(cacheDir, headSha, gitAfter, merged);
-          return { ...buildChurnResult(merged), cacheHit: true };
-        }
-      }
-    }
-  }
-  const fresh = runGitLog(root, gitAfter, null);
-  if (!fresh) return null;
-  if (!noCache) saveChurnCache(cacheDir, headSha, gitAfter, fresh);
-  return { ...buildChurnResult(fresh), cacheHit: false };
-}