scip-query 0.1.0

package/src/queries/extract-candidates.ts

@@ -0,0 +1,167 @@
+import type { ScipDatabase } from '../db.js';
+import { getCalleeRowsForSymbol } from '../query-support.js';
+import type { ExtractCandidate } from '../types.js';
+import { shortenSymbol } from '../symbol-parser.js';
+
+/**
+ * Find functions with natural extraction seams.
+ *
+ * A large function that references two distinct groups of symbols —
+ * where group A's symbols are never co-referenced with group B's —
+ * has a natural extraction boundary. The isolated cluster can likely
+ * be pulled into its own function.
+ *
+ * We detect this by:
+ * 1. Finding all callees of a function
+ * 2. Building a co-occurrence graph (which callees appear in the same chunk)
+ * 3. Finding connected components — disconnected components = extraction seams
+ * 4. Scoring each cluster by how isolated it is from the rest
+ */
+export function extractCandidates(
+  db: ScipDatabase,
+  opts: { scope?: string; minLoc?: number; minCallees?: number; limit?: number } = {},
+): ExtractCandidate[] {
+  const { scope, minLoc = 10, minCallees = 6, limit = 20 } = opts;
+  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : '';
+
+  // Find functions large enough to consider
+  const symbols = db.all<{
+    id: number;
+    symbol: string;
+    document_id: number;
+    start_line: number;
+    end_line: number;
+    relative_path: string;
+  }>(
+    `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
+    FROM global_symbols gs
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    JOIN documents d ON der.document_id = d.id
+    WHERE 1 = 1
+      ${db.pathExclusionsFor('d')}
+      ${db.symbolNoiseFor('gs')}
+      AND (der.end_line - der.start_line + 1) >= ?
+      ${scopeFilter}
+    ORDER BY (der.end_line - der.start_line + 1) DESC`,
+    minLoc,
+  );
+
+  const results: ExtractCandidate[] = [];
+
+  for (const sym of symbols) {
+    if (db.isIgnored(sym.relative_path)) continue;
+
+    // Skip pure type files — "callees" in a type file are just type references,
+    // not function calls. Splitting type files is a cosmetic choice, not an
+    // extraction opportunity.
+    const basename = sym.relative_path.split('/').pop() ?? '';
+    if (basename.includes('types')) continue;
+
+    // Get callees with their chunk locations (to build co-occurrence)
+    const calleeChunks = getCalleeRowsForSymbol(db, {
+      documentId: sym.document_id,
+      startLine: sym.start_line,
+      endLine: sym.end_line,
+      symbolId: sym.id,
+    });
+
+    // Collect unique callees
+    const calleeSet = new Set(calleeChunks.map((c) => c.symbol));
+    if (calleeSet.size < minCallees) continue;
+
+    // Build co-occurrence graph: two callees are connected if they
+    // appear in the same chunk (meaning they're used in proximity)
+    const cooccurrence = new Map<string, Set<string>>();
+    for (const callee of calleeSet) {
+      cooccurrence.set(callee, new Set());
+    }
+
+    // Group by chunk
+    const chunkToCallees = new Map<number, Set<string>>();
+    for (const cc of calleeChunks) {
+      if (!chunkToCallees.has(cc.chunkId)) chunkToCallees.set(cc.chunkId, new Set());
+      chunkToCallees.get(cc.chunkId)!.add(cc.symbol);
+    }
+
+    // Callees in the same chunk are co-occurring
+    for (const callees of chunkToCallees.values()) {
+      const arr = [...callees];
+      for (let i = 0; i < arr.length; i++) {
+        for (let j = i + 1; j < arr.length; j++) {
+          cooccurrence.get(arr[i]!)!.add(arr[j]!);
+          cooccurrence.get(arr[j]!)!.add(arr[i]!);
+        }
+      }
+    }
+
+    // Find connected components via BFS
+    const visited = new Set<string>();
+    const clusters: Set<string>[] = [];
+
+    for (const callee of calleeSet) {
+      if (visited.has(callee)) continue;
+      const cluster = new Set<string>();
+      const queue = [callee];
+      while (queue.length > 0) {
+        const current = queue.pop()!;
+        if (visited.has(current)) continue;
+        visited.add(current);
+        cluster.add(current);
+        for (const neighbor of cooccurrence.get(current) ?? []) {
+          if (!visited.has(neighbor)) queue.push(neighbor);
+        }
+      }
+      clusters.push(cluster);
+    }
+
+    // Only interesting if there are multiple clusters (= extraction seams exist)
+    if (clusters.length < 2) continue;
+
+    // Score each cluster by isolation:
+    // isolation = 1 - (edges to other clusters / total possible edges to other clusters)
+    const scoredClusters = clusters
+      .filter((c) => c.size >= 2) // single-callee clusters aren't interesting
+      .map((cluster) => {
+        const otherCallees = new Set<string>();
+        for (const c of clusters) {
+          if (c !== cluster) {
+            for (const s of c) otherCallees.add(s);
+          }
+        }
+
+        // Count cross-cluster edges
+        let crossEdges = 0;
+        for (const callee of cluster) {
+          for (const neighbor of cooccurrence.get(callee) ?? []) {
+            if (otherCallees.has(neighbor)) crossEdges++;
+          }
+        }
+
+        const maxCrossEdges = cluster.size * otherCallees.size;
+        const isolation = maxCrossEdges > 0 ? 1 - crossEdges / maxCrossEdges : 1;
+
+        return {
+          callees: [...cluster].map(shortenSymbol),
+          isolation,
+        };
+      })
+      .filter((c) => c.isolation > 0.5) // Only report well-isolated clusters
+      .sort((a, b) => b.isolation - a.isolation);
+
+    if (scoredClusters.length > 0) {
+      results.push({
+        symbol: sym.symbol,
+        shortName: shortenSymbol(sym.symbol),
+        relativePath: sym.relative_path,
+        startLine: sym.start_line,
+        endLine: sym.end_line,
+        loc: sym.end_line - sym.start_line + 1,
+        totalCallees: calleeSet.size,
+        clusters: scoredClusters,
+      });
+    }
+  }
+
+  results.sort((a, b) => b.clusters.length - a.clusters.length || b.loc - a.loc);
+  return results.slice(0, limit);
+}

