refactor(backend): modularize runtime wiring and harden git change propagation

vipmax · vipmax · commit 0cf54eec936c · 2026-05-26T16:56:08.000+03:00
Extracted backend startup responsibilities into dedicated modules to simplify main runtime wiring and improve maintainability.

- Added AppState::new(...) to centralize initialization of config, LSP manager, ACP manager, git manager, and shared maps.

- Introduced background_tasks module to spawn ACP FS loop, diagnostics forwarding, and file watcher lifecycle in one place.

- Moved Socket.IO connect/disconnect flow into handlers/connection_handler with a 5-second disconnect grace period before LSP/file cleanup.

- Moved SPA/static asset fallback logic into handlers/static_handler.

- Slimmed main.rs to orchestration only: build channels/state, create Socket.IO namespace, wire router, and keep watcher alive.

Also fixed commit/change-tracking behavior around source control updates:

- Emit changes:update immediately after successful git:commit so UI refresh does not depend solely on filesystem watcher side effects.

- Reworked GitManager::commit to rebuild index from HEAD before applying selected files, preventing unrelated pre-staged leftovers from being included in commit.

- This ensures commits match explicit file selection in Changes panel and keeps git status updates deterministic.
diff --git a/anycode-backend/src/app_state.rs b/anycode-backend/src/app_state.rs
@@ -1,17 +1,20 @@
-use crate::acp::AcpManager;
+use crate::acp::{AcpManager, AcpPermissionMode};
+use crate::acp_fs;
 use crate::code::Code;
 use crate::config::Config;
 use crate::git::GitManager;
 use crate::lsp::LspManager;
 use crate::terminal::Terminal;
 use anyhow::{Result, anyhow};
+use lsp_types::PublishDiagnosticsParams;
 use socketioxide::extract::{SocketRef, State};
 use std::collections::HashSet;
 use std::collections::hash_map::{Entry, HashMap};
 use std::{collections::VecDeque, sync::Arc};
-use tokio::sync::Mutex;
+use tokio::sync::{Mutex, mpsc};
 use tokio_util::sync::CancellationToken;
 
