refactor: implement git staging/unstaging and fix status updates

- Backend (Rust):
  - Refactored GitManager to support individual file stage/unstage events.
  - Added check in stage() to handle deleted files by removing them from index.
  - Improved check_status_changed_for_paths to handle file status errors gracefully.
  - Implemented background status watcher that emits 'git:update' events.
- Frontend (React):
  - Redesigned ChangesPanel to list changes in Merged, Staged, and Changes groups.
  - Added stage/unstage buttons and actions.
  - Fixed keyboard navigation, selection, and ref scrolling bugs for files with both staged and unstaged changes using unique row IDs ('mode::path').

Author: vipmax

anycode-backend/src/app_state.rs

@@ -53,7 +53,8 @@ impl AppState {
         lsp_manager.set_diagnostics_sender(diagnostic_tx);
 
         let acp_manager = AcpManager::new(acp_permission_mode, acp_fs_tx);
-        let git_manager = GitManager::new(crate::utils::current_dir());
+        let mut git_manager = GitManager::new(crate::utils::current_dir());
+        let _ = git_manager.refresh_status_cache();
 
         Self {
             config: Arc::new(config),

anycode-backend/src/background_tasks.rs

@@ -7,6 +7,7 @@ use notify::{Event, RecursiveMode, Watcher, recommended_watcher};
 use socketioxide::SocketIo;
 use tokio::sync::mpsc::Receiver;
 use tokio::sync::{Mutex, mpsc};
+use tokio::time::{self, Duration};
 
 use crate::acp_fs;
 use crate::app_state::AppState;
@@ -25,10 +26,35 @@ pub fn spawn_all(
 ) -> Result<notify::RecommendedWatcher> {
     spawn_acp_fs(state, io, acp_fs_rx);
     spawn_diagnostics(io, diagnostics_rx);
+    spawn_git_status_watcher(state, io);
     let watcher = spawn_file_watcher(state, io)?;
     Ok(watcher)
 }
 
+fn spawn_git_status_watcher(state: &AppState, io: &Arc<SocketIo>) {
+    let git_manager = state.git_manager.clone();
+    let socket = io.clone();
+
+    tokio::spawn(async move {
+        let mut ticker = time::interval(Duration::from_secs(1));
+        loop {
+            ticker.tick().await;
+
+            let update = {
+                let mut git = git_manager.lock().await;
+                git.check_status_changed().map(|status| status.to_json())
+            };
+
+            if let Some(status_update) = update {
+                let send_result = socket.emit("git:update", &status_update).await;
+                if let Err(e) = send_result {
+                    tracing::error!("error while sending git:update {}", e);
+                }
+            }
+        }
+    });
+}
+
 fn spawn_acp_fs(
     state: &AppState,
     io: &Arc<SocketIo>,

anycode-backend/src/git.rs

@@ -20,6 +20,9 @@ pub enum FileStatus {
 pub struct GitFileStatus {
     pub path: String,
     pub status: FileStatus,
+    pub staged: bool,
+    pub unstaged: bool,
+    pub conflicted: bool,
     pub added: usize,
     pub removed: usize,
 }
@@ -44,6 +47,9 @@ impl GitStatus {
 pub struct GitStatusPatchFile {
     pub path: String,
     pub status: String,
+    pub staged: bool,
+    pub unstaged: bool,
+    pub conflicted: bool,
     pub added: usize,
     pub removed: usize,
 }
@@ -118,6 +124,19 @@ impl GitManager {
         Repository::discover(&self.workdir).context("Failed to discover git repository")
     }
 
+    fn sort_files(files: &mut [GitFileStatus]) {
+        files.sort_by(|a, b| {
+            a.path
+                .cmp(&b.path)
+                .then_with(|| Self::status_to_str(a.status).cmp(Self::status_to_str(b.status)))
+                .then_with(|| a.staged.cmp(&b.staged))
+                .then_with(|| a.unstaged.cmp(&b.unstaged))
+                .then_with(|| a.conflicted.cmp(&b.conflicted))
+                .then_with(|| a.added.cmp(&b.added))
+                .then_with(|| a.removed.cmp(&b.removed))
+        });
+    }
+
     /// Check if a path should be ignored (in .git or gitignored)
     pub fn should_ignore(&self, path: &Path) -> bool {
         let path_str = path.to_string_lossy();
@@ -225,11 +244,7 @@ impl GitManager {
             }
         }
 
-        info!(
-            "Git status: {} files changed on branch {}",
-            files.len(),
-            branch
-        );
+        Self::sort_files(&mut files);
 
         Ok(GitStatus { files, branch })
     }
@@ -261,6 +276,12 @@ impl GitManager {
     }
 
     pub fn check_status_changed_for_paths(&mut self, paths: &[PathBuf]) -> Option<GitStatusUpdate> {
+        if self.status_cache.files.is_empty() && self.status_cache.branch.is_empty() {
+            let full = self.status().ok()?;
+            self.status_cache = full.clone();
+            return Some(GitStatusUpdate::Full(full));
+        }
+
         let repo = self.repo().ok()?;
         let repo_root = repo.workdir().unwrap_or(Path::new("."));
         let branch = Self::branch_name(&repo);
@@ -290,7 +311,13 @@ impl GitManager {
             }
 
             let abs_path = repo_root.join(&relative_path).to_string_lossy().to_string();
-            let next_file = self.status_for_relative_path(&repo, &relative_path).ok()?;
+            let next_file = match self.status_for_relative_path(&repo, &relative_path) {
+                Ok(file) => file,
+                Err(e) => {
+                    tracing::warn!("Failed to get status for {}: {}", abs_path, e);
+                    continue;
+                }
+            };
             let prev_index = self
                 .status_cache
                 .files
@@ -309,17 +336,24 @@ impl GitManager {
             if let Some(file) = next_file.clone() {
                 self.status_cache.files.push(file);
             }
+            Self::sort_files(&mut self.status_cache.files);
 
             match next_file {
                 Some(file) => patch_files.push(GitStatusPatchFile {
                     path: file.path,
                     status: Self::status_to_str(file.status).to_string(),
+                    staged: file.staged,
+                    unstaged: file.unstaged,
+                    conflicted: file.conflicted,
                     added: file.added,
                     removed: file.removed,
                 }),
                 None => patch_files.push(GitStatusPatchFile {
                     path: abs_path,
                     status: "removed".to_string(),
+                    staged: false,
+                    unstaged: false,
+                    conflicted: false,
                     added: 0,
                     removed: 0,
                 }),
@@ -382,38 +416,12 @@ impl GitManager {
         })
     }
 
-    /// Commit files
-    pub fn commit(&self, files: &[String], message: &str) -> Result<()> {
+    /// Commit currently staged index entries (like `git commit`)
+    pub fn commit(&self, message: &str) -> Result<()> {
         let repo = self.repo()?;
         let mut index = repo.index()?;
         let head_commit = repo.head().ok().and_then(|h| h.peel_to_commit().ok());
 
-        // Build commit index from HEAD tree so the commit contains only explicitly
-        // selected paths from the UI, not previously staged leftovers.
-        if let Some(head) = &head_commit {
-            let head_tree = head.tree()?;
-            index.read_tree(&head_tree)?;
-        } else {
-            index.clear()?;
-        }
-
-        let repo_root = repo.workdir().unwrap_or(Path::new("."));
-        for file_path in files {
-            let path = Path::new(file_path);
-            let relative_path = if path.is_absolute() {
-                path.strip_prefix(repo_root).unwrap_or(path)
-            } else {
-                path
-            };
-
-            let full_path = repo_root.join(relative_path);
-            if full_path.exists() {
-                index.add_path(relative_path)?;
-            } else {
-                index.remove_path(relative_path)?;
-            }
-        }
-
         index.write()?;
 
         let tree_id = index.write_tree()?;
@@ -426,7 +434,50 @@ impl GitManager {
         repo.commit(Some("HEAD"), &sig, &sig, message, &tree, &parents_refs)
             .context("Failed to commit")?;
 
-        info!("Committed {} files: {}", files.len(), message);
+        info!("Committed staged index: {}", message);
+        Ok(())
+    }
+
+    /// Stage file in index (like `git add <path>`)
+    pub fn stage(&self, path: &str) -> Result<()> {
+        let repo = self.repo()?;
+        let repo_root = repo.workdir().unwrap_or(Path::new("."));
+        let file_path = Path::new(path);
+        let relative_path = if file_path.is_absolute() {
+            file_path.strip_prefix(repo_root).unwrap_or(file_path)
+        } else {
+            file_path
+        };
+
+        let mut index = repo.index()?;
+        if repo_root.join(relative_path).exists() {
+            index.add_path(relative_path)?;
+        } else {
+            let _ = index.remove_path(relative_path);
+        }
+        index.write()?;
+        Ok(())
+    }
+
+    /// Unstage file from index (like `git restore --staged <path>`)
+    pub fn unstage(&self, path: &str) -> Result<()> {
+        let repo = self.repo()?;
+        let repo_root = repo.workdir().unwrap_or(Path::new("."));
+        let file_path = Path::new(path);
+        let relative_path = if file_path.is_absolute() {
+            file_path.strip_prefix(repo_root).unwrap_or(file_path)
+        } else {
+            file_path
+        };
+
+        let head = repo.head().ok().and_then(|h| h.peel_to_commit().ok());
+        if let Some(commit) = head {
+            repo.reset_default(Some(commit.as_object()), [relative_path])?;
+        } else {
+            let mut index = repo.index()?;
+            let _ = index.remove_path(relative_path);
+            index.write()?;
+        }
         Ok(())
     }
 
@@ -667,16 +718,32 @@ impl GitManager {
         added: usize,
         removed: usize,
     ) -> Option<GitFileStatus> {
-        let file_status = if status.contains(Status::WT_NEW) || status.contains(Status::INDEX_NEW) {
+        let conflicted = status.contains(Status::CONFLICTED);
+        let staged = status.intersects(
+            Status::INDEX_NEW
+                | Status::INDEX_MODIFIED
+                | Status::INDEX_DELETED
+                | Status::INDEX_RENAMED
+                | Status::INDEX_TYPECHANGE,
+        );
+        let unstaged = status.intersects(
+            Status::WT_NEW
+                | Status::WT_MODIFIED
+                | Status::WT_DELETED
+                | Status::WT_RENAMED
+                | Status::WT_TYPECHANGE,
+        );
+
+        let file_status = if conflicted {
+            FileStatus::Conflict
+        } else if status.contains(Status::WT_NEW) || status.contains(Status::INDEX_NEW) {
             FileStatus::Added
         } else if status.contains(Status::WT_DELETED) || status.contains(Status::INDEX_DELETED) {
             FileStatus::Deleted
         } else if status.contains(Status::WT_MODIFIED) || status.contains(Status::INDEX_MODIFIED) {
             FileStatus::Modified
         } else if status.contains(Status::WT_RENAMED) || status.contains(Status::INDEX_RENAMED) {
             FileStatus::Renamed
-        } else if status.contains(Status::CONFLICTED) {
-            FileStatus::Conflict
         } else {
             return None;
         };
@@ -694,6 +761,9 @@ impl GitManager {
         Some(GitFileStatus {
             path: repo_root.join(relative_path).to_string_lossy().to_string(),
             status: file_status,
+            staged,
+            unstaged,
+            conflicted,
             added,
             removed,
         })

anycode-backend/src/handlers/connection_handler.rs

@@ -58,6 +58,8 @@ pub async fn handle_connect(socket: SocketRef, _state: State<AppState>) {
     socket.on("git:branches", handle_git_branches);
     socket.on("git:checkout", handle_git_checkout);
     socket.on("git:revert", handle_git_revert);
+    socket.on("git:stage", handle_git_stage);
+    socket.on("git:unstage", handle_git_unstage);
 
     socket.on("theme:list", handle_theme_list);
     socket.on("theme:get", handle_theme_get);

anycode-backend/src/handlers/git_handler.rs

@@ -11,7 +11,6 @@ pub struct GitFileOriginalRequest {
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct GitCommitRequest {
-    pub files: Vec<String>,
     pub message: String,
 }
 
@@ -58,11 +57,11 @@ pub async fn handle_git_commit(
     ack: AckSender,
     state: State<AppState>,
 ) {
-    info!("Received git:commit: {} files", request.files.len());
+    info!("Received git:commit");
 
     let (result, changes_update) = {
         let mut git = state.git_manager.lock().await;
-        match git.commit(&request.files, &request.message) {
+        match git.commit(&request.message) {
             Ok(_) => {
                 let status = git.refresh_status_cache().map(|s| s.to_json());
                 (Ok(json!({})), status.ok())
@@ -74,8 +73,8 @@ pub async fn handle_git_commit(
     send_response(ack, result);
 
     if let Some(update) = changes_update {
-        let _ = socket.emit("changes:update", &update);
-        let _ = socket.broadcast().emit("changes:update", &update).await;
+        let _ = socket.emit("git:update", &update);
+        let _ = socket.broadcast().emit("git:update", &update).await;
     }
 }
 
@@ -133,3 +132,34 @@ pub async fn handle_git_revert(
     };
     send_response(ack, result);
 }
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct GitStageRequest {
+    pub path: String,
+}
+
+pub async fn handle_git_stage(
+    Data(request): Data<GitStageRequest>,
+    ack: AckSender,
+    state: State<AppState>,
+) {
+    info!("Received git:stage: {:?}", request.path);
+    let result = {
+        let git = state.git_manager.lock().await;
+        git.stage(&request.path).map(|_| json!({}))
+    };
+    send_response(ack, result);
+}
+
+pub async fn handle_git_unstage(
+    Data(request): Data<GitStageRequest>,
+    ack: AckSender,
+    state: State<AppState>,
+) {
+    info!("Received git:unstage: {:?}", request.path);
+    let result = {
+        let git = state.git_manager.lock().await;
+        git.unstage(&request.path).map(|_| json!({}))
+    };
+    send_response(ack, result);
+}

anycode-backend/src/handlers/watch_handler.rs

@@ -200,10 +200,7 @@ async fn process_watch_event(
     let is_parent_opened = is_parent_dir_opened(path, socket2data).await;
 
     let watch_action = classify_watch_transition(last_state, current_state, is_opened_file);
-    info!(
-        "watch action: is_opened_file:{is_opened_file} is_cached_in_file2code:{is_cached_in_file2code} is_parent_opened:{is_parent_opened} {:?} for path: {:?}",
-        watch_action, path
-    );
+    info!("watch action:  {:?} for path: {:?}", watch_action, path);
 
     match watch_action {
         WatchAction::Create => {
@@ -304,7 +301,7 @@ async fn handle_changes_update(
     };
 
     if let Some(update) = update {
-        let _ = socket.emit("changes:update", &update.to_json()).await;
+        let _ = socket.emit("git:update", &update.to_json()).await;
     }
 }