refactor: use Arc<String> for diffs, rayon parsing, concurrent git fetching

Sephyi · Sephyi · commit 9184188c1bc6 · 2026-03-08T02:18:32.000+01:00
- FileChange.diff uses Arc&lt;String&gt; to avoid expensive cloning in split flow
- AnalyzerService.extract_symbols uses rayon par_iter for parallel
  tree-sitter parsing (Parser created per-file, not Send/Sync)
- GitService.fetch_file_contents fetches staged+HEAD content concurrently
  via tokio JoinSet instead of sequential per-file calls
- Apply let-chain idioms in config.rs, anthropic.rs, ollama.rs, git.rs
diff --git a/src/config.rs b/src/config.rs
@@ -171,10 +171,10 @@ impl Config {
         }
 
         // User-level config
-        if let Some(path) = Self::config_path() {
-            if path.exists() {
-                figment = figment.merge(Toml::file(&path));
-            }
+        if let Some(path) = Self::config_path()
+            && path.exists()
+        {
+            figment = figment.merge(Toml::file(&path));
         }
 
         // Environment variables (COMMITBEE_MODEL, COMMITBEE_PROVIDER, etc.)
diff --git a/src/domain/change.rs b/src/domain/change.rs
@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: PolyForm-Noncommercial-1.0.0
 
 use std::path::PathBuf;
+use std::sync::Arc;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ChangeStatus {
@@ -49,11 +50,43 @@ impl FileCategory {
         // Build/CI detection
         if path.starts_with(".github/")
             || path_str.contains("/.github/")
+            || path.starts_with(".gitlab-ci")
+            || path.starts_with(".circleci/")
+            || path_str.contains("/.circleci/")
             || matches!(
                 name,
-                "Dockerfile" | "docker-compose.yml" | "Makefile" | "justfile" | ".dockerignore"
+                "Dockerfile"
+                    | "Containerfile"
+                    | "docker-compose.yml"
+                    | "docker-compose.yaml"
+                    | "podman-compose.yml"
+                    | "podman-compose.yaml"
+                    | "compose.yml"
+                    | "compose.yaml"
+                    | "Makefile"
+                    | "justfile"
+                    | ".dockerignore"
+                    | ".containerignore"
+                    | "Jenkinsfile"
+                    | "Procfile"
+                    | "CMakeLists.txt"
+                    | "Makefile.am"
+                    | "configure.ac"
+                    | ".travis.yml"
+                    | "azure-pipelines.yml"
+                    | "netlify.toml"
+                    | "vercel.json"
+                    | "fly.toml"
+                    | "render.yaml"
+                    | "railway.toml"
+                    | "Earthfile"
+                    | "Tiltfile"
+                    | "skaffold.yaml"
+                    | "helmfile.yaml"
+                    | "Vagrantfile"
             )
             || ext == "dockerfile"
+            || ext == "containerfile"
         {
             return Self::Build;
         }
@@ -72,14 +105,56 @@ impl FileCategory {
                 | "go.mod"
                 | "go.sum"
                 | "bun.lockb"
+                | "biome.json"
+                | "biome.jsonc"
+                | "deno.json"
+                | "deno.jsonc"
+                | ".eslintrc"
+                | ".eslintrc.json"
+                | ".eslintrc.js"
+                | ".prettierrc"
+                | ".prettierrc.json"
+                | "ruff.toml"
+                | ".ruff.toml"
+                | "setup.py"
+                | "setup.cfg"
+                | "tox.ini"
+                | "Pipfile"
+                | "Pipfile.lock"
+                | "uv.lock"
+                | "Gemfile"
+                | "Gemfile.lock"
+                | "Rakefile"
+                | "pom.xml"
+                | "build.gradle"
+                | "build.gradle.kts"
+                | "settings.gradle"
+                | "settings.gradle.kts"
+                | "mix.exs"
+                | "pubspec.yaml"
+                | "pubspec.lock"
+                | "REUSE.toml"
+                | ".editorconfig"
+                | "flake.nix"
+                | "flake.lock"
+                | "renovate.json"
+                | "dependabot.yml"
         ) {
             return Self::Config;
         }
 
+        // Dotfiles with config extensions
+        if name.starts_with('.') && matches!(ext, "json" | "yaml" | "yml" | "toml" | "ini" | "cfg")
+        {
+            return Self::Config;
+        }
+
         // By extension - source code
         match ext {
             "rs" | "ts" | "js" | "py" | "go" | "tsx" | "jsx" | "java" | "kt" | "c" | "cpp"
-            | "h" | "hpp" => Self::Source,
+            | "h" | "hpp" | "cs" | "rb" | "swift" | "scala" | "ex" | "exs" | "php" | "r"
+            | "lua" | "zig" | "nim" | "dart" | "vue" | "svelte" | "ml" | "mli" | "hs" | "clj"
+            | "cljs" | "erl" | "hrl" | "pl" | "pm" | "sh" | "bash" | "zsh" => Self::Source,
             _ => Self::Other,
         }
     }
@@ -100,7 +175,7 @@ impl FileCategory {
 pub struct FileChange {
     pub path: PathBuf,
     pub status: ChangeStatus,
-    pub diff: String,
+    pub diff: Arc<String>,
     pub additions: usize,
     pub deletions: usize,
     pub category: FileCategory,
diff --git a/src/services/analyzer.rs b/src/services/analyzer.rs
@@ -2,10 +2,12 @@
 //
 // SPDX-License-Identifier: PolyForm-Noncommercial-1.0.0
 
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
 use std::sync::LazyLock;
 
+use rayon::prelude::*;
 use regex::Regex;
-use std::path::Path;
 use tree_sitter::{Language, Parser};
 
 use crate::domain::{CodeSymbol, FileChange, SymbolKind};
@@ -81,59 +83,49 @@ impl AnalyzerService {
         Ok(Self)
     }
 
-    /// Extract symbols from file changes using full file content + hunk mapping
+    /// Extract symbols from file changes using full file content + hunk mapping.
+    /// Uses rayon to parse files in parallel across CPU cores.
     pub fn extract_symbols(
-        &mut self,
+        &self,
         changes: &[FileChange],
-        staged_content: &dyn Fn(&Path) -> Option<String>,
-        head_content: &dyn Fn(&Path) -> Option<String>,
+        staged_content: &HashMap<PathBuf, String>,
+        head_content: &HashMap<PathBuf, String>,
     ) -> Vec<CodeSymbol> {
-        let mut symbols = Vec::new();
-
-        for change in changes {
-            if change.is_binary {
-                continue;
-            }
-
-            let ext = change
-                .path
-                .extension()
-                .and_then(|e| e.to_str())
-                .unwrap_or("");
-
-            let hunks = DiffHunk::parse_from_diff(&change.diff);
-
-            // Get the appropriate language for parsing
-            let language: Option<Language> = match ext {
-                "rs" => Some(tree_sitter_rust::LANGUAGE.into()),
-                "ts" | "tsx" => Some(tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into()),
-                "py" => Some(tree_sitter_python::LANGUAGE.into()),
-                "go" => Some(tree_sitter_go::LANGUAGE.into()),
-                "js" | "jsx" => Some(tree_sitter_javascript::LANGUAGE.into()),
-                _ => None,
-            };
-
-            if let Some(lang) = language {
-                let file_symbols = Self::extract_for_file_static(
-                    lang,
-                    change,
-                    &hunks,
-                    staged_content,
-                    head_content,
-                );
-                symbols.extend(file_symbols);
-            }
-        }
-
-        symbols
+        changes
+            .par_iter()
+            .filter(|change| !change.is_binary)
+            .flat_map(|change| {
+                let ext = change
+                    .path
+                    .extension()
+                    .and_then(|e| e.to_str())
+                    .unwrap_or("");
+
+                let language: Option<Language> = match ext {
+                    "rs" => Some(tree_sitter_rust::LANGUAGE.into()),
+                    "ts" | "tsx" => Some(tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into()),
+                    "py" => Some(tree_sitter_python::LANGUAGE.into()),
+                    "go" => Some(tree_sitter_go::LANGUAGE.into()),
+                    "js" | "jsx" => Some(tree_sitter_javascript::LANGUAGE.into()),
+                    _ => None,
+                };
+
+                language
+                    .map(|lang| {
+                        let hunks = DiffHunk::parse_from_diff(&change.diff);
+                        Self::extract_for_file(lang, change, &hunks, staged_content, head_content)
+                    })
+                    .unwrap_or_default()
+            })
+            .collect()
     }
 
-    fn extract_for_file_static(
+    fn extract_for_file(
         language: Language,
         change: &FileChange,
         hunks: &[DiffHunk],
-        staged_content: &dyn Fn(&Path) -> Option<String>,
-        head_content: &dyn Fn(&Path) -> Option<String>,
+        staged_content: &HashMap<PathBuf, String>,
+        head_content: &HashMap<PathBuf, String>,
     ) -> Vec<CodeSymbol> {
         let mut parser = Parser::new();
         if parser.set_language(&language).is_err() {
@@ -143,23 +135,23 @@ impl AnalyzerService {
         let mut symbols = Vec::new();
 
         // Parse staged (new) file content
-        if let Some(content) = staged_content(&change.path) {
+        if let Some(content) = staged_content.get(&change.path) {
             let changed = Self::extract_changed_symbols_static(
                 &mut parser,
                 &change.path,
-                &content,
+                content,
                 hunks,
                 true,
             );
             symbols.extend(changed);
         }
 
         // Parse HEAD (old) file content
-        if let Some(content) = head_content(&change.path) {
+        if let Some(content) = head_content.get(&change.path) {
             let changed = Self::extract_changed_symbols_static(
                 &mut parser,
                 &change.path,
-                &content,
+                content,
                 hunks,
                 false,
             );
diff --git a/src/services/git.rs b/src/services/git.rs
@@ -4,6 +4,7 @@
 
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 use tokio::process::Command;
 
@@ -109,7 +110,7 @@ impl GitService {
             files.push(FileChange {
                 path: file_path,
                 status,
-                diff,
+                diff: Arc::new(diff),
                 additions,
                 deletions,
                 category,
@@ -148,14 +149,12 @@ impl GitService {
                 current_path = Some(path.to_string());
             }
             // For deleted files, +++ is /dev/null — use --- header instead
-            if line == "+++ /dev/null" {
-                if let Some(last_minus) =
+            if line == "+++ /dev/null"
+                && let Some(last_minus) =
                     current_lines.iter().rev().find(|l| l.starts_with("--- a/"))
-                {
-                    if let Some(path) = last_minus.strip_prefix("--- a/") {
-                        current_path = Some(path.to_string());
-                    }
-                }
+                && let Some(path) = last_minus.strip_prefix("--- a/")
+            {
+                current_path = Some(path.to_string());
             }
 
             current_lines.push(line);
@@ -176,27 +175,47 @@ impl GitService {
 
     // ─── File Content ───
 
-    /// Get staged file content (from index)
-    pub async fn get_staged_content(&self, path: &Path) -> Option<String> {
-        let output: std::process::Output = Command::new("git")
-            .args(["show", &format!(":0:{}", path.display())])
-            .current_dir(&self.work_dir)
-            .output()
-            .await
-            .ok()?;
+    /// Fetch staged and HEAD content for multiple files concurrently.
+    /// Spawns all git-show processes in parallel instead of sequentially.
+    pub async fn fetch_file_contents(
+        &self,
+        paths: &[PathBuf],
+    ) -> (HashMap<PathBuf, String>, HashMap<PathBuf, String>) {
+        let mut set = tokio::task::JoinSet::new();
+
+        for path in paths {
+            let work_dir = self.work_dir.clone();
+            let path = path.clone();
+            set.spawn(async move {
+                let staged =
+                    Self::fetch_git_show(&work_dir, &format!(":0:{}", path.display())).await;
+                let head =
+                    Self::fetch_git_show(&work_dir, &format!("HEAD:{}", path.display())).await;
+                (path, staged, head)
+            });
+        }
 
-        if output.status.success() {
-            String::from_utf8(output.stdout).ok()
-        } else {
-            None
+        let mut staged_map = HashMap::new();
+        let mut head_map = HashMap::new();
+
+        while let Some(result) = set.join_next().await {
+            if let Ok((path, staged, head)) = result {
+                if let Some(content) = staged {
+                    staged_map.insert(path.clone(), content);
+                }
+                if let Some(content) = head {
+                    head_map.insert(path, content);
+                }
+            }
         }
+
+        (staged_map, head_map)
     }
 
-    /// Get HEAD file content
-    pub async fn get_head_content(&self, path: &Path) -> Option<String> {
+    async fn fetch_git_show(work_dir: &Path, ref_path: &str) -> Option<String> {
         let output: std::process::Output = Command::new("git")
-            .args(["show", &format!("HEAD:{}", path.display())])
-            .current_dir(&self.work_dir)
+            .args(["show", ref_path])
+            .current_dir(work_dir)
             .output()
             .await
             .ok()?;
diff --git a/src/services/llm/anthropic.rs b/src/services/llm/anthropic.rs
@@ -179,11 +179,11 @@ impl AnthropicProvider {
                         if let Ok(event) = serde_json::from_str::<StreamEvent>(data) {
                             match event.event_type.as_str() {
                                 "content_block_delta" => {
-                                    if let Some(delta) = &event.delta {
-                                        if let Some(text) = &delta.text {
-                                            let _ = token_tx.send(text.clone()).await;
-                                            full_response.push_str(text);
-                                        }
+                                    if let Some(delta) = &event.delta
+                                        && let Some(text) = &delta.text
+                                    {
+                                        let _ = token_tx.send(text.clone()).await;
+                                        full_response.push_str(text);
                                     }
                                 }
                                 "message_stop" => {
diff --git a/src/services/llm/ollama.rs b/src/services/llm/ollama.rs

Original file line number	Diff line number	Diff line change
`@@ -171,10 +171,10 @@ impl Config {`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`// User-level config`
`174`		`- if let Some(path) = Self::config_path() {`
`175`		`- if path.exists() {`
`176`		`- figment = figment.merge(Toml::file(&path));`
`177`		`- }`
	`174`	`+ if let Some(path) = Self::config_path()`
	`175`	`+ && path.exists()`
	`176`	`+ {`
	`177`	`+ figment = figment.merge(Toml::file(&path));`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`// Environment variables (COMMITBEE_MODEL, COMMITBEE_PROVIDER, etc.)`