@monoes/monograph 1.2.0 → 1.2.2

package/src/graph/baseline.ts

@@ -14,6 +14,7 @@ export interface BaselineFinding {
   nodeId: string;
   nodeName: string;
   filePath: string | null;
+  startLine: number | null;
   savedAt: string; // ISO timestamp
   /** 16-hex SHA-256 fingerprint for stable deduplication across runs */
   fingerprint?: string;
@@ -103,12 +104,12 @@ export function extractFindingsFromDb(
 
   // Isolated nodes (no incoming or outgoing edges)
   const isolated = db.prepare(`
-    SELECT n.id, n.name, n.file_path, n.label
+    SELECT n.id, n.name, n.file_path, n.start_line, n.label
     FROM nodes n
     WHERE NOT EXISTS (SELECT 1 FROM edges e WHERE e.source_id = n.id OR e.target_id = n.id)
     AND n.label IN ('Function', 'Class', 'Method', 'Interface', 'Variable', 'Module', 'File')
     LIMIT 500
-  `).all() as { id: string; name: string; file_path: string | null; label: string }[];
+  `).all() as { id: string; name: string; file_path: string | null; start_line: number | null; label: string }[];
 
   for (const n of isolated) {
     findings.push({
@@ -117,6 +118,7 @@ export function extractFindingsFromDb(
       nodeId: n.id,
       nodeName: n.name,
       filePath: n.file_path,
+      startLine: n.start_line ?? null,
       savedAt: new Date().toISOString(),
       fingerprint: fingerprintFinding('isolated_node', n.file_path ?? '', n.id),
     });
@@ -124,7 +126,7 @@ export function extractFindingsFromDb(
 
   // God nodes (degree > 50)
   const gods = db.prepare(`
-    SELECT n.id, n.name, n.file_path,
+    SELECT n.id, n.name, n.file_path, n.start_line,
            COUNT(DISTINCT e1.id) + COUNT(DISTINCT e2.id) as degree
     FROM nodes n
     LEFT JOIN edges e1 ON e1.source_id = n.id
@@ -133,7 +135,7 @@ export function extractFindingsFromDb(
     HAVING degree > 50
     ORDER BY degree DESC
     LIMIT 100
-  `).all() as { id: string; name: string; file_path: string | null; degree: number }[];
+  `).all() as { id: string; name: string; file_path: string | null; start_line: number | null; degree: number }[];
 
   for (const n of gods) {
     findings.push({
@@ -142,6 +144,7 @@ export function extractFindingsFromDb(
       nodeId: n.id,
       nodeName: n.name,
       filePath: n.file_path,
+      startLine: n.start_line ?? null,
       savedAt: new Date().toISOString(),
       fingerprint: fingerprintFinding('god_node', n.file_path ?? '', n.id),
     });
@@ -150,12 +153,12 @@ export function extractFindingsFromDb(
   // Surprise edges: non-EXTRACTED confidence (cross-community low-confidence edges)
   const surprises = db.prepare(`
     SELECT DISTINCT e.id as edge_id, e.source_id, e.target_id, e.confidence,
-           n.name as src_name, n.file_path as src_file
+           n.name as src_name, n.file_path as src_file, n.start_line as src_line
     FROM edges e
     JOIN nodes n ON n.id = e.source_id
     WHERE e.confidence != 'EXTRACTED'
     LIMIT 200
-  `).all() as { edge_id: string; source_id: string; target_id: string; confidence: string; src_name: string; src_file: string | null }[];
+  `).all() as { edge_id: string; source_id: string; target_id: string; confidence: string; src_name: string; src_file: string | null; src_line: number | null }[];
 
   for (const e of surprises) {
     findings.push({
@@ -164,30 +167,28 @@ export function extractFindingsFromDb(
       nodeId: e.source_id,
       nodeName: e.src_name,
       filePath: e.src_file,
+      startLine: e.src_line ?? null,
       savedAt: new Date().toISOString(),
       fingerprint: fingerprintFinding('surprise', e.source_id, e.target_id),
     });
   }
 
   // Bridge nodes: nodes whose edges span more than one community_id
+  // Use JOIN+GROUP BY instead of correlated subqueries to avoid N*2 subquery executions
   const bridges = db.prepare(`
-    SELECT n.id, n.name, n.file_path
+    SELECT n.id, n.name, n.file_path, n.start_line,
+           COUNT(DISTINCT CASE WHEN e_out.source_id = n.id AND n_tgt.community_id != n.community_id THEN n_tgt.community_id END) +
+           COUNT(DISTINCT CASE WHEN e_in.target_id = n.id AND n_src.community_id != n.community_id THEN n_src.community_id END) AS cross_communities
     FROM nodes n
+    LEFT JOIN edges e_out ON e_out.source_id = n.id
+    LEFT JOIN nodes n_tgt ON n_tgt.id = e_out.target_id AND n_tgt.community_id IS NOT NULL
+    LEFT JOIN edges e_in ON e_in.target_id = n.id
+    LEFT JOIN nodes n_src ON n_src.id = e_in.source_id AND n_src.community_id IS NOT NULL
     WHERE n.community_id IS NOT NULL
-    AND (
-      SELECT COUNT(DISTINCT n_tgt.community_id)
-      FROM edges e_out
-      JOIN nodes n_tgt ON n_tgt.id = e_out.target_id
-      WHERE e_out.source_id = n.id AND n_tgt.community_id != n.community_id
-    ) +
-    (
-      SELECT COUNT(DISTINCT n_src.community_id)
-      FROM edges e_in
-      JOIN nodes n_src ON n_src.id = e_in.source_id
-      WHERE e_in.target_id = n.id AND n_src.community_id != n.community_id
-    ) >= 2
+    GROUP BY n.id
+    HAVING cross_communities >= 2
     LIMIT 100
-  `).all() as { id: string; name: string; file_path: string | null }[];
+  `).all() as { id: string; name: string; file_path: string | null; start_line: number | null }[];
 
   for (const n of bridges) {
     findings.push({
@@ -196,6 +197,7 @@ export function extractFindingsFromDb(
       nodeId: n.id,
       nodeName: n.name,
       filePath: n.file_path,
+      startLine: n.start_line ?? null,
       savedAt: new Date().toISOString(),
       fingerprint: fingerprintFinding('bridge_node', n.file_path ?? '', n.id),
     });
@@ -203,13 +205,13 @@ export function extractFindingsFromDb(
 
   // Unreachable exports: exported nodes with no incoming edges
   const unreachableExports = db.prepare(`
-    SELECT n.id, n.name, n.file_path
+    SELECT n.id, n.name, n.file_path, n.start_line
     FROM nodes n
     WHERE n.is_exported = 1
     AND n.label IN ('Function', 'Class', 'Method', 'Interface', 'Variable')
     AND NOT EXISTS (SELECT 1 FROM edges e WHERE e.target_id = n.id)
     LIMIT 300
-  `).all() as { id: string; name: string; file_path: string | null }[];
+  `).all() as { id: string; name: string; file_path: string | null; start_line: number | null }[];
 
   for (const n of unreachableExports) {
     findings.push({
@@ -218,6 +220,7 @@ export function extractFindingsFromDb(
       nodeId: n.id,
       nodeName: n.name,
       filePath: n.file_path,
+      startLine: n.start_line ?? null,
       savedAt: new Date().toISOString(),
       fingerprint: fingerprintFinding('unreachable_export', n.file_path ?? '', n.id),
     });
@@ -226,12 +229,12 @@ export function extractFindingsFromDb(
   // Ambiguous edges: edges with AMBIGUOUS confidence
   const ambiguousEdges = db.prepare(`
     SELECT DISTINCT e.id as edge_id, e.source_id, e.target_id,
-           n.name as src_name, n.file_path as src_file
+           n.name as src_name, n.file_path as src_file, n.start_line as src_line
     FROM edges e
     JOIN nodes n ON n.id = e.source_id
     WHERE e.confidence = 'AMBIGUOUS'
     LIMIT 200
-  `).all() as { edge_id: string; source_id: string; target_id: string; src_name: string; src_file: string | null }[];
+  `).all() as { edge_id: string; source_id: string; target_id: string; src_name: string; src_file: string | null; src_line: number | null }[];
 
   for (const e of ambiguousEdges) {
     findings.push({
@@ -240,6 +243,7 @@ export function extractFindingsFromDb(
       nodeId: e.source_id,
       nodeName: e.src_name,
       filePath: e.src_file,
+      startLine: e.src_line ?? null,
       savedAt: new Date().toISOString(),
       fingerprint: fingerprintFinding('ambiguous_edge', e.source_id, e.target_id),
     });
@@ -367,3 +371,53 @@ export function computeTrend(
 
   return { metrics, overallDirection };
 }
+
+/** Format a list of ComparedFindings as structured text with file:line hints. */
+export function formatComparedFindings(findings: ComparedFinding[], showAll = false): string {
+  if (findings.length === 0) return 'Baseline comparison: no findings.';
+
+  const newFindings = findings.filter(f => f.introduced);
+  const existing = findings.filter(f => !f.introduced);
+
+  const lines: string[] = [
+    `Baseline comparison: ${findings.length} total finding(s) — ${newFindings.length} new, ${existing.length} known.`,
+    '',
+  ];
+
+  if (newFindings.length > 0) {
+    lines.push(`New findings (${newFindings.length}):`);
+    for (const f of newFindings) {
+      const ref = f.filePath
+        ? f.startLine != null ? `${f.filePath}:${f.startLine}` : f.filePath
+        : f.nodeId;
+      lines.push(`  [${f.type}]  ${f.nodeName}  ${ref}`);
+    }
+    lines.push('');
+  }
+
+  if (showAll && existing.length > 0) {
+    lines.push(`Known findings (${existing.length}):`);
+    for (const f of existing) {
+      const ref = f.filePath
+        ? f.startLine != null ? `${f.filePath}:${f.startLine}` : f.filePath
+        : f.nodeId;
+      lines.push(`  [${f.type}]  ${f.nodeName}  ${ref}`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n').trimEnd();
+}
+
+/** Format a TrendReport as structured text for LLM consumption. */
+export function formatTrendReport(report: TrendReport): string {
+  const lines: string[] = [
+    `Graph trend: ${report.overallDirection}`,
+    '',
+  ];
+  for (const m of report.metrics) {
+    const deltaStr = m.delta > 0 ? `+${m.delta}` : `${m.delta}`;
+    lines.push(`  ${m.symbol} ${m.metric}: ${m.previous} → ${m.current} (${deltaStr})  [${m.direction}]`);
+  }
+  return lines.join('\n');
+}

package/src/graph/clone-detector.ts

@@ -29,39 +29,29 @@ function baseName(filePath: string): string {
   return filePath.replace(/^.*[\\/]/, '');
 }
 
-/** Compute Jaccard similarity between two multisets (represented as token arrays). */
-function jaccardSimilarity(a: string[], b: string[]): number {
+/**
+ * Compute both Jaccard similarity and shared token count in a single pass.
+ * Avoids building the countA Map twice (previously done separately in
+ * jaccardSimilarity and sharedTokenCount).
+ */
+function computeSimilarityAndShared(a: string[], b: string[]): { similarity: number; shared: number } {
   const countA = new Map<string, number>();
-  const countB = new Map<string, number>();
   for (const t of a) countA.set(t, (countA.get(t) ?? 0) + 1);
-  for (const t of b) countB.set(t, (countB.get(t) ?? 0) + 1);
 
   let intersection = 0;
-  for (const [token, ca] of countA) {
-    const cb = countB.get(token) ?? 0;
-    intersection += Math.min(ca, cb);
-  }
-
-  const union = a.length + b.length - intersection;
-  return union === 0 ? 1 : intersection / union;
-}
-
-/** Count tokens shared between two multisets. */
-function sharedTokenCount(a: string[], b: string[]): number {
-  const countA = new Map<string, number>();
-  for (const t of a) countA.set(t, (countA.get(t) ?? 0) + 1);
-
-  let shared = 0;
   const seen = new Map<string, number>();
   for (const t of b) {
     const limit = countA.get(t) ?? 0;
     const used = seen.get(t) ?? 0;
     if (used < limit) {
-      shared++;
+      intersection++;
       seen.set(t, used + 1);
     }
   }
-  return shared;
+
+  const union = a.length + b.length - intersection;
+  const similarity = union === 0 ? 1 : intersection / union;
+  return { similarity, shared: intersection };
 }
 
 export function detectClones(
@@ -78,10 +68,12 @@ export function detectClones(
   const pairs: ClonePair[] = [];
   const involvedFiles = new Set<string>();
 
-  // Pre-compute tokens for each file
-  const tokenMap = new Map<string, string[]>();
+  // Pre-compute path tokens and name tokens for each file
+  const tokenMap = new Map<string, { pathTokens: string[]; nameTokens: string[] }>();
   for (const row of rows) {
-    tokenMap.set(row.file_path, tokenizePath(row.file_path));
+    const pathTokens = tokenizePath(row.file_path);
+    const nameTokens = tokenizePath(baseName(row.file_path));
+    tokenMap.set(row.file_path, { pathTokens, nameTokens });
   }
 
   // Compare all pairs
@@ -89,22 +81,16 @@ export function detectClones(
     for (let j = i + 1; j < rows.length; j++) {
       const pathA = rows[i].file_path;
       const pathB = rows[j].file_path;
-      const tokensA = tokenMap.get(pathA)!;
-      const tokensB = tokenMap.get(pathB)!;
+      const entryA = tokenMap.get(pathA)!;
+      const entryB = tokenMap.get(pathB)!;
 
-      const sim = jaccardSimilarity(tokensA, tokensB);
-      const shared = sharedTokenCount(tokensA, tokensB);
+      const { similarity: sim, shared } = computeSimilarityAndShared(entryA.pathTokens, entryB.pathTokens);
 
       if (sim < minSimilarity || shared < minTokens) {
         // Also check near-duplicate file names (same name, different dir)
-        const nameA = baseName(pathA);
-        const nameB = baseName(pathB);
-        const nameTokensA = tokenizePath(nameA);
-        const nameTokensB = tokenizePath(nameB);
-        const nameSim = jaccardSimilarity(nameTokensA, nameTokensB);
-        const nameShared = sharedTokenCount(nameTokensA, nameTokensB);
-
-        if (nameSim >= minSimilarity && nameShared >= Math.min(minTokens, nameTokensA.length)) {
+        const { similarity: nameSim, shared: nameShared } = computeSimilarityAndShared(entryA.nameTokens, entryB.nameTokens);
+
+        if (nameSim >= minSimilarity && nameShared >= Math.min(minTokens, entryA.nameTokens.length)) {
           // Same-name files in different directories → structural similarity
           const pair: ClonePair = {
             fileA: pathA,

package/src/graph/clone-families.ts

@@ -30,7 +30,8 @@ export interface CloneFamily {
 }
 
 function fileSetKey(files: string[]): string {
-  return [...files].sort().join('|');
+  // Avoid spread allocation: sort a copy directly
+  return files.slice().sort().join('|');
 }
 
 function generateSuggestions(family: Omit<CloneFamily, 'suggestions'>): RefactoringSuggestion[] {
@@ -46,10 +47,14 @@ function generateSuggestions(family: Omit<CloneFamily, 'suggestions'>): Refactor
     });
   } else {
     // Check if all files are in the same directory → MergeDirectories
-    const dirs = [...new Set(family.files.map(f => {
-      const parts = f.replace(/\\/g, '/').split('/');
-      return parts.slice(0, -1).join('/');
-    }))];
+    // Use Set directly to avoid spread+map intermediate array
+    const dirSet = new Set<string>();
+    for (const f of family.files) {
+      const slash = f.replace(/\\/g, '/');
+      const lastSlash = slash.lastIndexOf('/');
+      dirSet.add(lastSlash >= 0 ? slash.slice(0, lastSlash) : '.');
+    }
+    const dirs = [...dirSet];
     if (dirs.length > 1 && family.files.length >= 3) {
       suggestions.push({
         kind: 'MergeDirectories',
@@ -81,12 +86,29 @@ export function groupIntoFamilies(groups: CloneGroup[]): CloneFamily[] {
     familyMap.get(key)!.groups.push(group);
   }
 
-  return [...familyMap.values()].map(({ files, groups }) => {
+  // Build output array without intermediate spread + map allocation
+  const result: CloneFamily[] = [];
+  for (const { files, groups } of familyMap.values()) {
     const fileList = [...files].sort();
-    const totalDuplicatedLines = groups.reduce((s, g) => s + g.duplicatedLines, 0);
+    let totalDuplicatedLines = 0;
+    for (const g of groups) totalDuplicatedLines += g.duplicatedLines;
     const base = { files: fileList, groups, totalDuplicatedLines };
-    return { ...base, suggestions: generateSuggestions(base) };
-  }).sort((a, b) => b.totalDuplicatedLines - a.totalDuplicatedLines);
+    result.push({ ...base, suggestions: generateSuggestions(base) });
+  }
+  return result.sort((a, b) => b.totalDuplicatedLines - a.totalDuplicatedLines);
+}
+
+/** Format clone families as structured text for LLM consumption. */
+export function formatCloneFamilies(families: CloneFamily[]): string {
+  if (families.length === 0) return 'No clone families detected.';
+  const lines: string[] = [`Clone Families (${families.length} total):`];
+  for (const f of families.slice(0, 20)) {
+    lines.push(`\n  ${f.totalDuplicatedLines} duplicated lines across ${f.files.length} files:`);
+    for (const file of f.files) lines.push(`    ${file}`);
+    for (const s of f.suggestions) lines.push(`  -> [${s.kind}] ${s.description}`);
+  }
+  if (families.length > 20) lines.push(`\n  ... and ${families.length - 20} more families`);
+  return lines.join('\n');
 }
 
 export function cloneFamilySummary(families: CloneFamily[]): {
@@ -97,12 +119,14 @@ export function cloneFamilySummary(families: CloneFamily[]): {
   const byKind: Record<RefactoringKind, number> = {
     ExtractFunction: 0, ExtractModule: 0, MergeDirectories: 0,
   };
+  let totalDuplicatedLines = 0;
   for (const f of families) {
+    totalDuplicatedLines += f.totalDuplicatedLines;
     for (const s of f.suggestions) byKind[s.kind]++;
   }
   return {
     totalFamilies: families.length,
-    totalDuplicatedLines: families.reduce((s, f) => s + f.totalDuplicatedLines, 0),
+    totalDuplicatedLines,
     byKind,
   };
 }

package/src/graph/codeowners-extended.ts

@@ -58,3 +58,57 @@ export function ownerLabel(co: CodeOwnersLike, relativePath: string): string {
   }
   return owners[0];
 }
+
+export interface OwnershipAggregate {
+  /** Paths that have no owner. */
+  unowned: string[];
+  /** Map from owner handle → list of owned file paths. */
+  byOwner: Map<string, string[]>;
+  /** Total files analyzed. */
+  totalFiles: number;
+}
+
+/**
+ * Aggregate ownership across a list of relative paths in a single pass.
+ * Each file is attributed to its primary owner (first in the owners list).
+ */
+export function aggregateOwnership(
+  co: CodeOwnersLike,
+  relativePaths: string[],
+): OwnershipAggregate {
+  const unowned: string[] = [];
+  const byOwner = new Map<string, string[]>();
+
+  for (const path of relativePaths) {
+    const owners = co.ownersOf(path);
+    if (!owners || owners.length === 0) {
+      unowned.push(path);
+    } else {
+      const primary = owners[0];
+      let bucket = byOwner.get(primary);
+      if (!bucket) { bucket = []; byOwner.set(primary, bucket); }
+      bucket.push(path);
+    }
+  }
+
+  return { unowned, byOwner, totalFiles: relativePaths.length };
+}
+
+/**
+ * Format an OwnershipAggregate as structured text for LLM consumption.
+ */
+export function formatOwnershipReport(agg: OwnershipAggregate): string {
+  const lines: string[] = [
+    `Ownership report: ${agg.totalFiles} files, ${agg.byOwner.size} owner(s), ${agg.unowned.length} unowned`,
+    '',
+  ];
+  // Sort owners by file count descending
+  const sorted = Array.from(agg.byOwner.entries()).sort((a, b) => b[1].length - a[1].length);
+  for (const [owner, files] of sorted) {
+    lines.push(`  ${owner}: ${files.length} file(s)`);
+  }
+  if (agg.unowned.length > 0) {
+    lines.push(`  ${UNOWNED_LABEL}: ${agg.unowned.length} file(s)`);
+  }
+  return lines.join('\n');
+}

package/src/graph/codeowners-gitlab.ts

@@ -86,6 +86,12 @@ function pathMatchesPattern(filePath: string, pattern: string): boolean {
   return norm === pat || norm.endsWith('/' + pat) || norm.startsWith(pat + '/');
 }
 
+/** Single-call helper — avoids triple matchOwners invocations when callers need all three fields. */
+export function singleFileOwnership(entries: CodeownersEntry[], filePath: string): { section: string; owners: string[]; ownerCount: number } {
+  const { owners, section } = matchOwners(entries, filePath);
+  return { section: section ?? NO_SECTION_LABEL, owners, ownerCount: owners.length };
+}
+
 export function ownerCountOf(entries: CodeownersEntry[], filePath: string): number {
   return matchOwners(entries, filePath).owners.length;
 }
@@ -102,3 +108,43 @@ export function sectionAndOwnersOf(entries: CodeownersEntry[], filePath: string)
 export function hasSections(entries: CodeownersEntry[]): boolean {
   return entries.some(e => e.section !== undefined);
 }
+
+export interface CodeownersGitlabReport {
+  totalEntries: number;
+  hasSections: boolean;
+  sectionNames: string[];
+  ownershipSummary: Array<{ file: string; section: string; owners: string[] }>;
+}
+
+/**
+ * Format a batch file-ownership report for LLM consumption.
+ * Uses singleFileOwnership() to avoid N*3 matchOwners scans.
+ */
+export function formatCodeownersGitlab(entries: CodeownersEntry[], filePaths: string[]): string {
+  if (entries.length === 0) return 'No CODEOWNERS entries found.';
+
+  const sections = new Set<string>();
+  const rows: Array<{ file: string; section: string; owners: string[] }> = [];
+  for (const fp of filePaths) {
+    const { section, owners } = singleFileOwnership(entries, fp);
+    sections.add(section);
+    rows.push({ file: fp, section, owners });
+  }
+
+  const unowned = rows.filter(r => r.owners.length === 0);
+  const lines: string[] = [
+    `CODEOWNERS (GitLab) — ${entries.length} entries, ${sections.size} section(s)`,
+    `Sections: ${[...sections].join(', ') || '(none)'}`,
+    `Files scanned: ${filePaths.length}  Unowned: ${unowned.length}`,
+    '',
+  ];
+  for (const r of rows) {
+    const ownerStr = r.owners.length > 0 ? r.owners.join(' ') : UNOWNED_LABEL;
+    lines.push(`  ${r.file}  [${r.section}]  ${ownerStr}`);
+  }
+  if (unowned.length > 0) {
+    lines.push('', `Unowned files (${unowned.length}):`);
+    for (const r of unowned) lines.push(`  ${r.file}`);
+  }
+  return lines.join('\n');
+}

package/src/graph/codeowners.ts

@@ -98,6 +98,32 @@ export function parseCodeowners(repoRoot: string): CodeownersEntry[] {
   return entries;
 }
 
+// ── Compiled entry (regex precompiled once) ────────────────────────────────────
+
+export interface CompiledEntry {
+  owners: string[];
+  re: RegExp;
+}
+
+/**
+ * Compile an array of CodeownersEntry into CompiledEntry objects so that
+ * globToRegex() runs exactly once per pattern instead of once per file lookup.
+ */
+export function compileEntries(entries: CodeownersEntry[]): CompiledEntry[] {
+  return entries.map(e => ({ owners: e.owners, re: globToRegex(e.pattern) }));
+}
+
+// Resolve owner for a single file path using precompiled regexes.
+// Last matching entry wins (GitHub semantics).
+export function resolveOwnerCompiled(compiled: CompiledEntry[], filePath: string): string[] {
+  const normalised = filePath.replace(/\\/g, '/').replace(/^\.\//, '');
+  let lastMatch: CompiledEntry | null = null;
+  for (const entry of compiled) {
+    if (entry.re.test(normalised)) lastMatch = entry;
+  }
+  return lastMatch ? lastMatch.owners : [];
+}
+
 // Resolve owner for a single file path (relative to repoRoot)
 // Last matching entry wins
 export function resolveOwner(entries: CodeownersEntry[], filePath: string): string[] {
@@ -121,6 +147,9 @@ export function annotateOwnership(
   repoRoot: string,
 ): { annotated: number; unowned: number } {
   const entries = parseCodeowners(repoRoot);
+  // Compile regexes once for all file nodes — avoids O(files * patterns) re-compilations.
+  const compiled = compileEntries(entries);
+
   const fileNodes = db
     .prepare(`SELECT id, file_path, properties FROM nodes WHERE label = 'File' AND file_path IS NOT NULL`)
     .all() as { id: string; file_path: string; properties: string | null }[];
@@ -133,7 +162,7 @@ export function annotateOwnership(
   const updateAll = db.transaction(() => {
     for (const node of fileNodes) {
       const relPath = relative(repoRoot, node.file_path).replace(/\\/g, '/');
-      const owners = resolveOwner(entries, relPath);
+      const owners = resolveOwnerCompiled(compiled, relPath);
       const existing = node.properties ? JSON.parse(node.properties) : {};
       const updated = { ...existing, codeowners: owners };
       update.run(JSON.stringify(updated), node.id);
@@ -158,6 +187,8 @@ export function groupByOwner<T extends { filePath?: string | null }>(
   findings: T[],
   entries: CodeownersEntry[],
 ): Map<string, T[]> {
+  // Compile patterns once for all findings to avoid O(findings * patterns) regex constructions.
+  const compiled = compileEntries(entries);
   const result = new Map<string, T[]>();
 
   for (const finding of findings) {
@@ -168,7 +199,7 @@ export function groupByOwner<T extends { filePath?: string | null }>(
       continue;
     }
 
-    const owners = resolveOwner(entries, finding.filePath);
+    const owners = resolveOwnerCompiled(compiled, finding.filePath);
     if (owners.length === 0) {
       const bucket = result.get('unowned') ?? [];
       bucket.push(finding);