Fix per-file RegexSet recompilation in find_library_anchors

The find_library_anchors function was creating a new RegexSet on every
file scan by collecting include patterns and compiling them fresh. With
~1000 patterns, this added significant overhead per file.

Fix: Pre-compile the include RegexSet per language during PatternSet
initialization and store library ownership indices. The function now
uses the pre-compiled set directly.

Performance improvement:
- library_anchors/python: 228µs → 25µs (~9x faster)
- full_pipeline/python: 3.07ms → 2.75ms (~10% faster)
- directory_scale/files/1000: 246ms → 235ms (~5% faster)

Generated with [Claude Code](https://claude.ai/code)
via [Happy](https://happy.engineering)

Co-Authored-By: Claude <noreply@anthropic.com>
Co-Authored-By: Happy <yesreply@happy.engineering>

Author: 3 people

src/patterns.rs

@@ -73,11 +73,21 @@ struct RawParameterPattern {
     default_value: Option<toml::Value>,
 }
 
+/// Pre-compiled include patterns with ownership tracking for find_library_anchors
+#[derive(Debug, Clone)]
+pub struct IncludeSetWithOwners {
+    pub regex_set: RegexSet,
+    /// Maps each regex index to its library index in PatternSet::libraries
+    pub library_indices: Vec<usize>,
+}
+
 #[derive(Debug, Clone)]
 pub struct PatternSet {
     pub libraries: Vec<Library>,
     pub include_sets: HashMap<Language, RegexSet>,
     pub api_sets: HashMap<Language, RegexSet>,
+    /// Pre-compiled include patterns per language with library ownership for find_library_anchors
+    pub include_sets_with_owners: HashMap<Language, IncludeSetWithOwners>,
 }
 
 #[derive(Debug, Clone)]
@@ -173,11 +183,16 @@ impl PatternSet {
         }
         let mut include_patterns: HashMap<Language, Vec<String>> = HashMap::new();
         let mut api_patterns: HashMap<Language, Vec<String>> = HashMap::new();
-        for lib in &libraries {
+        // Track which library owns each include pattern (for find_library_anchors)
+        let mut include_owners: HashMap<Language, Vec<usize>> = HashMap::new();
+
+        for (lib_idx, lib) in libraries.iter().enumerate() {
             for lang in &lib.languages {
                 let include_entry = include_patterns.entry(*lang).or_default();
+                let owners_entry = include_owners.entry(*lang).or_default();
                 for re in &lib.include_regexes {
                     include_entry.push(re.as_str().to_string());
+                    owners_entry.push(lib_idx);
                 }
                 let api_entry = api_patterns.entry(*lang).or_default();
                 for re in &lib.api_regexes {
@@ -188,9 +203,19 @@ impl PatternSet {
 
         let mut include_sets = HashMap::new();
         let mut api_sets = HashMap::new();
+        let mut include_sets_with_owners = HashMap::new();
+
         for (lang, patterns) in include_patterns {
             if !patterns.is_empty() {
-                include_sets.insert(lang, RegexSet::new(patterns)?);
+                let regex_set = RegexSet::new(&patterns)?;
+                include_sets.insert(lang, regex_set.clone());
+                include_sets_with_owners.insert(
+                    lang,
+                    IncludeSetWithOwners {
+                        regex_set,
+                        library_indices: include_owners.remove(&lang).unwrap_or_default(),
+                    },
+                );
             }
         }
         for (lang, patterns) in api_patterns {
@@ -203,6 +228,7 @@ impl PatternSet {
             libraries,
             include_sets,
             api_sets,
+            include_sets_with_owners,
         })
     }
 

src/scan.rs

@@ -1,6 +1,6 @@
 use ahash::{AHashMap as HashMap, AHashSet as HashSet};
 use anyhow::{Context, Result};
-use regex::{Regex, RegexSet};
+use regex::Regex;
 use tree_sitter::{Language as TsLanguage, Node, Parser, Point, Tree};
 
 use crate::patterns::{Language, ParameterPattern, PatternSet};
@@ -105,9 +105,8 @@ pub fn find_library_anchors<'a>(
     patterns: &'a PatternSet,
 ) -> Vec<LibraryHit<'a>> {
     let mut hits = Vec::new();
-    let mut include_patterns = Vec::new();
-    let mut include_owners = Vec::new();
 
+    // Handle libraries without include patterns (fallback to api_regexes)
     for lib in &patterns.libraries {
         if !lib.languages.contains(&lang) {
             continue;
@@ -121,27 +120,23 @@ pub fn find_library_anchors<'a>(
                     column: 1,
                 });
             }
-            continue;
-        }
-        for re in &lib.include_regexes {
-            include_patterns.push(re.as_str().to_string());
-            include_owners.push(&lib.name);
         }
     }
 
-    if include_patterns.is_empty() {
+    // Use pre-compiled include set with ownership tracking
+    let Some(include_set_with_owners) = patterns.include_sets_with_owners.get(&lang) else {
         return hits;
-    }
+    };
 
-    let include_set = RegexSet::new(&include_patterns).expect("valid include regexes");
     for node in import_like_nodes(lang, tree.root_node()) {
         let text = node.utf8_text(content.as_bytes()).unwrap_or("");
-        let matches = include_set.matches(text);
+        let matches = include_set_with_owners.regex_set.matches(text);
         if matches.matched_any() {
             let Point { row, column } = node.start_position();
             for idx in matches.iter() {
+                let lib_idx = include_set_with_owners.library_indices[idx];
                 hits.push(LibraryHit {
-                    library_name: include_owners[idx],
+                    library_name: &patterns.libraries[lib_idx].name,
                     line: row + 1,
                     column: column + 1,
                 });