fix(config): honor include/exclude globs in file collection (#981) (#994)

* fix(config): honor include/exclude globs in file collection (#981)

config.include and config.exclude were declared in DEFAULTS but never
consumed by either engine, so users' glob filters in .codegraphrc.json
had no effect. Both engines now compile the globs once and filter
collected paths (relative to project root, forward-slash normalized)
during initial walks and incremental fast-path rebuilds.

- New src/shared/globs.ts with compileGlobs + matchesAny (extracted
  from features/boundaries.ts so the collector and boundaries share
  one implementation)
- TS collector: passesIncludeExclude applied in collectFiles recursion
  and tryFastCollect so config changes take effect on incremental builds
- Rust collector: globset-based filter wired through collect_files and
  try_fast_collect; BuildConfig gains include/exclude fields
- Integration tests (wasm + native parity) cover exclude reject, include
  limit, combined filters, and empty-config default behavior

Fixes #981

Impact: 19 functions changed, 20 affected

* chore: sync Cargo.lock for globset dependency (#981)

* fix(globs): enforce path-component boundary for `**/<literal>` patterns (#994)

The `globToRegex` WASM-side glob compiler consumed the `/` after `**`
without adding a directory-boundary group, so `**/index.ts` compiled to
`^.*index\.ts$` and matched `barindex.ts`. The Rust `globset` crate
enforces the boundary, so the two engines disagreed on these patterns.

Compile `**/` as `(?:[^/]+/)*` — zero or more complete directory
segments — keeping parity with globset. Bare `**` (e.g. trailing in
`dir/**`) still compiles to `.*` so `dir/**` keeps matching `dir/a/b`.

Adds regression tests for `**/<literal>` and `dir/**`.

Impact: 1 functions changed, 8 affected

* fix(config): surface GlobSetBuilder::build errors instead of silently disabling filters (#994)

If `GlobSetBuilder::build()` returned `Err`, `build_glob_set` silently
returned `None` and all include/exclude filters were disabled — users
would see unexpected files in the graph with no clue why. Mirror the
per-pattern error path and log the failure via `eprintln!` before
falling back to `None`.

Impact: 1 functions changed, 8 affected

Author: carlos-alm

Cargo.lock

@@ -37,6 +37,7 @@ tree-sitter-haskell = "0.23"
 tree-sitter-ocaml = "0.24"
 rayon = "1"
 ignore = "0.4"
+globset = "0.4"
 sha2 = "0.10"
 # `bundled` embeds a second SQLite copy (better-sqlite3 already bundles one).
 # This is intentional: Windows CI lacks a system SQLite, and WAL coordination

crates/codegraph-core/Cargo.toml

@@ -549,15 +549,32 @@ fn collect_source_files(
                     &db_files,
                     &journal.changed,
                     &journal.removed,
+                    &config.include,
+                    &config.exclude,
                 )
             } else {
-                file_collector::collect_files(root_dir, &config.ignore_dirs)
+                file_collector::collect_files(
+                    root_dir,
+                    &config.ignore_dirs,
+                    &config.include,
+                    &config.exclude,
+                )
             }
         } else {
-            file_collector::collect_files(root_dir, &config.ignore_dirs)
+            file_collector::collect_files(
+                root_dir,
+                &config.ignore_dirs,
+                &config.include,
+                &config.exclude,
+            )
         }
     } else {
-        file_collector::collect_files(root_dir, &config.ignore_dirs)
+        file_collector::collect_files(
+            root_dir,
+            &config.ignore_dirs,
+            &config.include,
+            &config.exclude,
+        )
     }
 }
 

crates/codegraph-core/src/build_pipeline.rs

@@ -10,6 +10,17 @@ use serde::Deserialize;
 #[derive(Debug, Clone, Deserialize, Default)]
 #[serde(rename_all = "camelCase")]
 pub struct BuildConfig {
+    /// Glob patterns limiting which source files are included.
+    /// When non-empty, a file must match at least one pattern.
+    /// Matched against paths relative to the project root.
+    #[serde(default)]
+    pub include: Vec<String>,
+
+    /// Glob patterns excluding source files from the build.
+    /// Matched against paths relative to the project root.
+    #[serde(default)]
+    pub exclude: Vec<String>,
+
     /// Additional directory names to ignore during file collection.
     #[serde(default)]
     pub ignore_dirs: Vec<String>,
@@ -129,12 +140,16 @@ mod tests {
     fn deserialize_empty_config() {
         let config: BuildConfig = serde_json::from_str("{}").unwrap();
         assert!(config.ignore_dirs.is_empty());
+        assert!(config.include.is_empty());
+        assert!(config.exclude.is_empty());
         assert!(config.build.incremental);
     }
 
     #[test]
     fn deserialize_full_config() {
         let json = r#"{
+            "include": ["src/**/*.ts"],
+            "exclude": ["**/*.test.ts", "**/*.spec.ts"],
             "ignoreDirs": ["vendor", "tmp"],
             "build": {
                 "incremental": false,
@@ -145,6 +160,8 @@ mod tests {
             }
         }"#;
         let config: BuildConfig = serde_json::from_str(json).unwrap();
+        assert_eq!(config.include, vec!["src/**/*.ts"]);
+        assert_eq!(config.exclude, vec!["**/*.test.ts", "**/*.spec.ts"]);
         assert_eq!(config.ignore_dirs, vec!["vendor", "tmp"]);
         assert!(!config.build.incremental);
         assert_eq!(config.build.drift_threshold, 0.2);

crates/codegraph-core/src/config.rs

@@ -5,6 +5,7 @@
 //! (from BurntSushi/ripgrep) for gitignore-aware traversal.
 
 use crate::parser_registry::LanguageKind;
+use globset::{Glob, GlobSet, GlobSetBuilder};
 use std::collections::HashSet;
 use std::path::Path;
 
@@ -44,10 +45,77 @@ pub struct CollectResult {
     pub directories: HashSet<String>,
 }
 
+/// Compile a list of glob patterns into a `GlobSet`.
+///
+/// Invalid patterns are logged via `eprintln!` and skipped so a single bad
+/// entry in config can't take down the whole build.
+fn build_glob_set(patterns: &[String]) -> Option<GlobSet> {
+    if patterns.is_empty() {
+        return None;
+    }
+    let mut builder = GlobSetBuilder::new();
+    let mut added = 0usize;
+    for p in patterns {
+        match Glob::new(p) {
+            Ok(g) => {
+                builder.add(g);
+                added += 1;
+            }
+            Err(e) => {
+                eprintln!("codegraph: ignoring invalid glob pattern {p:?}: {e}");
+            }
+        }
+    }
+    if added == 0 {
+        return None;
+    }
+    match builder.build() {
+        Ok(set) => Some(set),
+        Err(e) => {
+            // Failing to build the GlobSet disables *all* include/exclude
+            // filters, which silently changes what files the build sees.
+            // Surface the error so users can correct their config instead of
+            // being confused by ignored filters.
+            eprintln!("codegraph: failed to build glob set: {e}");
+            None
+        }
+    }
+}
+
+/// `true` when the relative path passes the configured include/exclude filters.
+///
+/// `rel_path` must be relative to the project root and normalized to forward
+/// slashes. Mirrors `passesIncludeExclude` in `src/domain/graph/builder/helpers.ts`
+/// so both engines accept or reject the same set of files.
+pub fn passes_include_exclude(
+    rel_path: &str,
+    include: Option<&GlobSet>,
+    exclude: Option<&GlobSet>,
+) -> bool {
+    if let Some(set) = include {
+        if !set.is_match(rel_path) {
+            return false;
+        }
+    }
+    if let Some(set) = exclude {
+        if set.is_match(rel_path) {
+            return false;
+        }
+    }
+    true
+}
+
 /// Collect all source files under `root_dir`, respecting gitignore and ignore dirs.
 ///
 /// `extra_ignore_dirs` are additional directory names to skip (from config `ignoreDirs`).
-pub fn collect_files(root_dir: &str, extra_ignore_dirs: &[String]) -> CollectResult {
+/// `include_patterns` / `exclude_patterns` are file-level glob filters applied after
+/// the extension check, matched against paths relative to `root_dir`.
+pub fn collect_files(
+    root_dir: &str,
+    extra_ignore_dirs: &[String],
+    include_patterns: &[String],
+    exclude_patterns: &[String],
+) -> CollectResult {
     // Build an owned set of ignore dirs to avoid leaking memory.
     // The closure captures this owned set, so lifetimes are satisfied without Box::leak.
     let ignore_set: HashSet<String> = DEFAULT_IGNORE_DIRS
@@ -58,6 +126,10 @@ pub fn collect_files(root_dir: &str, extra_ignore_dirs: &[String]) -> CollectRes
 
     let ext_set: HashSet<&str> = SUPPORTED_EXTENSIONS.iter().copied().collect();
 
+    let include_set = build_glob_set(include_patterns);
+    let exclude_set = build_glob_set(exclude_patterns);
+    let root_path = Path::new(root_dir);
+
     let mut files = Vec::new();
     let mut directories = HashSet::new();
 
@@ -105,6 +177,19 @@ pub fn collect_files(root_dir: &str, extra_ignore_dirs: &[String]) -> CollectRes
             }
         }
 
+        // Apply file-level include/exclude globs against the relative path.
+        if include_set.is_some() || exclude_set.is_some() {
+            let rel = path
+                .strip_prefix(root_path)
+                .ok()
+                .and_then(|p| p.to_str())
+                .map(|s| s.replace('\\', "/"))
+                .unwrap_or_else(|| normalize_path(path));
+            if !passes_include_exclude(&rel, include_set.as_ref(), exclude_set.as_ref()) {
+                continue;
+            }
+        }
+
         let abs = normalize_path(path);
         if let Some(parent) = path.parent() {
             directories.insert(normalize_path(parent));
@@ -117,12 +202,18 @@ pub fn collect_files(root_dir: &str, extra_ignore_dirs: &[String]) -> CollectRes
 
 /// Reconstruct file list from DB file_hashes + journal deltas (fast path).
 ///
+/// Applies `include_patterns` / `exclude_patterns` so incremental builds honor
+/// config changes — the paths in the DB were collected under an earlier config
+/// that may have had different glob filters.
+///
 /// Returns `None` when the fast path isn't applicable.
 pub fn try_fast_collect(
     root_dir: &str,
     db_files: &[String],
     journal_changed: &[String],
     journal_removed: &[String],
+    include_patterns: &[String],
+    exclude_patterns: &[String],
 ) -> CollectResult {
     let mut file_set: HashSet<String> = db_files.iter().cloned().collect();
 
@@ -134,12 +225,22 @@ pub fn try_fast_collect(
         file_set.insert(changed.clone());
     }
 
+    let include_set = build_glob_set(include_patterns);
+    let exclude_set = build_glob_set(exclude_patterns);
+    let has_filters = include_set.is_some() || exclude_set.is_some();
+
     // Convert relative paths to absolute and compute directories
     let root = Path::new(root_dir);
     let mut files = Vec::with_capacity(file_set.len());
     let mut directories = HashSet::new();
 
     for rel_path in &file_set {
+        if has_filters {
+            let norm = rel_path.replace('\\', "/");
+            if !passes_include_exclude(&norm, include_set.as_ref(), exclude_set.as_ref()) {
+                continue;
+            }
+        }
         let abs = root.join(rel_path);
         let abs_str = normalize_path(&abs);
         if let Some(parent) = abs.parent() {
@@ -171,7 +272,7 @@ mod tests {
         fs::write(src.join("readme.md"), "# Hello").unwrap();
         fs::write(src.join("util.js"), "module.exports = {};").unwrap();
 
-        let result = collect_files(tmp.to_str().unwrap(), &[]);
+        let result = collect_files(tmp.to_str().unwrap(), &[], &[], &[]);
         let names: HashSet<String> = result
             .files
             .iter()
@@ -200,13 +301,61 @@ mod tests {
         fs::create_dir_all(&src).unwrap();
         fs::write(src.join("app.ts"), "").unwrap();
 
-        let result = collect_files(tmp.to_str().unwrap(), &[]);
+        let result = collect_files(tmp.to_str().unwrap(), &[], &[], &[]);
         assert_eq!(result.files.len(), 1);
         assert!(result.files[0].contains("app.ts"));
 
         let _ = fs::remove_dir_all(&tmp);
     }
 
+    #[test]
+    fn collect_honors_exclude_globs() {
+        let tmp = std::env::temp_dir().join("codegraph_collect_exclude_test");
+        let _ = fs::remove_dir_all(&tmp);
+        let src = tmp.join("src");
+        fs::create_dir_all(&src).unwrap();
+        fs::write(src.join("app.ts"), "").unwrap();
+        fs::write(src.join("app.test.ts"), "").unwrap();
+        fs::write(src.join("util.ts"), "").unwrap();
+
+        let exclude = vec!["**/*.test.ts".to_string()];
+        let result = collect_files(tmp.to_str().unwrap(), &[], &[], &exclude);
+        let names: HashSet<String> = result
+            .files
+            .iter()
+            .filter_map(|f| Path::new(f).file_name().map(|n| n.to_str().unwrap().to_string()))
+            .collect();
+        assert!(names.contains("app.ts"));
+        assert!(names.contains("util.ts"));
+        assert!(!names.contains("app.test.ts"), "exclude glob should reject matching files");
+
+        let _ = fs::remove_dir_all(&tmp);
+    }
+
+    #[test]
+    fn collect_honors_include_globs() {
+        let tmp = std::env::temp_dir().join("codegraph_collect_include_test");
+        let _ = fs::remove_dir_all(&tmp);
+        let src = tmp.join("src");
+        let tests = tmp.join("tests");
+        fs::create_dir_all(&src).unwrap();
+        fs::create_dir_all(&tests).unwrap();
+        fs::write(src.join("app.ts"), "").unwrap();
+        fs::write(tests.join("spec.ts"), "").unwrap();
+
+        let include = vec!["src/**".to_string()];
+        let result = collect_files(tmp.to_str().unwrap(), &[], &include, &[]);
+        let names: HashSet<String> = result
+            .files
+            .iter()
+            .filter_map(|f| Path::new(f).file_name().map(|n| n.to_str().unwrap().to_string()))
+            .collect();
+        assert!(names.contains("app.ts"));
+        assert!(!names.contains("spec.ts"), "include glob should reject non-matching files");
+
+        let _ = fs::remove_dir_all(&tmp);
+    }
+
     #[test]
     fn fast_collect_applies_deltas() {
         let root = "/project";
@@ -218,7 +367,7 @@ mod tests {
         let changed = vec!["src/d.ts".to_string()];
         let removed = vec!["src/b.ts".to_string()];
 
-        let result = try_fast_collect(root, &db_files, &changed, &removed);
+        let result = try_fast_collect(root, &db_files, &changed, &removed, &[], &[]);
         assert_eq!(result.files.len(), 3); // a, c, d
         let names: HashSet<&str> = result
             .files
@@ -230,4 +379,28 @@ mod tests {
         assert!(names.contains("c.ts"));
         assert!(names.contains("d.ts"));
     }
+
+    #[test]
+    fn fast_collect_honors_exclude_globs() {
+        let root = "/project";
+        let db_files = vec![
+            "src/a.ts".to_string(),
+            "src/a.test.ts".to_string(),
+            "src/b.ts".to_string(),
+        ];
+        let exclude = vec!["**/*.test.ts".to_string()];
+
+        let result = try_fast_collect(root, &db_files, &[], &[], &[], &exclude);
+        let names: HashSet<&str> = result
+            .files
+            .iter()
+            .map(|f| f.rsplit('/').next().unwrap_or(f))
+            .collect();
+        assert!(names.contains("a.ts"));
+        assert!(names.contains("b.ts"));
+        assert!(
+            !names.contains("a.test.ts"),
+            "fast path must filter out excluded files so incremental builds honor config changes"
+        );
+    }
 }