package/src/queries/fan.ts

@@ -0,0 +1,148 @@
+import type { ScipDatabase } from '../db.js';
+import type { FanResult } from '../types.js';
+import { shortenSymbol } from '../symbol-parser.js';
+
+/**
+ * Fan-in: how many distinct files reference this symbol.
+ * High fan-in = widely depended upon = high blast radius for changes.
+ */
+export function fanIn(
+  db: ScipDatabase,
+  symbolPattern: string,
+): FanResult[] {
+  const rows = db.all<{
+    symbol: string;
+    file_count: number;
+  }>(
+    `SELECT gs.symbol, COUNT(DISTINCT c.document_id) AS file_count
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    WHERE gs.symbol LIKE ?
+      AND m.role = 0
+    GROUP BY gs.id
+    ORDER BY file_count DESC`,
+    `%${symbolPattern}%`,
+  );
+
+  return rows.map((r) => ({
+    name: shortenSymbol(r.symbol),
+    count: r.file_count,
+  }));
+}
+
+/**
+ * Fan-out: how many external symbols does this file reference.
+ * High fan-out = depends on many things = fragile to upstream changes.
+ */
+export function fanOut(
+  db: ScipDatabase,
+  filePattern: string,
+): FanResult[] {
+  const rows = db.all<{
+    relative_path: string;
+    symbol_count: number;
+  }>(
+    `SELECT d.relative_path, COUNT(DISTINCT gs.id) AS symbol_count
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents d ON c.document_id = d.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    JOIN documents def_d ON der.document_id = def_d.id
+    WHERE d.relative_path LIKE ?
+      AND m.role = 0
+      AND def_d.id != d.id
+    GROUP BY d.id
+    ORDER BY symbol_count DESC`,
+    `%${filePattern}%`,
+  );
+
+  return rows
+    .filter((r) => !db.isIgnored(r.relative_path))
+    .map((r) => ({
+      name: r.relative_path,
+      count: r.symbol_count,
+    }));
+}
+
+/**
+ * Top fan-in across the whole codebase — the most depended-on symbols.
+ */
+export function topFanIn(
+  db: ScipDatabase,
+  opts: { limit?: number; scope?: string } = {},
+): FanResult[] {
+  const { limit = 30, scope } = opts;
+  const scopeFilter = scope
+    ? `AND def_d.relative_path LIKE '%${scope}%'`
+    : '';
+
+  const rows = db.all<{
+    symbol: string;
+    file_count: number;
+  }>(
+    `SELECT gs.symbol, COUNT(DISTINCT c.document_id) AS file_count
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    JOIN documents def_d ON der.document_id = def_d.id
+    WHERE m.role = 0
+      ${db.pathExclusionsFor('def_d')}
+      ${db.symbolNoiseFor('gs')}
+      ${scopeFilter}
+    GROUP BY gs.id
+    HAVING file_count > 1
+    ORDER BY file_count DESC
+    LIMIT ?`,
+    limit,
+  );
+
+  return rows.map((r) => ({
+    name: shortenSymbol(r.symbol),
+    count: r.file_count,
+  }));
+}
+
+/**
+ * Top fan-out across the whole codebase — files that depend on the most external symbols.
+ */
+export function topFanOut(
+  db: ScipDatabase,
+  opts: { limit?: number; scope?: string } = {},
+): FanResult[] {
+  const { limit = 30, scope } = opts;
+  const scopeFilter = scope
+    ? `AND d.relative_path LIKE '%${scope}%'`
+    : '';
+
+  const rows = db.all<{
+    relative_path: string;
+    symbol_count: number;
+  }>(
+    `SELECT d.relative_path, COUNT(DISTINCT gs.id) AS symbol_count
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents d ON c.document_id = d.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    JOIN documents def_d ON der.document_id = def_d.id
+    WHERE m.role = 0
+      AND def_d.id != d.id
+      ${db.pathExclusionsFor('d')}
+      ${db.symbolNoiseFor('gs')}
+      ${scopeFilter}
+    GROUP BY d.id
+    ORDER BY symbol_count DESC
+    LIMIT ?`,
+    limit,
+  );
+
+  return rows
+    .filter((r) => !db.isIgnored(r.relative_path))
+    .map((r) => ({
+      name: r.relative_path,
+      count: r.symbol_count,
+    }));
+}