+
 #[derive(Clone)]
 pub struct AppState {
     pub config: Arc<Config>,
@@ -39,6 +42,30 @@ pub struct TerminalData {
 }
 
 impl AppState {
+    pub fn new(
+        diagnostic_tx: mpsc::Sender<PublishDiagnosticsParams>,
+        acp_fs_tx: mpsc::Sender<acp_fs::AcpFsCommand>,
+    ) -> Self {
+        let config = crate::config::get();
+        let acp_permission_mode = AcpPermissionMode::from_env();
+
+        let mut lsp_manager = LspManager::new(config.clone());
+        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());
+
+        Self {
+            config: Arc::new(config),
+            file2code: Arc::new(Mutex::new(HashMap::new())),
+            lsp_manager: Arc::new(Mutex::new(lsp_manager)),
+            acp_manager: Arc::new(Mutex::new(acp_manager)),
+            git_manager: Arc::new(Mutex::new(git_manager)),
+            socket2data: Arc::new(Mutex::new(HashMap::new())),
+            terminals: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
+
     pub async fn shutdown(&self) {
         self.lsp_manager.lock().await.stop_all().await;
         self.acp_manager.lock().await.stop_all().await;
diff --git a/anycode-backend/src/background_tasks.rs b/anycode-backend/src/background_tasks.rs
@@ -0,0 +1,113 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use anyhow::Result;
+use lsp_types::PublishDiagnosticsParams;
+use notify::{Event, RecursiveMode, Watcher, recommended_watcher};
+use socketioxide::SocketIo;
+use tokio::sync::mpsc::Receiver;
+use tokio::sync::{Mutex, mpsc};
+
+use crate::acp_fs;
+use crate::app_state::AppState;
+use crate::handlers::watch_handler::handle_watch_event;
+
+/// Spawns all background tasks: ACP filesystem loop, LSP diagnostics forwarding,
+/// and file system watcher.
+///
+/// The returned `notify::RecommendedWatcher` must be kept alive for the duration
+/// of the program — dropping it stops file watching.
+pub fn spawn_all(
+    state: &AppState,
+    io: &Arc<SocketIo>,
+    diagnostics_rx: Receiver<PublishDiagnosticsParams>,
+    acp_fs_rx: Receiver<acp_fs::AcpFsCommand>,
+) -> Result<notify::RecommendedWatcher> {
+    spawn_acp_fs(state, io, acp_fs_rx);
+    spawn_diagnostics(io, diagnostics_rx);
+    let watcher = spawn_file_watcher(state, io)?;
+    Ok(watcher)
+}
+
+fn spawn_acp_fs(
+    state: &AppState,
+    io: &Arc<SocketIo>,
+    acp_fs_rx: Receiver<acp_fs::AcpFsCommand>,
+) {
+    let file2code = state.file2code.clone();
+    let lsp_manager = state.lsp_manager.clone();
+    let config = state.config.as_ref().clone();
+    let io = io.clone();
+
+    tokio::spawn(acp_fs::run_acp_fs_loop(
+        acp_fs_rx,
+        file2code,
+        lsp_manager,
+        config,
+        io,
+    ));
+}
+
+fn spawn_diagnostics(
+    io: &Arc<SocketIo>,
+    mut diagnostics_rx: Receiver<PublishDiagnosticsParams>,
+) {
+    let socket = io.clone();
+    tokio::spawn(async move {
+        while let Some(diagnostic_message) = diagnostics_rx.recv().await {
+            let send_result = socket.emit("lsp:diagnostics", &diagnostic_message).await;
+            if let Err(e) = send_result {
+                tracing::error!("error while sending lsp:diagnostics {}", e);
+            }
+        }
+    });
+}
+
+fn spawn_file_watcher(
+    state: &AppState,
+    io: &Arc<SocketIo>,
+) -> Result<notify::RecommendedWatcher> {
+    let file2code = state.file2code.clone();
+    let socket2data = state.socket2data.clone();
+    let git_manager = state.git_manager.clone();
+    let lsp_manager = state.lsp_manager.clone();
+
+    let (watch_tx, mut watch_rx) = mpsc::channel::<notify::Result<Event>>(32);
+    let mut watcher = recommended_watcher(move |res| {
+        let _ = watch_tx.blocking_send(res);
+    })?;
+
+    let dir = std::path::Path::new(".");
+    watcher.watch(dir, RecursiveMode::Recursive)?;
+
+    let file_states = Arc::new(Mutex::new(HashMap::new()));
+    let socket = io.clone();
+    tokio::spawn(async move {
+        while let Some(res) = watch_rx.recv().await {
+            match res {
+                Ok(event) => {
+                    for path in &event.paths {
+                        if crate::utils::is_ignored_path(path) {
+                            continue;
+                        } else {
+                            handle_watch_event(
+                                path,
+                                &event,
+                                &socket,
+                                &file2code,
+                                &socket2data,
+                                &file_states,
+                                &git_manager,
+                                &lsp_manager,
+                            )
+                            .await
+                        }
+                    }
+                }
+                Err(e) => eprintln!("watch error: {:?}", e),
+            }
+        }
+    });
+
+    Ok(watcher)
+}
diff --git a/anycode-backend/src/git.rs b/anycode-backend/src/git.rs
@@ -386,6 +386,16 @@ impl GitManager {
     pub fn commit(&self, files: &[String], 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 {
@@ -409,19 +419,10 @@ impl GitManager {
         let tree_id = index.write_tree()?;
         let tree = repo.find_tree(tree_id)?;
 
-        let sig = repo
-            .signature()
-            .or_else(|_| git2::Signature::now("Anycode User", "user@anycode.dev"))?;
-
-        let parents: Vec<git2::Commit> = repo
-            .head()
-            .ok()
-            .and_then(|h| h.peel_to_commit().ok())
-            .map(|c| vec![c])
-            .unwrap_or_default();
-
+        let parents: Vec<git2::Commit> = head_commit.map(|c| vec![c]).unwrap_or_default();
         let parents_refs: Vec<&git2::Commit> = parents.iter().collect();
 
+        let sig = repo.signature()?;
         repo.commit(Some("HEAD"), &sig, &sig, message, &tree, &parents_refs)
             .context("Failed to commit")?;
 
diff --git a/anycode-backend/src/handlers/connection_handler.rs b/anycode-backend/src/handlers/connection_handler.rs
@@ -0,0 +1,141 @@
+use std::collections::HashSet;
+
+use socketioxide::extract::{SocketRef, State};
+use tracing::{error, info};
+
+use crate::app_state::{AppState, is_language_opened};
+use crate::handlers::{
+    acp_handler::*,
+    git_handler::*,
+    io_handler::*,
+    lsp_handler::*,
+    search_handler::*,
+    terminal_handler::*,
+    theme_handler::*,
+};
+
+pub async fn handle_connect(socket: SocketRef, _state: State<AppState>) {
+    info!("Socket.IO connected: {:?} {:?}", socket.ns(), socket.id);
+
+    socket.on("file:open", handle_file_open);
+    socket.on("dir:list", handle_dir_list);
+    socket.on("file:change", handle_file_change);
+    socket.on("file:save", handle_file_save);
+    socket.on("file:create", handle_create);
+    socket.on("file:close", handle_file_close);
+
+    socket.on("lsp:completion", handle_completion);
+    socket.on("lsp:definition", handle_definition);
+    socket.on("lsp:references", handle_references);
+    socket.on("lsp:hover", handle_hover);
+
+    socket.on("search:start", handle_search);
+    socket.on("search:cancel", handle_search_cancel);
+
+    socket.on("terminal:start", handle_terminal_start);
+    socket.on("terminal:input", handle_terminal_input);
+    socket.on("terminal:resize", handle_terminal_resize);
+    socket.on("terminal:close", handle_terminal_close);
+    socket.on("terminal:reconnect", handle_terminal_reconnect);
+
+    socket.on("acp:start", handle_acp_start);
+    socket.on("acp:prompt", handle_acp_prompt);
+    socket.on("acp:stop", handle_acp_stop);
+    socket.on("acp:cancel", handle_acp_cancel);
+    socket.on("acp:set_model", handle_acp_set_model);
+    socket.on("acp:set_reasoning", handle_acp_set_reasoning);
+    socket.on("acp:list", handle_acp_list);
+    socket.on("acp:sessions_list", handle_acp_sessions_list);
+    socket.on("acp:reconnect", handle_acp_reconnect);
+    socket.on("acp:permission_response", handle_acp_permission_response);
+    socket.on("acp:undo", handle_acp_undo);
+
+    socket.on("git:status", handle_git_status);
+    socket.on("git:file-original", handle_git_file_original);
+    socket.on("git:commit", handle_git_commit);
+    socket.on("git:push", handle_git_push);
+    socket.on("git:pull", handle_git_pull);
+    socket.on("git:branches", handle_git_branches);
+    socket.on("git:checkout", handle_git_checkout);
+    socket.on("git:revert", handle_git_revert);
+
+    socket.on("theme:list", handle_theme_list);
+    socket.on("theme:get", handle_theme_get);
+    socket.on_disconnect(handle_disconnect)
+}
+
+pub async fn handle_disconnect(socket: SocketRef, state: State<AppState>) {
+    info!("Socket.IO disconnected: {}", socket.id);
+
+    let sid = socket.id.as_str().to_string();
+
+    // Get opened files for this socket before removing socket data
+    let opened_files = {
+        let sockets_data = state.socket2data.lock().await;
+        match sockets_data.get(&sid) {
+            Some(socket_data) => socket_data.opened_files.clone(),
+            None => return,
+        }
+    };
+
+    // Get languages for files opened by this socket
+    let languages = {
+        let f2c = state.file2code.lock().await;
+        opened_files
+            .iter()
+            .filter_map(|path| f2c.get(path).map(|code| code.lang.clone()))
+            .collect::<HashSet<_>>()
+    };
+
+    // Remove socket data immediately
+    {
+        let mut sockets_data = state.socket2data.lock().await;
+        sockets_data.remove(&sid);
+    }
+
+    // Spawn a delayed task to clean up files and LSP servers (5-second grace period)
+    tokio::spawn(async move {
+        tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
+
+        // Get all opened files from remaining active sockets
+        let all_opened_files: HashSet<String> = {
+            let sockets_data = state.socket2data.lock().await;
+            sockets_data
+                .values()
+                .flat_map(|data| data.opened_files.iter())
+                .cloned()
+                .collect()
+        };
+
+        // Clean up files that are no longer opened by any socket
+        let files_to_close: Vec<(String, String)> = {
+            let f2c = state.file2code.lock().await;
+            opened_files
+                .iter()
+                .filter(|path| !all_opened_files.contains(*path))
+                .filter_map(|path| f2c.get(path).map(|code| (path.clone(), code.lang.clone())))
+                .collect()
+        };
+
+        // Close files (notify LSP didClose)
+        if !files_to_close.is_empty() {
+            let mut lsp_manager = state.lsp_manager.lock().await;
+            for (file_path, lang) in &files_to_close {
+                if let Some(lsp) = lsp_manager.get(lang).await {
+                    if let Err(e) = lsp.did_close(file_path) {
+                        error!("Failed to notify LSP didClose for {}: {:?}", file_path, e);
+                    }
+                }
+            }
+        }
+
+        // Stop LSP servers for languages that have no files opened by other active sockets
+        for lang in languages {
+            if !is_language_opened(&lang, &state).await {
+                info!("Lsp autoclose after grace period: '{}'", lang);
+                let mut lsp_manager = state.lsp_manager.lock().await;
+                lsp_manager.stop(&lang).await;
+            }
+        }
+    });
+}
diff --git a/anycode-backend/src/handlers/mod.rs b/anycode-backend/src/handlers/mod.rs
@@ -1,8 +1,10 @@
 pub mod acp_handler;
+pub mod connection_handler;
 pub mod git_handler;
 pub mod io_handler;
 pub mod lsp_handler;
 pub mod search_handler;
+pub mod theme_handler;
 pub mod terminal_handler;
+pub mod static_handler;
 pub mod watch_handler;
-pub mod theme_handler;
diff --git a/anycode-backend/src/handlers/static_handler.rs b/anycode-backend/src/handlers/static_handler.rs
diff --git a/anycode-backend/src/main.rs b/anycode-backend/src/main.rs
