feat: add include pattern matching for test file detection

Implement traf's `changedIncludedFilesPackages` mechanism in domino.
Changed files matching configurable regex patterns now directly mark
their owning project as affected, regardless of whether the file is
parsed by the semantic analyzer.

Default pattern matches test/spec files: `\.(spec|test)\.(ts|js)x?$`

This ensures that when only test files change for a project, the project
is still correctly detected as affected -- matching traf's behavior.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: EladBezalel

src/core.rs

@@ -7,12 +7,16 @@ use crate::types::{
   TrueAffectedConfig,
 };
 use crate::utils;
+use regex::Regex;
 use rustc_hash::{FxHashMap, FxHashSet};
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use tracing::debug;
 
+/// Default include pattern: matches test/spec files (.spec.ts, .test.tsx, etc.)
+const DEFAULT_INCLUDE_PATTERN: &str = r"\.(spec|test)\.(ts|js)x?$";
+
 /// Mutable state for tracking affected symbols during analysis
 struct AffectedState<'a> {
   affected_packages: &'a mut FxHashSet<String>,
@@ -69,6 +73,41 @@ fn find_affected_internal(
   let mut affected_packages = FxHashSet::default();
   let mut project_causes: FxHashMap<String, Vec<AffectCause>> = FxHashMap::default();
 
+  // Step 4b: Process included file patterns (e.g., test files)
+  // Files matching include patterns directly mark their owning project as affected,
+  // matching traf's changedIncludedFilesPackages behavior.
+  let default_include = vec![DEFAULT_INCLUDE_PATTERN.to_string()];
+  let include_patterns = if config.include.is_empty() {
+    &default_include
+  } else {
+    &config.include
+  };
+
+  let compiled_patterns: Vec<Regex> = include_patterns
+    .iter()
+    .filter_map(|p| match Regex::new(p) {
+      Ok(re) => Some(re),
+      Err(e) => {
+        debug!("Invalid include pattern '{}': {}", p, e);
+        None
+      }
+    })
+    .collect();
+
+  for changed_file in &changed_files {
+    let file_str = changed_file.file_path.to_string_lossy();
+    if compiled_patterns.iter().any(|re| re.is_match(&file_str)) {
+      if let Some(pkg) = utils::get_package_name_by_path(&changed_file.file_path, &config.projects)
+      {
+        debug!(
+          "Include pattern matched {:?}, adding package '{}'",
+          changed_file.file_path, pkg
+        );
+        affected_packages.insert(pkg);
+      }
+    }
+  }
+
   // Step 5: Partition changed files into source and non-source
   let (source_files, asset_files): (Vec<&ChangedFile>, Vec<&ChangedFile>) = changed_files
     .iter()
@@ -680,4 +719,26 @@ mod tests {
     assert!(affected.contains("lib1"));
     assert!(affected.contains("app")); // Should be added as implicit dependent
   }
+
+  #[test]
+  fn test_default_include_pattern_matches_test_files() {
+    let re = Regex::new(DEFAULT_INCLUDE_PATTERN).expect("Default pattern should compile");
+
+    // Should match spec/test files
+    assert!(re.is_match("proj1/utils.spec.ts"));
+    assert!(re.is_match("proj1/utils.test.ts"));
+    assert!(re.is_match("proj1/component.spec.tsx"));
+    assert!(re.is_match("proj1/component.test.tsx"));
+    assert!(re.is_match("proj1/helper.spec.js"));
+    assert!(re.is_match("proj1/helper.test.jsx"));
+    assert!(re.is_match("tests/validation/roof.step.test.ts"));
+
+    // Should NOT match regular source files
+    assert!(!re.is_match("proj1/utils.ts"));
+    assert!(!re.is_match("proj1/component.tsx"));
+    assert!(!re.is_match("proj1/index.js"));
+    assert!(!re.is_match("proj1/styles.css"));
+    assert!(!re.is_match("proj1/data.json"));
+    assert!(!re.is_match("proj1/test-utils.ts")); // "test" in name but not .test.ts
+  }
 }

src/types.rs