package/src/queries/files.ts

@@ -0,0 +1,16 @@
+import type { ScipDatabase } from '../db.js';
+import type { FileResult } from '../types.js';
+
+export function files(db: ScipDatabase, pattern: string): FileResult[] {
+  const rows = db.all<{ relative_path: string }>(
+    `SELECT relative_path FROM documents
+     WHERE relative_path LIKE ?
+     ORDER BY relative_path`,
+    `%${pattern}%`,
+  );
+
+  // Apply gitignore filtering
+  return rows
+    .filter((r) => !db.isIgnored(r.relative_path))
+    .map((r) => ({ relativePath: r.relative_path }));
+}

package/src/queries/health.ts

@@ -0,0 +1,324 @@
+import type { ScipDatabase } from '../db.js';
+import { dead } from './dead.js';
+import { isolated } from './isolated.js';
+import { cycles } from './cycles.js';
+import { similarAll } from './similar.js';
+import { extractCandidates } from './extract-candidates.js';
+import { wrapperCandidates } from './wrapper-candidates.js';
+import { passthroughCandidates } from './passthrough-candidates.js';
+import { staleAbstractions } from './stale-abstractions.js';
+import { drift } from './drift.js';
+import { complexityHotspots } from './complexity-hotspots.js';
+import { testCoverageSummary } from './test-coverage.js';
+import { stats } from './stats.js';
+import type { HealthAction, HealthReport } from '../types.js';
+
+/**
+ * Single composite health report that runs all de-bloat analyses
+ * and produces a prioritized action list.
+ *
+ * The scoring formula accounts for common false positives:
+ * - Entry points (CLI, workers, barrels) appearing as "dead code"
+ * - Typed result interfaces with 1 consumer (normal for APIs)
+ * - Consistent import patterns across sibling modules (not duplication)
+ * - Barrel and orchestrator files deviating from sibling patterns (expected)
+ */
+export function health(
+  db: ScipDatabase,
+  opts: { scope?: string } = {},
+): HealthReport {
+  const { scope } = opts;
+
+  // Run all analyses
+  const s = stats(db);
+  const deadResult = dead(db, { scope, minLoc: 3, skipBarrels: false });
+  const isolatedResult = isolated(db, { scope, minLoc: 3 });
+  const cycleResult = cycles(db, { scope });
+  const similarResult = similarAll(db, { scope, minSimilarity: 0.6, limit: 50, minCallees: 4 });
+  const extractResult = extractCandidates(db, { scope, minLoc: 15, minCallees: 5, limit: 50 });
+  const wrapperResult = wrapperCandidates(db, { scope, maxLoc: 15, limit: 50 });
+  const passthroughResult = passthroughCandidates(db, { scope, maxLoc: 15, limit: 50 });
+  const staleResult = staleAbstractions(db, { scope, minLoc: 3, limit: 50 });
+  const driftResult = drift(db, { scope });
+  const complexResult = complexityHotspots(db, { scope, minLoc: 10, limit: 10 });
+  const testResult = testCoverageSummary(db, { scope, minLoc: 3 });
+
+  const isolatedLoc = isolatedResult.reduce((sum, r) => sum + r.loc, 0);
+
+  // ── False-positive filtering ─────────────────────────────
+
+  // Entry points and barrels appear as dead/isolated because nothing imports them.
+  // Filter them out of the scoring (but still report them with a note).
+  const entryPointPatterns = ['/index.ts', '/index.js', 'cli.ts', 'worker.ts', 'postinstall.ts', '/mod.rs', '__init__.py', 'main.ts', 'main.rs', 'main.go', 'main.py'];
+  const isEntryPoint = (path: string) => entryPointPatterns.some((p) => path.endsWith(p));
+
+  // Dead code: only count truly dead symbols (zero refs anywhere),
+  // excluding entry points AND file-internal helpers (which are fine).
+  const trueDeadSymbols = deadResult.symbols.filter(
+    (s) => !isEntryPoint(s.relativePath) && s.kind === 'dead-code',
+  );
+  const trueDeadCount = trueDeadSymbols.length;
+  const trueDeadLoc = trueDeadSymbols.reduce((sum, s) => sum + s.loc, 0);
+  const fileInternalCount = deadResult.symbols.filter(
+    (s) => !isEntryPoint(s.relativePath) && s.kind === 'file-internal',
+  ).length;
+
+  // Isolated: same entry-point filtering
+  const trueIsolatedCount = isolatedResult.filter(
+    (s) => !isEntryPoint(s.relativePath),
+  ).length;
+
+  // Stale abstractions: the command filters out types.ts single-consumer types.
+  // Also filter out 0-consumer types in files that export functions — these are
+  // likely parameter/return types consumed through function signatures, which
+  // the SCIP index can't track as direct mentions.
+  const filesWithFunctions = new Set(
+    db.all<{ relative_path: string }>(
+      `SELECT DISTINCT d.relative_path
+       FROM global_symbols gs
+       JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+       JOIN documents d ON der.document_id = d.id
+       WHERE gs.symbol LIKE '%().'
+         ${db.pathExclusionsFor('d')}`,
+    ).map((r) => r.relative_path),
+  );
+  const trueStaleCount = staleResult.filter((s) => {
+    // 0-consumer types in files with functions are likely param/return types
+    if (s.consumers === 0 && filesWithFunctions.has(s.file)) return false;
+    return true;
+  }).length;
+
+  // Drift: now uses usage-based detection (unused imports, layer violations, pattern deviations)
+  // The drift command already filters structural roles internally.
+  const trueDriftCount = driftResult.results.length;
+
+  // Similar pairs: the similar command now uses TF-IDF weighted cosine
+  // similarity which automatically discounts infrastructure callees.
+  // The sharedCallees list only contains significant (above-median IDF) callees.
+  // We can trust the count directly.
+  const trueSimilarCount = similarResult.length;
+
+  // ── Build prioritized action list ────────────────────────
+
+  const actions: HealthAction[] = [];
+
+  if (trueDeadCount > 0) {
+    actions.push({
+      category: 'Dead code',
+      description: `${trueDeadCount} symbols with zero references anywhere — safe to delete`,
+      effort: 'low',
+      impact: 'high',
+      count: trueDeadCount,
+      locRecoverable: trueDeadLoc,
+    });
+  }
+
+  if (testResult.percent < 50) {
+    actions.push({
+      category: 'Test coverage',
+      description: `${testResult.percent}% of symbols referenced by tests (${testResult.uncovered} uncovered)`,
+      effort: 'high',
+      impact: 'high',
+      count: testResult.uncovered,
+      locRecoverable: 0,
+    });
+  }
+
+  if (trueIsolatedCount > 0) {
+    actions.push({
+      category: 'Isolated symbols',
+      description: `${trueIsolatedCount} symbols completely disconnected from the codebase graph`,
+      effort: 'low',
+      impact: 'medium',
+      count: trueIsolatedCount,
+      locRecoverable: isolatedResult
+        .filter((s) => !isEntryPoint(s.relativePath))
+        .reduce((sum, s) => sum + s.loc, 0),
+    });
+  }
+
+  if (cycleResult.length > 0) {
+    actions.push({
+      category: 'Circular dependencies',
+      description: `${cycleResult.length} cycle(s) — break with dependency inversion or module restructuring`,
+      effort: 'medium',
+      impact: 'high',
+      count: cycleResult.length,
+      locRecoverable: 0,
+    });
+  }
+
+  if (trueSimilarCount > 0) {
+    actions.push({
+      category: 'Similar functions',
+      description: `${trueSimilarCount} pairs with real logic overlap (beyond shared imports) — consolidation candidates`,
+      effort: 'medium',
+      impact: 'medium',
+      count: trueSimilarCount,
+      locRecoverable: 0,
+    });
+  }
+
+  if (extractResult.length > 0) {
+    actions.push({
+      category: 'Extraction candidates',
+      description: `${extractResult.length} large functions with isolated callee clusters — extract method opportunities`,
+      effort: 'medium',
+      impact: 'medium',
+      count: extractResult.length,
+      locRecoverable: 0,
+    });
+  }
+
+  if (wrapperResult.length > 0) {
+    actions.push({
+      category: 'Wrapper functions',
+      description: `${wrapperResult.length} single-consumer symbols that could be inlined`,
+      effort: 'low',
+      impact: 'low',
+      count: wrapperResult.length,
+      locRecoverable: wrapperResult.reduce((sum, r) => sum + r.loc, 0),
+    });
+  }
+
+  if (passthroughResult.length > 0) {
+    actions.push({
+      category: 'Passthrough functions',
+      description: `${passthroughResult.length} functions that just forward to one callee — unnecessary indirection`,
+      effort: 'low',
+      impact: 'low',
+      count: passthroughResult.length,
+      locRecoverable: passthroughResult.reduce((sum, r) => sum + r.loc, 0),
+    });
+  }
+
+  if (trueStaleCount > 0) {
+    // Count from the filtered set, not the raw result
+    const trueStaleSymbols = staleResult.filter((s) => {
+      if (s.consumers === 0 && filesWithFunctions.has(s.file)) return false;
+      return true;
+    });
+    const unused = trueStaleSymbols.filter((s) => s.consumers === 0).length;
+    const singleUse = trueStaleCount - unused;
+    const parts: string[] = [];
+    if (unused > 0) parts.push(`${unused} unused`);
+    if (singleUse > 0) parts.push(`${singleUse} single-consumer (not in types file)`);
+    actions.push({
+      category: 'Stale abstractions',
+      description: `${parts.join(', ')} — premature abstraction`,
+      effort: 'low',
+      impact: 'medium',
+      count: trueStaleCount,
+      locRecoverable: staleResult
+        .filter((s) => s.consumers === 0 || !s.file.includes('types'))
+        .reduce((sum, r) => sum + r.loc, 0),
+    });
+  }
+
+  if (trueDriftCount > 0) {
+    const parts: string[] = [];
+    if (driftResult.unusedImports > 0) parts.push(`${driftResult.unusedImports} unused imports`);
+    if (driftResult.layerViolations > 0) parts.push(`${driftResult.layerViolations} layer violations`);
+    if (driftResult.patternDeviations > 0) parts.push(`${driftResult.patternDeviations} unique deps`);
+    actions.push({
+      category: 'Structural drift',
+      description: parts.join(', '),
+      effort: driftResult.layerViolations > 0 ? 'medium' : 'low',
+      impact: driftResult.layerViolations > 0 ? 'medium' : 'low',
+      count: trueDriftCount,
+      locRecoverable: 0,
+    });
+  }
+
+  // Sort: high impact + low effort first
+  const impactWeight = { high: 3, medium: 2, low: 1 };
+  const effortWeight = { low: 3, medium: 2, high: 1 };
+  actions.sort((a, b) => {
+    const scoreA = impactWeight[a.impact] * effortWeight[a.effort];
+    const scoreB = impactWeight[b.impact] * effortWeight[b.effort];
+    return scoreB - scoreA;
+  });
+
+  // ── Compute health score (0-100) ─────────────────────────
+  //
+  // Uses filtered counts (false positives removed).
+  // Deductions scale with codebase size so a 10-file project
+  // and a 1000-file project aren't penalized the same way.
+  const fileCount = Math.max(s.documents, 1);
+  const symbolCount = Math.max(s.symbols, 1);
+
+  let score = 100;
+
+  // Dead code: deduct based on % of symbols that are dead, not raw count
+  const deadPercent = trueDeadCount / symbolCount;
+  score -= Math.min(20, Math.round(deadPercent * 200));
+
+  // Isolated: same percentage-based
+  const isolatedPercent = trueIsolatedCount / symbolCount;
+  score -= Math.min(10, Math.round(isolatedPercent * 200));
+
+  // Cycles: these are always bad, flat penalty
+  score -= Math.min(15, cycleResult.length * 5);
+
+  // Similar pairs: only count true logic overlap, not boilerplate
+  score -= Math.min(10, trueSimilarCount * 2);
+
+  // Extract candidates: mild penalty
+  score -= Math.min(5, extractResult.length * 2);
+
+  // Wrappers: mild
+  score -= Math.min(3, wrapperResult.length);
+
+  // Passthroughs: mild
+  score -= Math.min(3, passthroughResult.length);
+
+  // Stale abstractions: percentage-based with filtered count
+  const stalePercent = trueStaleCount / Math.max(symbolCount * 0.1, 1);
+  score -= Math.min(8, Math.round(stalePercent * 10));
+
+  // Drift: percentage of files that deviate
+  const driftPercent = trueDriftCount / fileCount;
+  score -= Math.min(5, Math.round(driftPercent * 50));
+
+  // Complexity: only penalize extreme outliers
+  const extremeComplexity = complexResult.filter((r) => r.score > 50).length;
+  score -= Math.min(5, extremeComplexity * 2);
+
+  // Test coverage: significant penalty for low coverage
+  // 0% = -15, 25% = -11, 50% = -7, 75% = -4, 100% = 0
+  const coverageDeduction = Math.round(15 * (1 - testResult.percent / 100));
+  score -= coverageDeduction;
+
+  score = Math.max(0, Math.min(100, score));
+
+  return {
+    score,
+    overview: {
+      documents: s.documents,
+      symbols: s.symbols,
+      indexSizeBytes: s.indexSizeBytes,
+    },
+    findings: {
+      deadSymbols: trueDeadCount,
+      deadLoc: trueDeadLoc,
+      isolatedSymbols: trueIsolatedCount,
+      isolatedLoc: isolatedResult
+        .filter((s) => !isEntryPoint(s.relativePath))
+        .reduce((sum, s) => sum + s.loc, 0),
+      cycles: cycleResult.length,
+      similarPairs: trueSimilarCount,
+      extractionCandidates: extractResult.length,
+      wrappers: wrapperResult.length,
+      passthroughs: passthroughResult.length,
+      staleTypes: trueStaleCount,
+      driftedFiles: trueDriftCount,
+      complexityHotspotCount: complexResult.length,
+      testCoveragePercent: testResult.percent,
+    },
+    actions,
+    topComplexity: complexResult.slice(0, 5).map((r) => ({
+      symbol: r.shortName,
+      score: r.score,
+    })),
+  };
+}