release: v0.5.13 — auto-ignore git subtree imports, fix stale cache after ignore-config change

Two compounding problems made vendored upstream code (effect, etc.) flood the
flow groups in repos that use `git subtree add` to vendor dependencies.
On the otel-outbox-tracing-sentry worktree this surfaced as 3,500 files
from `repos/effect/` swamping the 400 files of real changes.

1. No subtree awareness. Diffcore had no way to know that `repos/effect/`
   was vendored code rather than first-party source. Users had to manually
   add `repos/effect/**` to `[ignore].paths` in `.diffcore.toml`, and most
   never did because the source of the noise wasn't obvious.

2. Stale analysis cache. Even when users added the ignore pattern, the
   on-disk analysis cache at `.diffcore/cache/<sha>.json` didn't include
   ignore patterns in its key — so the cached result from before the
   config change kept getting served. `--no-cache` looked like a workaround
   but only skipped the IR cache; the analysis-cache check at main.rs:496
   didn't honor the flag at all.

Fix:

- crates/diffcore-core/src/git.rs: new `detect_subtree_paths(repo)` walks
  HEAD and matches three `git subtree` message shapes — `Squashed
  '<path>/' content from commit`, `Add '<path>/' from commit '<sha>'`, and
  `Merge commit '<sha>' as '<path>'`. Returns deduplicated, sorted paths,
  filtered to those that still exist in the working directory (so a later
  rename/delete doesn't ghost-add ignore entries).

- crates/diffcore-core/src/config.rs: new `IgnoreConfig.auto_subtrees`
  field defaulting to true. New `DiffcoreConfig::apply_detected_subtrees`
  method appends `<path>/**` globs to `ignore.paths`, skipping duplicates,
  and returns the detected paths so callers can log them.

- crates/diffcore-core/src/cache.rs: `compute_cache_key` now takes the
  ignore-pattern list as a second argument and folds a sorted hash of the
  patterns into the SHA-256 key. Any ignore-config change — including
  auto-detected subtrees — now invalidates the cache automatically.

- crates/diffcore-cli/src/main.rs: calls `apply_detected_subtrees` after
  loading config in both analyze entry points, logs `Auto-ignoring N git
  subtree path(s): …` at info level, passes ignore patterns into
  `compute_cache_key`, and finally honors `args.no_cache` for the analysis
  cache (previously it only affected the IR cache).

- crates/diffcore-tauri/src/commands.rs: same wiring inside the Tauri
  analyze command so the desktop app gets the same behavior.

Tests:

- git.rs: 6 new tests — three for the message-parser covering each subtree
  marker shape, one for unrelated messages, plus `detect_subtree_paths`
  against a real temp repo that exercises the on-disk filter and the
  dedupe/sort guarantees.
- config.rs: 4 new tests covering the `auto_subtrees` default, opt-out via
  TOML, the no-op-when-disabled path, and full append behavior against a
  real repo with a Squashed-style commit.
- cache.rs: 2 new tests — `cache_key_includes_ignore_patterns` proves the
  key changes when patterns are added; `cache_key_ignore_pattern_order_independent`
  proves pattern order doesn't break cache hits.

Verified locally on the otel-outbox-tracing-sentry worktree: file count
of `repos/effect/...` entries in flow groups drops from 1,502 to 0, total
groups drop from 660 to 164.

Opt out with:
  [ignore]
  auto_subtrees = false

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jamesaphoenix

Cargo.lock

@@ -3,7 +3,7 @@ members = ["crates/diffcore-core", "crates/diffcore-cli", "crates/diffcore-tauri
 resolver = "2"
 
 [workspace.package]
-version = "0.5.12"
+version = "0.5.13"
 edition = "2021"
 license = "MIT"
 

Cargo.toml

@@ -325,8 +325,9 @@ fn run_analyze_and_return(args: AnalyzeArgs) -> Result<AnalysisOutput, Box<dyn s
         .workdir()
         .ok_or("Bare repositories are not supported")?
         .to_path_buf();
-    let config = DiffcoreConfig::load_with_global_llm_from_dir(&workdir)
+    let mut config = DiffcoreConfig::load_with_global_llm_from_dir(&workdir)
         .map_err(|e| format!("Config error: {}", e))?;
+    let _detected_subtrees = config.apply_detected_subtrees(&repo);
 
     let include_uncommitted = if args.include_uncommitted {
         true
@@ -354,7 +355,7 @@ fn run_analyze_and_return(args: AnalyzeArgs) -> Result<AnalysisOutput, Box<dyn s
         });
     }
 
-    let cache_key = cache::compute_cache_key(&diff_result);
+    let cache_key = cache::compute_cache_key(&diff_result, &config.ignore.paths);
     if let Some(cached) = cache::load_cached(&workdir, &cache_key) {
         return Ok(cached);
     }
