refactor(git): async operations and single-pass diff parsing

Replace std::process::Command with tokio::process::Command for all git
CLI calls. Reduce N+1 process spawns to 2 by parsing a single unified
diff into per-file sections. Pre-fetch file content into HashMaps
before sync tree-sitter analysis.

Author: Sephyi

Cargo.toml

@@ -16,7 +16,7 @@ clap = { version = "4.5", features = ["derive", "env"] }
 clap_complete = "4.5"
 
 # Async runtime
-tokio = { version = "1.43", features = ["rt-multi-thread", "macros", "signal", "sync"] }
+tokio = { version = "1.43", features = ["rt-multi-thread", "macros", "signal", "sync", "process"] }
 tokio-stream = "0.1"
 tokio-util = "0.7"
 

src/app.rs

@@ -2,9 +2,12 @@
 //
 // SPDX-License-Identifier: GPL-3.0-only
 
+use std::collections::HashMap;
+use std::io::IsTerminal;
+use std::path::PathBuf;
+
 use console::style;
 use dialoguer::Confirm;
-use std::io::IsTerminal;
 use tokio::signal;
 use tokio::sync::mpsc;
 use tokio_util::sync::CancellationToken;
@@ -66,7 +69,7 @@ impl App {
         self.print_status("Analyzing staged changes...");
 
         let git = GitService::discover()?;
-        let changes = git.get_staged_changes(self.config.max_file_lines)?;
+        let changes = git.get_staged_changes(self.config.max_file_lines).await?;
 
         self.print_info(&format!(
             "{} files with changes detected (+{} -{})",
@@ -108,16 +111,29 @@ impl App {
             return Err(Error::Cancelled);
         }
 
-        // Step 3: Analyze code with tree-sitter
+        // Step 3: Pre-fetch file content and analyze with tree-sitter
         self.print_status("Extracting code symbols...");
 
         let mut analyzer = AnalyzerService::new()?;
 
-        let git_ref = &git;
+        // Pre-fetch all file content asynchronously, then pass as sync maps
+        let file_paths: Vec<PathBuf> = changes.files.iter().map(|f| f.path.clone()).collect();
+        let mut staged_map: HashMap<PathBuf, String> = HashMap::new();
+        let mut head_map: HashMap<PathBuf, String> = HashMap::new();
+
+        for path in &file_paths {
+            if let Some(content) = git.get_staged_content(path).await {
+                staged_map.insert(path.clone(), content);
+            }
+            if let Some(content) = git.get_head_content(path).await {
+                head_map.insert(path.clone(), content);
+            }
+        }
+
         let symbols = analyzer.extract_symbols(
             &changes.files,
-            &|path| git_ref.get_staged_content(path),
-            &|path| git_ref.get_head_content(path),
+            &|path| staged_map.get(path).cloned(),
+            &|path| head_map.get(path).cloned(),
         );
 
         debug!(count = symbols.len(), "symbols extracted");
@@ -221,7 +237,7 @@ impl App {
         }
 
         // Create commit
-        git.commit(&message)?;
+        git.commit(&message).await?;
 
         eprintln!("{} Committed!", style("✓").green().bold());
 

src/services/git.rs

@@ -2,8 +2,11 @@
 //
 // SPDX-License-Identifier: GPL-3.0-only
 
+use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
+use tokio::process::Command;
+
 use crate::domain::{ChangeStatus, DiffStats, FileCategory, FileChange, StagedChanges};
 use crate::error::{Error, Result};
 
@@ -25,33 +28,52 @@ impl GitService {
     }
 
     pub fn check_state(&self) -> Result<()> {
-        // Check for merge/rebase in progress
         let state = self.repo.state();
         if matches!(state, Some(gix::state::InProgress::Merge)) {
             return Err(Error::MergeInProgress);
         }
         Ok(())
     }
 
-    pub fn get_staged_changes(&self, max_file_lines: usize) -> Result<StagedChanges> {
-        self.check_state()?;
+    // ─── Async Git Helpers ───
 
-        // Use git diff --cached --name-status to get list of staged files
-        let output = std::process::Command::new("git")
-            .args(["diff", "--cached", "--name-status", "--no-renames"])
+    async fn run_git(&self, args: &[&str]) -> Result<String> {
+        let output = Command::new("git")
+            .args(args)
             .current_dir(&self.work_dir)
-            .output()?;
+            .output()
+            .await?;
 
         if !output.status.success() {
             let stderr = String::from_utf8_lossy(&output.stderr);
             return Err(Error::Git(stderr.to_string()));
         }
 
+        Ok(String::from_utf8_lossy(&output.stdout).into_owned())
+    }
+
+    // ─── Staged Changes (Single-Pass Diff) ───
+
+    pub async fn get_staged_changes(&self, max_file_lines: usize) -> Result<StagedChanges> {
+        self.check_state()?;
+
+        // Two calls total (down from N+1): name-status + unified diff
+        let (status_output, diff_output) = tokio::try_join!(
+            self.run_git(&["diff", "--cached", "--name-status", "--no-renames"]),
+            self.run_git(&[
+                "diff",
+                "--cached",
+                "--no-ext-diff",
+                "--unified=3",
+                "--no-renames"
+            ]),
+        )?;
+
+        let file_diffs = Self::split_unified_diff(&diff_output);
+
         let mut files = Vec::new();
         let mut stats = DiffStats::default();
 
-        let status_output = String::from_utf8_lossy(&output.stdout);
-
         for line in status_output.lines() {
             if line.is_empty() {
                 continue;
@@ -74,11 +96,14 @@ impl GitService {
             let is_binary = Self::is_binary_path(&file_path);
 
             if is_binary {
-                continue; // Skip binary files
+                continue;
             }
 
-            // Get diff content
-            let diff = self.get_file_diff(&file_path, max_file_lines)?;
+            let diff = file_diffs
+                .get(parts[1])
+                .map(|d| Self::truncate_diff(d, max_file_lines))
+                .unwrap_or_default();
+
             let (additions, deletions) = Self::count_changes(&diff);
 
             files.push(FileChange {
@@ -103,33 +128,61 @@ impl GitService {
         Ok(StagedChanges { files, stats })
     }
 
-    fn get_file_diff(&self, path: &Path, max_lines: usize) -> Result<String> {
-        // Use git command for reliable diff output
-        // --no-ext-diff: don't use external diff tools
-        // --unified=3: standard 3 lines of context
-        let output = std::process::Command::new("git")
-            .args(["diff", "--cached", "--no-ext-diff", "--unified=3", "--"])
-            .arg(path)
-            .current_dir(&self.work_dir)
-            .output()?;
+    /// Split a unified diff into per-file sections keyed by file path.
+    fn split_unified_diff(diff: &str) -> HashMap<String, String> {
+        let mut result = HashMap::new();
+        let mut current_path: Option<String> = None;
+        let mut current_lines: Vec<&str> = Vec::new();
 
-        if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            return Err(Error::Git(stderr.to_string()));
+        for line in diff.lines() {
+            if line.starts_with("diff --git ") {
+                // Save previous file's accumulated diff
+                if let Some(path) = current_path.take() {
+                    result.insert(path, current_lines.join("\n"));
+                }
+                current_lines.clear();
+            }
+
+            // Extract path from +++ header (reliable for added/modified files)
+            if let Some(path) = line.strip_prefix("+++ b/") {
+                current_path = Some(path.to_string());
+            }
+            // For deleted files, +++ is /dev/null — use --- header instead
+            if line == "+++ /dev/null" {
+                if 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());
+                    }
+                }
+            }
+
+            current_lines.push(line);
         }
 
-        let diff = String::from_utf8_lossy(&output.stdout);
-        let lines: Vec<&str> = diff.lines().take(max_lines).collect();
+        // Don't forget the last file
+        if let Some(path) = current_path {
+            result.insert(path, current_lines.join("\n"));
+        }
+
+        result
+    }
 
-        Ok(lines.join("\n"))
+    fn truncate_diff(diff: &str, max_lines: usize) -> String {
+        let lines: Vec<&str> = diff.lines().take(max_lines).collect();
+        lines.join("\n")
     }
 
+    // ─── File Content ───
+
     /// Get staged file content (from index)
-    pub fn get_staged_content(&self, path: &Path) -> Option<String> {
-        let output = std::process::Command::new("git")
+    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()?;
 
         if output.status.success() {
@@ -140,11 +193,12 @@ impl GitService {
     }
 
     /// Get HEAD file content
-    pub fn get_head_content(&self, path: &Path) -> Option<String> {
-        let output = std::process::Command::new("git")
+    pub async fn get_head_content(&self, path: &Path) -> Option<String> {
+        let output: std::process::Output = Command::new("git")
             .args(["show", &format!("HEAD:{}", path.display())])
             .current_dir(&self.work_dir)
             .output()
+            .await
             .ok()?;
 
         if output.status.success() {
@@ -154,6 +208,8 @@ impl GitService {
         }
     }
 
+    // ─── Diff Parsing ───
+
     fn count_changes(diff: &str) -> (usize, usize) {
         let mut additions = 0;
         let mut deletions = 0;
@@ -199,11 +255,14 @@ impl GitService {
         )
     }
 
-    pub fn commit(&self, message: &str) -> Result<()> {
-        let output = std::process::Command::new("git")
+    // ─── Commit ───
+
+    pub async fn commit(&self, message: &str) -> Result<()> {
+        let output = Command::new("git")
             .args(["commit", "-m", message])
             .current_dir(&self.work_dir)
-            .output()?;
+            .output()
+            .await?;
 
         if !output.status.success() {
             let stderr = String::from_utf8_lossy(&output.stderr);