@@ -95,8 +95,8 @@ pub struct TrueAffectedConfig {
   pub root_ts_config: Option<PathBuf>,
   /// Projects in the workspace
   pub projects: Vec<Project>,
-  /// Additional file patterns to include
-  #[allow(dead_code)]
+  /// Additional file patterns to include (regex patterns).
+  /// When empty, defaults to matching test files: `\.(spec|test)\.(ts|js)x?$`
   pub include: Vec<String>,
   /// Paths to ignore
   #[allow(dead_code)]

tests/fixtures/monorepo

@@ -1 +1 @@
-Subproject commit 0d6eb7a3c5c9e4e0e19ec9a0cd80e017c55a9c59
+Subproject commit 10ec84a6d723c01d9fbca21e983373b552ef5bd6

tests/integration_test.rs

@@ -1479,3 +1479,113 @@ export function anotherFn() {
     "proj2 should be affected via asset → constant → export chain"
   );
 }
+
+/// Helper to get affected projects with custom include patterns
+fn get_affected_with_include(include: Vec<String>) -> Vec<String> {
+  let config = TrueAffectedConfig {
+    cwd: fixture_path(),
+    base: "main".to_string(),
+    root_ts_config: Some(PathBuf::from("tsconfig.json")),
+    projects: vec![
+      Project {
+        name: "proj1".to_string(),
+        source_root: PathBuf::from("proj1"),
+        ts_config: Some(PathBuf::from("proj1/tsconfig.json")),
+        implicit_dependencies: vec![],
+        targets: vec![],
+      },
+      Project {
+        name: "proj2".to_string(),
+        source_root: PathBuf::from("proj2"),
+        ts_config: Some(PathBuf::from("proj2/tsconfig.json")),
+        implicit_dependencies: vec![],
+        targets: vec![],
+      },
+      Project {
+        name: "proj3".to_string(),
+        source_root: PathBuf::from("proj3"),
+        ts_config: Some(PathBuf::from("proj3/tsconfig.json")),
+        implicit_dependencies: vec!["proj1".to_string()],
+        targets: vec![],
+      },
+    ],
+    include,
+    ignored_paths: vec![],
+  };
+
+  let profiler = Arc::new(Profiler::new(false));
+
+  find_affected(config, profiler)
+    .expect("Failed to find affected projects")
+    .affected_projects
+}
+
+#[test]
+fn test_included_test_file_marks_project_affected() {
+  let branch = TestBranch::new("test-include-spec-file");
+
+  // Create a .spec.ts file in proj1 (test file matching default include pattern)
+  branch.make_change(
+    "proj1/utils.spec.ts",
+    r#"import { proj1 } from './index';
+
+describe('proj1', () => {
+  it('should work', () => {
+    expect(proj1()).toBe('proj1');
+  });
+});
+"#,
+  );
+
+  // Now modify only the test file
+  branch.make_change(
+    "proj1/utils.spec.ts",
+    r#"import { proj1 } from './index';
+
+describe('proj1', () => {
+  it('should work correctly', () => {
+    expect(proj1()).toBe('proj1-modified');
+  });
+});
+"#,
+  );
+
+  // Use default include (empty vec triggers default test file pattern)
+  let affected = get_affected_with_include(vec![]);
+
+  // proj1 should be affected because the .spec.ts file matches the default include pattern
+  assert!(
+    affected.contains(&"proj1".to_string()),
+    "proj1 should be affected when a .spec.ts file changes (default include pattern). Got: {:?}",
+    affected
+  );
+}
+
+#[test]
+fn test_included_file_with_custom_pattern() {
+  let branch = TestBranch::new("test-include-custom");
+
+  // Create a .stories.ts file in proj2
+  branch.make_change(
+    "proj2/button.stories.ts",
+    r#"export const Primary = { args: { label: 'Click' } };
+"#,
+  );
+
+  // Modify the stories file
+  branch.make_change(
+    "proj2/button.stories.ts",
+    r#"export const Primary = { args: { label: 'Click Me' } };
+"#,
+  );
+
+  // Use a custom include pattern that matches .stories.ts files
+  let affected = get_affected_with_include(vec![r"\.stories\.(ts|js)x?$".to_string()]);
+
+  // proj2 should be affected because the .stories.ts file matches the custom pattern
+  assert!(
+    affected.contains(&"proj2".to_string()),
+    "proj2 should be affected when a .stories.ts file changes (custom include pattern). Got: {:?}",
+    affected
+  );
+}