From 69af696016a3c1c3c6aee42aeae8170871249c49 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 8 Aug 2026 08:53:44 +0000
Subject: [PATCH 1/4] Initial plan


From 43737da864d3ec578b2482e54902628e53326f1c Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 8 Aug 2026 08:57:04 +0000
Subject: [PATCH 2/4] Honor ignore rules outside git repos during indexing

Co-authored-by: Anandb71 <169837340+Anandb71@users.noreply.github.com>
---
 crates/arbor-watcher/src/indexer.rs | 156 +++++++++++++++++++++++++++-
 1 file changed, 155 insertions(+), 1 deletion(-)

diff --git a/crates/arbor-watcher/src/indexer.rs b/crates/arbor-watcher/src/indexer.rs
index 716523f..9e04093 100644
--- a/crates/arbor-watcher/src/indexer.rs
+++ b/crates/arbor-watcher/src/indexer.rs
@@ -5,8 +5,10 @@
 
 use arbor_core::{parse_file, CodeNode};
 use arbor_graph::{ArborGraph, GraphBuilder, GraphStore};
+use ignore::gitignore::{Gitignore, GitignoreBuilder};
 use ignore::WalkBuilder;
 use rayon::prelude::*;
+use serde::Deserialize;
 use std::collections::HashSet;
 use std::path::{Path, PathBuf};
 use std::time::Instant;
@@ -44,6 +46,77 @@ pub struct IndexOptions {
     pub cache_path: Option<PathBuf>,
 }
 
+const DEFAULT_EXCLUDE_PATTERNS: &[&str] = &[
+    "node_modules/",
+    "venv/",
+    ".venv/",
+    "site-packages/",
+    "__pycache__/",
+    "target/",
+    "dist/",
+    "build/",
+    "out/",
+];
+
+#[derive(Debug, Deserialize)]
+struct ArborConfig {
+    #[serde(default)]
+    ignore: Vec<String>,
+}
+
+fn build_ignore_matcher(root: &Path) -> Option<Gitignore> {
+    let mut builder = GitignoreBuilder::new(root);
+    for pattern in DEFAULT_EXCLUDE_PATTERNS {
+        if let Err(e) = builder.add_line(None, pattern) {
+            warn!("Invalid built-in ignore pattern '{}': {}", pattern, e);
+        }
+    }
+
+    let config_path = root.join(".arbor").join("config.json");
+    if config_path.exists() {
+        match std::fs::read_to_string(&config_path) {
+            Ok(text) => match serde_json::from_str::<ArborConfig>(&text) {
+                Ok(config) => {
+                    for pattern in config.ignore {
+                        let trimmed = pattern.trim();
+                        if trimmed.is_empty() {
+                            continue;
+                        }
+                        if let Err(e) = builder.add_line(None, trimmed) {
+                            warn!(
+                                "Invalid ignore pattern '{}' in {}: {}",
+                                trimmed,
+                                config_path.display(),
+                                e
+                            );
+                        }
+                    }
+                }
+                Err(e) => {
+                    warn!("Failed to parse {}: {}", config_path.display(), e);
+                }
+            },
+            Err(e) => {
+                warn!("Failed to read {}: {}", config_path.display(), e);
+            }
+        }
+    }
+
+    match builder.build() {
+        Ok(matcher) => Some(matcher),
+        Err(e) => {
+            warn!("Failed to build ignore matcher: {}", e);
+            None
+        }
+    }
+}
+
+fn is_ignored(path: &Path, is_dir: bool, matcher: Option<&Gitignore>) -> bool {
+    matcher
+        .map(|m| m.matched_path_or_any_parents(path, is_dir).is_ignore())
+        .unwrap_or(false)
+}
+
 /// Indexes a directory and returns the code graph.
 ///
 /// This walks all source files, parses them, and builds the
@@ -84,12 +157,16 @@ pub fn index_directory(root: &Path, options: IndexOptions) -> Result<IndexResult
                 }
             });
 
-    // Walk the directory, respecting .gitignore, collecting supported files
+    // Walk the directory, respecting ignore files and collecting supported files.
+    let ignore_matcher = build_ignore_matcher(root);
     let walker = WalkBuilder::new(root)
         .hidden(true) // Skip hidden files
         .git_ignore(true) // Respect .gitignore
+        .ignore(true) // Respect .ignore and custom ignore files
+        .require_git(false) // Respect .gitignore even outside a git repository
         .git_global(true)
         .git_exclude(true)
+        .add_custom_ignore_filename(".arborignore")
         .follow_links(options.follow_symlinks)
         .build();
 