@@ -442,6 +443,16 @@ fn run_analyze(args: AnalyzeArgs) -> Result<(), Box<dyn std::error::Error>> {
     let mut config = DiffcoreConfig::load_with_global_llm_from_dir(&workdir)
         .map_err(|e| format!("Config error: {}", e))?;
 
+    // Auto-detect git subtree imports and add them to the ignore list.
+    let detected_subtrees = config.apply_detected_subtrees(&repo);
+    if !detected_subtrees.is_empty() {
+        log::info!(
+            "Auto-ignoring {} git subtree path(s): {}",
+            detected_subtrees.len(),
+            detected_subtrees.join(", ")
+        );
+    }
+
     // Apply CLI overrides for refinement
     if args.refine {
         config.llm.refinement.enabled = true;
@@ -480,9 +491,11 @@ fn run_analyze(args: AnalyzeArgs) -> Result<(), Box<dyn std::error::Error>> {
         return write_output(&empty_output, args.output.as_deref());
     }
 
-    // Check cache (skip if LLM annotation or refinement requested — those are additive)
-    let cache_key = cache::compute_cache_key(&diff_result);
-    if !args.annotate && !args.refine && args.refine_model.is_none() {
+    // Check cache (skip if LLM annotation or refinement requested — those are additive,
+    // or if --no-cache was passed). Cache key incorporates ignore patterns so any
+    // ignore-config change (incl. auto-detected subtrees) invalidates the entry.
+    let cache_key = cache::compute_cache_key(&diff_result, &config.ignore.paths);
+    if !args.annotate && !args.refine && args.refine_model.is_none() && !args.no_cache {
         if let Some(cached) = cache::load_cached(&workdir, &cache_key) {
             return write_output(&cached, args.output.as_deref());
         }

crates/diffcore-cli/src/main.rs

@@ -14,16 +14,18 @@ use std::path::{Path, PathBuf};
 use crate::git::DiffResult;
 use crate::types::AnalysisOutput;
 
-/// Compute a deterministic cache key from a diff result.
+/// Compute a deterministic cache key from a diff result and ignore patterns.
 ///
 /// The key is a hex-encoded SHA-256 hash of:
 /// - base_sha (or "none")
 /// - head_sha (or "none")
 /// - sorted file paths joined by newlines
+/// - sorted ignore patterns joined by newlines
 ///
-/// This ensures the cache is invalidated when any file is added/removed
-/// or when the base/head refs change.
-pub fn compute_cache_key(diff_result: &DiffResult) -> String {
+/// This ensures the cache is invalidated when any file is added/removed,
+/// when the base/head refs change, or when the ignore configuration changes
+/// (including auto-detected subtree paths).
+pub fn compute_cache_key(diff_result: &DiffResult, ignore_patterns: &[String]) -> String {
     let mut hasher = Sha256::new();
 
     hasher.update(diff_result.base_sha.as_deref().unwrap_or("none"));
@@ -38,6 +40,16 @@ pub fn compute_cache_key(diff_result: &DiffResult) -> String {
         hasher.update(b"\n");
     }
 
+    // Separator so an empty patterns list produces a distinct key from one whose
+    // first pattern happens to start with a path-looking string.
+    hasher.update(b"\0ignore\0");
+    let mut patterns: Vec<&str> = ignore_patterns.iter().map(|s| s.as_str()).collect();
+    patterns.sort();
+    for pat in &patterns {
+        hasher.update(pat.as_bytes());
+        hasher.update(b"\n");
+    }
+
     hex::encode(hasher.finalize())
 }
 
@@ -250,44 +262,44 @@ mod tests {
     #[test]
     fn cache_key_deterministic() {
         let diff = make_diff_result(Some("abc"), Some("def"), &["a.ts", "b.ts"]);
-        let key1 = compute_cache_key(&diff);
-        let key2 = compute_cache_key(&diff);
+        let key1 = compute_cache_key(&diff, &[]);
+        let key2 = compute_cache_key(&diff, &[]);
         assert_eq!(key1, key2);
     }
 
     #[test]
     fn cache_key_different_shas() {
         let diff1 = make_diff_result(Some("abc"), Some("def"), &["a.ts"]);
         let diff2 = make_diff_result(Some("abc"), Some("ghi"), &["a.ts"]);
-        assert_ne!(compute_cache_key(&diff1), compute_cache_key(&diff2));
+        assert_ne!(compute_cache_key(&diff1, &[]), compute_cache_key(&diff2, &[]));
     }
 
     #[test]
     fn cache_key_different_files() {
         let diff1 = make_diff_result(Some("abc"), Some("def"), &["a.ts"]);
         let diff2 = make_diff_result(Some("abc"), Some("def"), &["a.ts", "b.ts"]);
-        assert_ne!(compute_cache_key(&diff1), compute_cache_key(&diff2));
+        assert_ne!(compute_cache_key(&diff1, &[]), compute_cache_key(&diff2, &[]));
     }
 
     #[test]
     fn cache_key_order_independent() {
         let diff1 = make_diff_result(Some("abc"), Some("def"), &["b.ts", "a.ts"]);
         let diff2 = make_diff_result(Some("abc"), Some("def"), &["a.ts", "b.ts"]);
-        assert_eq!(compute_cache_key(&diff1), compute_cache_key(&diff2));
+        assert_eq!(compute_cache_key(&diff1, &[]), compute_cache_key(&diff2, &[]));
     }
 
     #[test]
     fn cache_key_none_shas() {
         let diff = make_diff_result(None, None, &["a.ts"]);
-        let key = compute_cache_key(&diff);
+        let key = compute_cache_key(&diff, &[]);
         assert!(!key.is_empty());
         assert_eq!(key.len(), 64); // SHA-256 hex length
     }
 
     #[test]
     fn cache_key_empty_files() {
         let diff = make_diff_result(Some("abc"), Some("def"), &[]);
-        let key = compute_cache_key(&diff);
+        let key = compute_cache_key(&diff, &[]);
         assert_eq!(key.len(), 64);
     }
 
@@ -349,10 +361,32 @@ mod tests {
     #[test]
     fn cache_key_hex_encoded() {
         let diff = make_diff_result(Some("abc"), Some("def"), &["a.ts"]);
-        let key = compute_cache_key(&diff);
+        let key = compute_cache_key(&diff, &[]);
         assert!(key.chars().all(|c| c.is_ascii_hexdigit()));
     }
 
+    #[test]
+    fn cache_key_includes_ignore_patterns() {
+        let diff = make_diff_result(Some("abc"), Some("def"), &["a.ts"]);
+        let no_ignores = compute_cache_key(&diff, &[]);
+        let with_ignores = compute_cache_key(&diff, &["repos/effect/**".to_string()]);
+        assert_ne!(no_ignores, with_ignores);
+    }
+
+    #[test]
+    fn cache_key_ignore_pattern_order_independent() {
+        let diff = make_diff_result(Some("abc"), Some("def"), &["a.ts"]);
+        let key1 = compute_cache_key(
+            &diff,
+            &["repos/effect/**".to_string(), "dist/**".to_string()],
+        );
+        let key2 = compute_cache_key(
+            &diff,
+            &["dist/**".to_string(), "repos/effect/**".to_string()],
+        );
+        assert_eq!(key1, key2);
+    }
+
     #[test]
     fn load_cached_malformed_json_returns_none() {
         let tmp = tempfile::tempdir().unwrap();

crates/diffcore-core/src/cache.rs

@@ -88,11 +88,32 @@ pub struct EntrypointConfig {
 }
 
 /// File ignore configuration.
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct IgnoreConfig {
     /// Glob patterns for files to exclude from analysis.
     #[serde(default)]
     pub paths: Vec<String>,
+    /// Whether to auto-detect git subtree imports and ignore their paths.
+    ///
+    /// When true (default), `apply_detected_subtrees` scans the repository's commit
+    /// history for `git subtree` merge markers and adds the imported paths to
+    /// `paths` as `<path>/**` globs. Vendored upstream code merged via
+    /// `git subtree add`/`pull` is filtered out automatically without manual config.
+    #[serde(default = "default_auto_subtrees")]
+    pub auto_subtrees: bool,
+}
+
+fn default_auto_subtrees() -> bool {
+    true
+}
+
+impl Default for IgnoreConfig {
+    fn default() -> Self {
+        Self {
+            paths: Vec::new(),
+            auto_subtrees: true,
+        }
+    }
 }
 
 /// Diff behavior configuration.
@@ -378,6 +399,28 @@ impl DiffcoreConfig {
         Ok(())
     }
 
+    /// Detect git subtree imports and append `<path>/**` globs to the ignore list.
+    ///
+    /// No-op when `ignore.auto_subtrees` is false. Returns the list of paths that
+    /// were detected (so callers can surface them in logs/UI); pre-existing
+    /// ignore patterns are preserved and duplicates are skipped.
+    pub fn apply_detected_subtrees(&mut self, repo: &git2::Repository) -> Vec<String> {
+        if !self.ignore.auto_subtrees {
+            return Vec::new();
+        }
+        let detected = match crate::git::detect_subtree_paths(repo) {
+            Ok(paths) => paths,
+            Err(_) => return Vec::new(),
+        };
+        for path in &detected {
+            let pattern = format!("{}/**", path);
+            if !self.ignore.paths.contains(&pattern) {
+                self.ignore.paths.push(pattern);
+            }
+        }
+        detected
+    }
+
     /// Check if a file path should be ignored based on configured ignore patterns.
     ///
     /// Patterns are matched against the relative path from the repo root.
@@ -920,6 +963,7 @@ events = ["src/handlers/events/**/*.ts"]
             },
             ignore: IgnoreConfig {
                 paths: vec!["**/*.test.ts".to_string()],
+                auto_subtrees: true,
             },
             llm: LlmConfig {
                 provider: Some("anthropic".to_string()),
@@ -1320,4 +1364,114 @@ provider = "openai"
 
         std::env::remove_var("DIFFCORE_GLOBAL_CONFIG_DIR");
     }
+
+    // ── auto_subtrees Tests ──
+
+    #[test]
+    fn auto_subtrees_defaults_true() {
+        let config = DiffcoreConfig::default();
+        assert!(config.ignore.auto_subtrees);
+    }
+
+    #[test]
+    fn auto_subtrees_defaults_true_on_empty_toml() {
+        let config = DiffcoreConfig::from_str("").unwrap();
+        assert!(config.ignore.auto_subtrees);
+    }
+
+    #[test]
+    fn auto_subtrees_can_be_disabled() {
+        let toml_str = r#"
+[ignore]
+auto_subtrees = false
+"#;
+        let config = DiffcoreConfig::from_str(toml_str).unwrap();
+        assert!(!config.ignore.auto_subtrees);
+    }
+
+    #[test]
+    fn apply_detected_subtrees_is_noop_when_disabled() {
+        let dir = tempfile::tempdir().unwrap();
+        let repo = git2::Repository::init(dir.path()).unwrap();
+        let mut config = DiffcoreConfig::default();
+        config.ignore.auto_subtrees = false;
+        config.ignore.paths.push("foo/**".to_string());
+
+        let detected = config.apply_detected_subtrees(&repo);
+        assert!(detected.is_empty());
+        assert_eq!(config.ignore.paths, vec!["foo/**".to_string()]);
+    }
+
+    #[test]
+    fn apply_detected_subtrees_appends_detected_globs() {
+        // Build a repo with a squashed-subtree commit whose path exists on disk.
+        let dir = tempfile::tempdir().unwrap();
+        let repo = git2::Repository::init(dir.path()).unwrap();
+        {
+            let mut cfg = repo.config().unwrap();
+            cfg.set_str("user.name", "Test").unwrap();
+            cfg.set_str("user.email", "test@test.com").unwrap();
+        }
+
+        // initial commit
+        let sig = repo.signature().unwrap();
+        std::fs::write(dir.path().join("README.md"), "root").unwrap();
+        let mut index = repo.index().unwrap();
+        index.add_path(std::path::Path::new("README.md")).unwrap();
+        index.write().unwrap();
+        let tree_oid = index.write_tree().unwrap();
+        let tree = repo.find_tree(tree_oid).unwrap();
+        repo.commit(Some("HEAD"), &sig, &sig, "initial", &tree, &[])
+            .unwrap();
+
+        // subtree commit
+        std::fs::create_dir_all(dir.path().join("repos/effect")).unwrap();
+        std::fs::write(dir.path().join("repos/effect/package.json"), "{}").unwrap();
+        let mut index = repo.index().unwrap();
+        index
+            .add_path(std::path::Path::new("repos/effect/package.json"))
+            .unwrap();
+        index.write().unwrap();
+        let tree_oid = index.write_tree().unwrap();
+        let tree = repo.find_tree(tree_oid).unwrap();
+        let parent = repo.head().unwrap().peel_to_commit().unwrap();
+        repo.commit(
+            Some("HEAD"),
+            &sig,
+            &sig,
+            "Squashed 'repos/effect/' content from commit deadbeef",
+            &tree,
+            &[&parent],
+        )
+        .unwrap();
+
+        let mut config = DiffcoreConfig::default();
+        let detected = config.apply_detected_subtrees(&repo);
+
+        assert_eq!(detected, vec!["repos/effect".to_string()]);
+        assert!(config.ignore.paths.contains(&"repos/effect/**".to_string()));
+        assert!(config.is_ignored("repos/effect/package.json"));
+        assert!(!config.is_ignored("apps/api/src/main.ts"));
+    }
+
+    #[test]
+    fn apply_detected_subtrees_does_not_duplicate_existing_patterns() {
+        let dir = tempfile::tempdir().unwrap();
+        let repo = git2::Repository::init(dir.path()).unwrap();
+        let mut config = DiffcoreConfig::default();
+        // Pre-existing ignore entry for the same subtree.
+        config.ignore.paths.push("repos/effect/**".to_string());
+
+        // Call twice — should be idempotent.
+        let _ = config.apply_detected_subtrees(&repo);
+        let _ = config.apply_detected_subtrees(&repo);
+
+        let count = config
+            .ignore
+            .paths
+            .iter()
+            .filter(|p| *p == "repos/effect/**")
+            .count();
+        assert_eq!(count, 1);
+    }
 }