@@ -97,6 +174,13 @@ pub fn index_directory(root: &Path, options: IndexOptions) -> Result<IndexResult
         .filter_map(Result::ok)
         .filter(|entry| {
             let path = entry.path();
+            if is_ignored(
+                path,
+                entry.file_type().map(|ft| ft.is_dir()).unwrap_or(false),
+                ignore_matcher.as_ref(),
+            ) {
+                return false;
+            }
             if path.is_dir() {
                 return false;
             }
@@ -233,16 +317,27 @@ pub fn parse_single_file(path: &Path) -> Result<Vec<CodeNode>, arbor_core::Parse
 /// UNIX epoch. Catches edits and additions; a lone deletion leaves no newer
 /// file, so it is picked up on the next edit instead.
 pub fn sources_newer_than(root: &Path, cache_mtime: u64, follow_symlinks: bool) -> bool {
+    let ignore_matcher = build_ignore_matcher(root);
     let walker = WalkBuilder::new(root)
         .hidden(true)
         .git_ignore(true)
+        .ignore(true)
+        .require_git(false)
         .git_global(true)
         .git_exclude(true)
+        .add_custom_ignore_filename(".arborignore")
         .follow_links(follow_symlinks)
         .build();
 
     for entry in walker.filter_map(Result::ok) {
         let path = entry.path();
+        if is_ignored(
+            path,
+            entry.file_type().map(|ft| ft.is_dir()).unwrap_or(false),
+            ignore_matcher.as_ref(),
+        ) {
+            continue;
+        }
         if path.is_dir() {
             continue;
         }
@@ -382,4 +477,63 @@ mod tests {
         assert_eq!(result.files_indexed, 1);
         assert!(result.nodes_extracted > 0);
     }
+
+    #[test]
+    fn test_index_honors_gitignore_outside_git_repo() {
+        let dir = tempdir().unwrap();
+        fs::create_dir_all(dir.path().join("venv")).unwrap();
+        fs::write(dir.path().join(".gitignore"), "venv/\n").unwrap();
+        fs::write(
+            dir.path().join("venv").join("ignored.rs"),
+            "pub fn ignored() {}",
+        )
+        .unwrap();
+        fs::write(dir.path().join("kept.rs"), "pub fn kept() {}").unwrap();
+
+        let result = index_directory(dir.path(), IndexOptions::default()).unwrap();
+        assert_eq!(result.files_indexed, 1);
+        assert!(result.graph.find_by_name("kept").len() == 1);
+        assert!(result.graph.find_by_name("ignored").is_empty());
+    }
+
+    #[test]
+    fn test_index_honors_arborignore() {
+        let dir = tempdir().unwrap();
+        fs::create_dir_all(dir.path().join("vendor")).unwrap();
+        fs::write(dir.path().join(".arborignore"), "vendor/\n").unwrap();
+        fs::write(
+            dir.path().join("vendor").join("ignored.rs"),
+            "pub fn ignored() {}",
+        )
+        .unwrap();
+        fs::write(dir.path().join("kept.rs"), "pub fn kept() {}").unwrap();
+
+        let result = index_directory(dir.path(), IndexOptions::default()).unwrap();
+        assert_eq!(result.files_indexed, 1);
+        assert!(result.graph.find_by_name("kept").len() == 1);
+        assert!(result.graph.find_by_name("ignored").is_empty());
+    }
+
+    #[test]
+    fn test_index_honors_arbor_config_ignore_patterns() {
+        let dir = tempdir().unwrap();
+        fs::create_dir_all(dir.path().join(".arbor")).unwrap();
+        fs::create_dir_all(dir.path().join("third_party")).unwrap();
+        fs::write(
+            dir.path().join(".arbor").join("config.json"),
+            r#"{"version":"1.0","ignore":["third_party/"]}"#,
+        )
+        .unwrap();
+        fs::write(
+            dir.path().join("third_party").join("ignored.rs"),
+            "pub fn ignored() {}",
+        )
+        .unwrap();
+        fs::write(dir.path().join("kept.rs"), "pub fn kept() {}").unwrap();
+
+        let result = index_directory(dir.path(), IndexOptions::default()).unwrap();
+        assert_eq!(result.files_indexed, 1);
+        assert!(result.graph.find_by_name("kept").len() == 1);
+        assert!(result.graph.find_by_name("ignored").is_empty());
+    }
 }

From b0ac6f047cc7e46f0ba569b8147c751d9490ccb9 Mon Sep 17 00:00:00 2001
From: w0wl0lxd <w0wl0lxd@tuta.com>
Date: Mon, 10 Aug 2026 20:59:23 -0400
Subject: [PATCH 3/4] fix(server,watcher): stop bridge busy-looping on ignored
 build dirs and run centrality off the async core

---
 crates/arbor-server/src/sync_server.rs | 297 +++++++++++++++----------
 crates/arbor-watcher/src/indexer.rs    | 118 ++++++----
 crates/arbor-watcher/src/lib.rs        |   2 +-
 3 files changed, 247 insertions(+), 170 deletions(-)

diff --git a/crates/arbor-server/src/sync_server.rs b/crates/arbor-server/src/sync_server.rs
index cbff339..32287de 100644
--- a/crates/arbor-server/src/sync_server.rs
+++ b/crates/arbor-server/src/sync_server.rs
@@ -9,6 +9,7 @@
 use crate::SharedGraph;
 use arbor_core::ArborParser;
 use arbor_graph::{compute_centrality_warm, ArborGraph, Edge, EdgeKind};
+use arbor_watcher::IgnoreMatcher;
 use futures_util::{SinkExt, StreamExt};
 use notify::{Config, Event, RecommendedWatcher, RecursiveMode, Watcher};
 use std::collections::HashMap;
@@ -553,6 +554,8 @@ async fn run_file_watcher(
     watcher.watch(&watch_path, RecursiveMode::Recursive)?;
     info!("👁️  File watcher started for {}", watch_path.display());
 
+    let ignore_matcher = IgnoreMatcher::new(&watch_path);
+
     // Debounce state
     let mut pending: HashMap<PathBuf, Instant> = HashMap::new();
     let debounce_dur = Duration::from_millis(debounce_ms);
@@ -570,7 +573,7 @@ async fn run_file_watcher(
 
         for path in ready {
             pending.remove(&path);
-            if should_process_file(&path, &extensions) {
+            if should_process_file(&path, &extensions, &ignore_matcher) {
                 let event = if path.exists() {
                     WatcherEvent::Changed(path)
                 } else {
@@ -584,7 +587,7 @@ async fn run_file_watcher(
         match tokio::time::timeout(Duration::from_millis(50), notify_rx.recv()).await {
             Ok(Some(Ok(event))) => {
                 for path in event.paths {
-                    if should_process_file(&path, &extensions) {
+                    if should_process_file(&path, &extensions, &ignore_matcher) {
                         pending.insert(path, Instant::now());
                     }
                 }
@@ -600,8 +603,11 @@ async fn run_file_watcher(
     Ok(())
 }
 
-/// Checks if a file should be processed based on extension.
-fn should_process_file(path: &Path, extensions: &[String]) -> bool {
+/// Checks if a file should be processed based on extension and ignore rules.
+fn should_process_file(path: &Path, extensions: &[String], ignore_matcher: &IgnoreMatcher) -> bool {
+    if ignore_matcher.is_ignored(path, path.is_dir()) {
+        return false;
+    }
     path.extension()
         .and_then(|ext| ext.to_str())
         .map(|ext| extensions.iter().any(|e| e == ext))
@@ -613,6 +619,10 @@ fn should_process_file(path: &Path, extensions: &[String]) -> bool {
 // ─────────────────────────────────────────────────────────────────────────────
 
 /// Runs the background indexer that processes file changes.
+///
+/// The CPU-heavy graph update and centrality recompute are moved to
+/// `tokio::task::spawn_blocking` so the async core worker stays responsive
+/// and does not busy-loop on a single file change.
 async fn run_background_indexer(
     mut rx: mpsc::Receiver<WatcherEvent>,
     graph: SharedGraph,
@@ -633,135 +643,154 @@ async fn run_background_indexer(
     info!("🔧 Background indexer started");
 
     while let Some(event) = rx.recv().await {
-        let start = Instant::now();
-
-        match event {
-            WatcherEvent::Changed(path) | WatcherEvent::Created(path) => {
-                let file_name = path
-                    .file_name()
-                    .and_then(|n| n.to_str())
-                    .unwrap_or("unknown");
-
-                info!("📝 Re-indexing: {}", file_name);
-
-                if parser.is_none() {
-                    parser = match ArborParser::new() {
-                        Ok(parser) => Some(parser),
-                        Err(error) => {
-                            warn!(
-                                "Skipping '{}' due to parser init failure: {}",
-                                file_name, error
-                            );
-                            None
-                        }
-                    };
+        // Take ownership of the parser for this event; the blocking task
+        // returns it so we can reuse it for the next event.
+        let mut current_parser = parser.take();
+
+        if current_parser.is_none() {
+            current_parser = match ArborParser::new() {
+                Ok(parser) => Some(parser),
+                Err(error) => {
+                    warn!("Failed to initialize parser for re-indexing: {}", error);
+                    None
                 }
+            };
+        }
 
-                let Some(parser) = parser.as_mut() else {
-                    continue;
-                };
+        let Some(mut event_parser) = current_parser else {
+            continue;
+        };
 
-                match parser.parse_file(&path) {
-                    Ok(result) => {
-                        let mut g = graph.write().await;
+        let graph = graph.clone();
+        let broadcast_tx = broadcast_tx.clone();
 
-                        // Remove old nodes from this file
-                        g.remove_file(&result.file_path);
+        parser = match tokio::task::spawn_blocking(move || {
+            let start = Instant::now();
 
-                        // Add new nodes
-                        let mut node_ids = HashMap::new();
-                        for symbol in &result.symbols {
-                            let id = g.add_node(symbol.clone());
-                            node_ids.insert(symbol.id.clone(), id);
-                        }
+            match event {
+                WatcherEvent::Changed(path) | WatcherEvent::Created(path) => {
+                    let file_name = path
+                        .file_name()
+                        .and_then(|n| n.to_str())
+                        .unwrap_or("unknown");
+
+                    info!("📝 Re-indexing: {}", file_name);
+
+                    match event_parser.parse_file(&path) {
+                        Ok(result) => {
+                            let mut g = graph.blocking_write();
+
+                            // Remove old nodes from this file
+                            g.remove_file(&result.file_path);
+
+                            // Add new nodes
+                            let mut node_ids = HashMap::new();
+                            for symbol in &result.symbols {
+                                let id = g.add_node(symbol.clone());
+                                node_ids.insert(symbol.id.clone(), id);
+                            }
 
-                        // Add edges for relations
-                        for relation in &result.relations {
-                            if let Some(&from_id) = node_ids.get(&relation.from_id) {
-                                // Try to find the target by name
-                                let targets = g.find_by_name(&relation.to_name);
-                                if let Some(target) = targets.first() {
-                                    if let Some(to_id) = g.get_index(&target.id) {
-                                        let edge_kind = match relation.kind {
-                                            arbor_core::RelationType::Calls => EdgeKind::Calls,
-                                            arbor_core::RelationType::Imports => EdgeKind::Imports,
-                                            arbor_core::RelationType::Extends => EdgeKind::Extends,
-                                            arbor_core::RelationType::Implements => {
-                                                EdgeKind::Implements
-                                            }
-                                        };
-                                        g.add_edge(from_id, to_id, Edge::new(edge_kind));
+                            // Add edges for relations
+                            for relation in &result.relations {
+                                if let Some(&from_id) = node_ids.get(&relation.from_id) {
+                                    let targets = g.find_by_name(&relation.to_name);
+                                    if let Some(target) = targets.first() {
+                                        if let Some(to_id) = g.get_index(&target.id) {
+                                            let edge_kind = match relation.kind {
+                                                arbor_core::RelationType::Calls => EdgeKind::Calls,
+                                                arbor_core::RelationType::Imports => {
+                                                    EdgeKind::Imports
+                                                }
+                                                arbor_core::RelationType::Extends => {
+                                                    EdgeKind::Extends
+                                                }
+                                                arbor_core::RelationType::Implements => {
+                                                    EdgeKind::Implements
+                                                }
+                                            };
+                                            g.add_edge(from_id, to_id, Edge::new(edge_kind));
+                                        }
                                     }
                                 }
                             }
-                        }
 
-                        // Recompute centrality so the code map stays in sync with the
-                        // patched graph — new nodes start at 0.0 otherwise and the map drifts.
-                        // Warm-started from the previous scores, so a single-file patch
-                        // converges in a round or two instead of the full budget.
-                        let scores =
-                            compute_centrality_warm(&g, 20, 0.85, Some(g.centrality_map()));
-                        g.set_centrality(scores.into_map());
-
-                        let elapsed = start.elapsed();
-                        info!(
-                            "✅ Indexed {} in {:?} ({} symbols, {} relations)",
-                            file_name,
-                            elapsed,
-                            result.symbols.len(),
-                            result.relations.len()
-                        );
-
-                        // Broadcast update
-                        let update = BroadcastMessage::GraphUpdate(GraphUpdatePayload {
-                            is_delta: true,
-                            node_count: g.node_count(),
-                            edge_count: g.edge_count(),
-                            file_count: g.stats().files,
-                            changed_files: vec![result.file_path],
-                            timestamp: std::time::SystemTime::now()
-                                .duration_since(std::time::UNIX_EPOCH)
-                                .map_or(0, |d| d.as_secs()),
-                            nodes: Some(g.nodes().cloned().collect()),
-                            edges: Some(g.export_edges()),
-                        });
-
-                        let _ = broadcast_tx.send(update);
-                    }
-                    Err(e) => {
-                        warn!("⚠️  Parse error for {}: {}", file_name, e);
+                            // Recompute centrality so the code map stays in sync with the
+                            // patched graph — new nodes start at 0.0 otherwise and the map drifts.
+                            // Warm-started from the previous scores, so a single-file patch
+                            // converges in a round or two instead of the full budget.
+                            let scores =
+                                compute_centrality_warm(&g, 20, 0.85, Some(g.centrality_map()));
+                            g.set_centrality(scores.into_map());
+
+                            let elapsed = start.elapsed();
+                            info!(
+                                "✅ Indexed {} in {:?} ({} symbols, {} relations)",
+                                file_name,
+                                elapsed,
+                                result.symbols.len(),
+                                result.relations.len()
+                            );
+
+                            // Broadcast update
+                            let update = BroadcastMessage::GraphUpdate(GraphUpdatePayload {
+                                is_delta: true,
+                                node_count: g.node_count(),
+                                edge_count: g.edge_count(),
+                                file_count: g.stats().files,
+                                changed_files: vec![result.file_path],
+                                timestamp: std::time::SystemTime::now()
+                                    .duration_since(std::time::UNIX_EPOCH)
+                                    .map_or(0, |d| d.as_secs()),
+                                nodes: Some(g.nodes().cloned().collect()),
+                                edges: Some(g.export_edges()),
+                            });
+
+                            let _ = broadcast_tx.send(update);
+                        }
+                        Err(e) => {
+                            warn!("⚠️  Parse error for {}: {}", file_name, e);
+                        }
                     }
                 }
+
+                WatcherEvent::Deleted(path) => {
+                    let file_str = path.to_string_lossy().to_string();
+                    info!("🗑️  File deleted: {}", path.display());
+
+                    let mut g = graph.blocking_write();
+                    g.remove_file(&file_str);
+
+                    // Recompute centrality so the code map reflects the removed nodes.
+                    let scores = compute_centrality_warm(&g, 20, 0.85, Some(g.centrality_map()));
+                    g.set_centrality(scores.into_map());
+
+                    let update = BroadcastMessage::GraphUpdate(GraphUpdatePayload {
+                        is_delta: true,
+                        node_count: g.node_count(),
+                        edge_count: g.edge_count(),
+                        file_count: g.stats().files,
+                        changed_files: vec![file_str],
+                        timestamp: std::time::SystemTime::now()
+                            .duration_since(std::time::UNIX_EPOCH)
+                            .map_or(0, |d| d.as_secs()),
+                        nodes: Some(g.nodes().cloned().collect()),
+                        edges: Some(g.export_edges()),
+                    });
+
+                    let _ = broadcast_tx.send(update);
+                }
             }
 
-            WatcherEvent::Deleted(path) => {
-                let file_str = path.to_string_lossy().to_string();
-                info!("🗑️  File deleted: {}", path.display());
-
-                let mut g = graph.write().await;
-                g.remove_file(&file_str);
-
-                // Recompute centrality so the code map reflects the removed nodes.
-                let scores = compute_centrality_warm(&g, 20, 0.85, Some(g.centrality_map()));
-                g.set_centrality(scores.into_map());
-
-                let update = BroadcastMessage::GraphUpdate(GraphUpdatePayload {
-                    is_delta: true,
-                    node_count: g.node_count(),
-                    edge_count: g.edge_count(),
-                    file_count: g.stats().files,
-                    changed_files: vec![file_str],
-                    timestamp: std::time::SystemTime::now()
-                        .duration_since(std::time::UNIX_EPOCH)
-                        .map_or(0, |d| d.as_secs()),
-                    nodes: Some(g.nodes().cloned().collect()),
-                    edges: Some(g.export_edges()),
-                });
-
-                let _ = broadcast_tx.send(update);
+            Some(event_parser)
+        })
+        .await
+        {
+            Ok(p) => p,
+            Err(e) => {
+                warn!("Background indexer task failed: {}", e);
+                None
             }
-        }
+        };
     }
 }
 
@@ -776,11 +805,33 @@ mod tests {
     #[test]
     fn test_should_process_file() {
         let extensions = vec!["ts".to_string(), "rs".to_string()];
-
-        assert!(should_process_file(Path::new("foo.ts"), &extensions));
-        assert!(should_process_file(Path::new("bar.rs"), &extensions));
-        assert!(!should_process_file(Path::new("baz.py"), &extensions));
-        assert!(!should_process_file(Path::new("README.md"), &extensions));
+        let ignore_matcher = IgnoreMatcher::new(Path::new("."));
+
+        assert!(should_process_file(
+            Path::new("foo.ts"),
+            &extensions,
+            &ignore_matcher
+        ));
+        assert!(should_process_file(
+            Path::new("bar.rs"),
+            &extensions,
+            &ignore_matcher
+        ));
+        assert!(!should_process_file(
+            Path::new("baz.py"),
+            &extensions,
+            &ignore_matcher
+        ));
+        assert!(!should_process_file(
+            Path::new("README.md"),
+            &extensions,
+            &ignore_matcher
+        ));
+        assert!(!should_process_file(
+            Path::new("target/debug/foo.rs"),
+            &extensions,
+            &ignore_matcher
+        ));
     }
 
     #[test]
diff --git a/crates/arbor-watcher/src/indexer.rs b/crates/arbor-watcher/src/indexer.rs
index 9e04093..47f775d 100644
--- a/crates/arbor-watcher/src/indexer.rs
+++ b/crates/arbor-watcher/src/indexer.rs
@@ -47,6 +47,8 @@ pub struct IndexOptions {
 }
 
 const DEFAULT_EXCLUDE_PATTERNS: &[&str] = &[
+    ".git/",
+    ".arbor/",
     "node_modules/",
     "venv/",
     ".venv/",
@@ -64,59 +66,85 @@ struct ArborConfig {
     ignore: Vec<String>,
 }
 
-fn build_ignore_matcher(root: &Path) -> Option<Gitignore> {
-    let mut builder = GitignoreBuilder::new(root);
-    for pattern in DEFAULT_EXCLUDE_PATTERNS {
-        if let Err(e) = builder.add_line(None, pattern) {
-            warn!("Invalid built-in ignore pattern '{}': {}", pattern, e);
+/// Shared ignore matcher used by both the directory walker and the file watcher.
+///
+/// Combines Arbor's built-in excludes (`.git/`, `target/`, `node_modules/`, ...),
+/// the root `.gitignore` and `.arborignore` files, and any custom patterns from
+/// `.arbor/config.json`.
+pub struct IgnoreMatcher {
+    inner: Option<Gitignore>,
+}
+
+impl IgnoreMatcher {
+    /// Build a matcher rooted at `root`.
+    pub fn new(root: &Path) -> Self {
+        let mut builder = GitignoreBuilder::new(root);
+
+        for pattern in DEFAULT_EXCLUDE_PATTERNS {
+            if let Err(e) = builder.add_line(None, pattern) {
+                warn!("Invalid built-in ignore pattern '{}': {}", pattern, e);
+            }
         }
-    }
 
-    let config_path = root.join(".arbor").join("config.json");
-    if config_path.exists() {
-        match std::fs::read_to_string(&config_path) {
-            Ok(text) => match serde_json::from_str::<ArborConfig>(&text) {
-                Ok(config) => {
-                    for pattern in config.ignore {
-                        let trimmed = pattern.trim();
-                        if trimmed.is_empty() {
-                            continue;
-                        }
-                        if let Err(e) = builder.add_line(None, trimmed) {
-                            warn!(
-                                "Invalid ignore pattern '{}' in {}: {}",
-                                trimmed,
-                                config_path.display(),
-                                e
-                            );
+        // Root-level ignore files. (Nested `.gitignore` files are honored by
+        // `WalkBuilder` during the initial walk; this matcher is enough for the
+        // watcher and for root-level rules in the indexer.)
+        for ignore_file in [".gitignore", ".arborignore"] {
+            let path = root.join(ignore_file);
+            if path.exists() {
+                if let Some(e) = builder.add(&path) {
+                    warn!("Failed to add {}: {}", path.display(), e);
+                }
+            }
+        }
+
+        // Custom ignore patterns from `.arbor/config.json`
+        let config_path = root.join(".arbor").join("config.json");
+        if config_path.exists() {
+            match std::fs::read_to_string(&config_path) {
+                Ok(text) => match serde_json::from_str::<ArborConfig>(&text) {
+                    Ok(config) => {
+                        for pattern in config.ignore {
+                            let trimmed = pattern.trim();
+                            if trimmed.is_empty() {
+                                continue;
+                            }
+                            if let Err(e) = builder.add_line(None, trimmed) {
+                                warn!(
+                                    "Invalid ignore pattern '{}' in {}: {}",
+                                    trimmed,
+                                    config_path.display(),
+                                    e
+                                );
+                            }
                         }
                     }
-                }
-                Err(e) => {
-                    warn!("Failed to parse {}: {}", config_path.display(), e);
-                }
+                    Err(e) => warn!("Failed to parse {}: {}", config_path.display(), e),
+                },
+                Err(e) => warn!("Failed to read {}: {}", config_path.display(), e),
+            }
+        }
+
+        match builder.build() {
+            Ok(matcher) => Self {
+                inner: Some(matcher),
             },
             Err(e) => {
-                warn!("Failed to read {}: {}", config_path.display(), e);
+                warn!("Failed to build ignore matcher: {}", e);
+                Self { inner: None }
             }
         }
     }
 
-    match builder.build() {
-        Ok(matcher) => Some(matcher),
-        Err(e) => {
-            warn!("Failed to build ignore matcher: {}", e);
-            None
-        }
+    /// Returns `true` if `path` should be ignored.
+    pub fn is_ignored(&self, path: &Path, is_dir: bool) -> bool {
+        self.inner
+            .as_ref()
+            .map(|m| m.matched_path_or_any_parents(path, is_dir).is_ignore())
+            .unwrap_or(false)
     }
 }
 
-fn is_ignored(path: &Path, is_dir: bool, matcher: Option<&Gitignore>) -> bool {
-    matcher
-        .map(|m| m.matched_path_or_any_parents(path, is_dir).is_ignore())
-        .unwrap_or(false)
-}
-
 /// Indexes a directory and returns the code graph.
 ///
 /// This walks all source files, parses them, and builds the
@@ -158,7 +186,7 @@ pub fn index_directory(root: &Path, options: IndexOptions) -> Result<IndexResult
             });
 
     // Walk the directory, respecting ignore files and collecting supported files.
-    let ignore_matcher = build_ignore_matcher(root);
+    let ignore_matcher = IgnoreMatcher::new(root);
     let walker = WalkBuilder::new(root)
         .hidden(true) // Skip hidden files
         .git_ignore(true) // Respect .gitignore
@@ -174,10 +202,9 @@ pub fn index_directory(root: &Path, options: IndexOptions) -> Result<IndexResult
         .filter_map(Result::ok)
         .filter(|entry| {
             let path = entry.path();
-            if is_ignored(
+            if ignore_matcher.is_ignored(
                 path,
                 entry.file_type().map(|ft| ft.is_dir()).unwrap_or(false),
-                ignore_matcher.as_ref(),
             ) {
                 return false;
             }
@@ -317,7 +344,7 @@ pub fn parse_single_file(path: &Path) -> Result<Vec<CodeNode>, arbor_core::Parse
 /// UNIX epoch. Catches edits and additions; a lone deletion leaves no newer
 /// file, so it is picked up on the next edit instead.
 pub fn sources_newer_than(root: &Path, cache_mtime: u64, follow_symlinks: bool) -> bool {
-    let ignore_matcher = build_ignore_matcher(root);
+    let ignore_matcher = IgnoreMatcher::new(root);
     let walker = WalkBuilder::new(root)
         .hidden(true)
         .git_ignore(true)
@@ -331,10 +358,9 @@ pub fn sources_newer_than(root: &Path, cache_mtime: u64, follow_symlinks: bool)
 
     for entry in walker.filter_map(Result::ok) {
         let path = entry.path();
-        if is_ignored(
+        if ignore_matcher.is_ignored(
             path,
             entry.file_type().map(|ft| ft.is_dir()).unwrap_or(false),
-            ignore_matcher.as_ref(),
         ) {
             continue;
         }
diff --git a/crates/arbor-watcher/src/lib.rs b/crates/arbor-watcher/src/lib.rs
index 4ac7d2c..05ebf5f 100644
--- a/crates/arbor-watcher/src/lib.rs
+++ b/crates/arbor-watcher/src/lib.rs
@@ -10,5 +10,5 @@
 mod indexer;
 mod watcher;
 
-pub use indexer::{index_directory, sources_newer_than, IndexOptions, IndexResult};
+pub use indexer::{index_directory, sources_newer_than, IgnoreMatcher, IndexOptions, IndexResult};
 pub use watcher::{FileChange, FileWatcher};

From fb90cd1575d038453de1dd6db739d7e4c1d5eb54 Mon Sep 17 00:00:00 2001
From: w0wl0lxd <w0wl0lxd@tuta.com>
Date: Mon, 10 Aug 2026 21:50:36 -0400
Subject: [PATCH 4/4] refactor(server): extract broadcast_graph_update helper
 in background indexer

---
 crates/arbor-server/src/sync_server.rs | 72 +++++++++++---------------
 1 file changed, 31 insertions(+), 41 deletions(-)

diff --git a/crates/arbor-server/src/sync_server.rs b/crates/arbor-server/src/sync_server.rs
index 32287de..9f41023 100644
--- a/crates/arbor-server/src/sync_server.rs
+++ b/crates/arbor-server/src/sync_server.rs
@@ -618,6 +618,35 @@ fn should_process_file(path: &Path, extensions: &[String], ignore_matcher: &Igno
 // Background Indexer
 // ─────────────────────────────────────────────────────────────────────────────
 
+/// Recompute centrality for the patched graph and broadcast the update.
+fn broadcast_graph_update(
+    g: &mut ArborGraph,
+    broadcast_tx: &broadcast::Sender<BroadcastMessage>,
+    changed_files: Vec<String>,
+) {
+    // Recompute centrality so the code map stays in sync with the
+    // patched graph — new nodes start at 0.0 otherwise and the map drifts.
+    // Warm-started from the previous scores, so a single-file patch
+    // converges in a round or two instead of the full budget.
+    let scores = compute_centrality_warm(g, 20, 0.85, Some(g.centrality_map()));
+    g.set_centrality(scores.into_map());
+
+    let update = BroadcastMessage::GraphUpdate(GraphUpdatePayload {
+        is_delta: true,
+        node_count: g.node_count(),
+        edge_count: g.edge_count(),
+        file_count: g.stats().files,
+        changed_files,
+        timestamp: std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .map_or(0, |d| d.as_secs()),
+        nodes: Some(g.nodes().cloned().collect()),
+        edges: Some(g.export_edges()),
+    });
+
+    let _ = broadcast_tx.send(update);
+}
+
 /// Runs the background indexer that processes file changes.
 ///
 /// The CPU-heavy graph update and centrality recompute are moved to
@@ -714,14 +743,6 @@ async fn run_background_indexer(
                                 }
                             }
 
-                            // Recompute centrality so the code map stays in sync with the
-                            // patched graph — new nodes start at 0.0 otherwise and the map drifts.
-                            // Warm-started from the previous scores, so a single-file patch
-                            // converges in a round or two instead of the full budget.
-                            let scores =
-                                compute_centrality_warm(&g, 20, 0.85, Some(g.centrality_map()));
-                            g.set_centrality(scores.into_map());
-
                             let elapsed = start.elapsed();
                             info!(
                                 "✅ Indexed {} in {:?} ({} symbols, {} relations)",
@@ -731,21 +752,7 @@ async fn run_background_indexer(
                                 result.relations.len()
                             );
 
-                            // Broadcast update
-                            let update = BroadcastMessage::GraphUpdate(GraphUpdatePayload {
-                                is_delta: true,
-                                node_count: g.node_count(),
-                                edge_count: g.edge_count(),
-                                file_count: g.stats().files,
-                                changed_files: vec![result.file_path],
-                                timestamp: std::time::SystemTime::now()
-                                    .duration_since(std::time::UNIX_EPOCH)
-                                    .map_or(0, |d| d.as_secs()),
-                                nodes: Some(g.nodes().cloned().collect()),
-                                edges: Some(g.export_edges()),
-                            });
-
-                            let _ = broadcast_tx.send(update);
+                            broadcast_graph_update(&mut g, &broadcast_tx, vec![result.file_path]);
                         }
                         Err(e) => {
                             warn!("⚠️  Parse error for {}: {}", file_name, e);
@@ -760,24 +767,7 @@ async fn run_background_indexer(
                     let mut g = graph.blocking_write();
                     g.remove_file(&file_str);
 
-                    // Recompute centrality so the code map reflects the removed nodes.
-                    let scores = compute_centrality_warm(&g, 20, 0.85, Some(g.centrality_map()));
-                    g.set_centrality(scores.into_map());
-
-                    let update = BroadcastMessage::GraphUpdate(GraphUpdatePayload {
-                        is_delta: true,
-                        node_count: g.node_count(),
-                        edge_count: g.edge_count(),
-                        file_count: g.stats().files,
-                        changed_files: vec![file_str],
-                        timestamp: std::time::SystemTime::now()
-                            .duration_since(std::time::UNIX_EPOCH)
-                            .map_or(0, |d| d.as_secs()),
-                        nodes: Some(g.nodes().cloned().collect()),
-                        edges: Some(g.export_edges()),
-                    });
-
-                    let _ = broadcast_tx.send(update);
+                    broadcast_graph_update(&mut g, &broadcast_tx, vec![file_str]);
                 }
             }