Normalize path handling

Author: vipmax

anycode-backend/src/acp.rs

@@ -1,6 +1,5 @@
 use crate::acp_fs::AcpFsCommand;
 use crate::acp_history::AcpHistoryManager;
-use crate::utils::relative_to_current_dir;
 use agent_client_protocol::{self as acp, Agent as _, Client};
 use agent_client_protocol_schema::{ProtocolVersion, SessionId};
 use anyhow::{Context, Result, anyhow};
@@ -310,13 +309,11 @@ impl Client for AcpClientImpl {
             serde_json::json!({})
         };
 
-        // Extract locations from tool call update (use relative path if possible)
+        // Keep ACP locations absolute to match the protocol and avoid path identity mismatches.
         let locations = tool_call_update.fields.locations.as_ref().map(|locs| {
             locs.iter()
                 .map(|loc| AcpLocation {
-                    path: relative_to_current_dir(&loc.path)
-                        .map(|p| p.to_string_lossy().to_string())
-                        .unwrap_or_else(|| loc.path.to_string_lossy().to_string()),
+                    path: loc.path.to_string_lossy().to_string(),
                     line: loc.line,
                 })
                 .collect()
@@ -462,7 +459,10 @@ impl Client for AcpClientImpl {
                 Err(acp::Error::internal_error())
             }
             Err(_) => {
-                error!("ACP fs response channel dropped for agent {}", self.agent_id);
+                error!(
+                    "ACP fs response channel dropped for agent {}",
+                    self.agent_id
+                );
                 Err(acp::Error::internal_error())
             }
         }
@@ -515,7 +515,10 @@ impl Client for AcpClientImpl {
                 Err(acp::Error::internal_error())
             }
             Err(_) => {
-                error!("ACP fs response channel dropped for agent {}", self.agent_id);
+                error!(
+                    "ACP fs response channel dropped for agent {}",
+                    self.agent_id
+                );
                 Err(acp::Error::internal_error())
             }
         }
@@ -782,12 +785,13 @@ impl AcpClientImpl {
         if let Some(raw_input) = tool_call.raw_input.as_ref() {
             if let Some(cmd) = raw_input.get("cmd").and_then(|value| value.as_str()) {
                 tool_command = Some(cmd.to_string());
-            } else if let Some(command) = raw_input.get("command").and_then(|value| value.as_str()) {
+            } else if let Some(command) = raw_input.get("command").and_then(|value| value.as_str())
+            {
                 tool_command = Some(command.to_string());
             }
         }
 
-        // Extract locations from tool call (use relative path if possible)
+        // Keep ACP locations absolute to match the protocol and avoid path identity mismatches.
         let locations = if tool_call.locations.is_empty() {
             None
         } else {
@@ -796,9 +800,7 @@ impl AcpClientImpl {
                     .locations
                     .iter()
                     .map(|loc| AcpLocation {
-                        path: relative_to_current_dir(&loc.path)
-                            .map(|p| p.to_string_lossy().to_string())
-                            .unwrap_or_else(|| loc.path.to_string_lossy().to_string()),
+                        path: loc.path.to_string_lossy().to_string(),
                         line: loc.line,
                     })
                     .collect(),
@@ -1148,7 +1150,12 @@ pub struct AcpAgent {
 }
 
 impl AcpAgent {
-    pub fn new(agent_id: String, agent_name: String, permission_mode: Arc<AtomicU8>, fs_sender: mpsc::Sender<AcpFsCommand>) -> Self {
+    pub fn new(
+        agent_id: String,
+        agent_name: String,
+        permission_mode: Arc<AtomicU8>,
+        fs_sender: mpsc::Sender<AcpFsCommand>,
+    ) -> Self {
         // Initialize history manager with current working directory and agent ID
         let project_root = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
         let mut history_manager = AcpHistoryManager::new(&project_root, &agent_id);
@@ -1343,18 +1350,18 @@ impl AcpAgent {
         Self::spawn_stderr_reader(stderr, message_sender.clone(), history_for_stderr);
 
         // Initialize connection and create session
-        let bootstrap =
-            match Self::initialize_connection(&conn, &agent_id, resume_session_id).await {
-                Ok(bootstrap) => {
-                    let _ = session_tx.send(bootstrap.session_id.clone()).await;
-                    ready.store(true, Ordering::SeqCst);
-                    Some(bootstrap)
-                }
-                Err(e) => {
-                    error!("Failed to initialize ACP agent {}: {}", agent_id, e);
-                    None
-                }
-            };
+        let bootstrap = match Self::initialize_connection(&conn, &agent_id, resume_session_id).await
+        {
+            Ok(bootstrap) => {
+                let _ = session_tx.send(bootstrap.session_id.clone()).await;
+                ready.store(true, Ordering::SeqCst);
+                Some(bootstrap)
+            }
+            Err(e) => {
+                error!("Failed to initialize ACP agent {}: {}", agent_id, e);
+                None
+            }
+        };
 
         // Handle prompts in a loop
         if let Some(bootstrap) = bootstrap {
@@ -1463,7 +1470,10 @@ impl AcpAgent {
         let cwd = std::env::current_dir().unwrap_or_else(|_| std::path::PathBuf::from("."));
         let bootstrap = Self::create_or_resume_session(conn, resume_session_id, cwd).await?;
 
-        info!("Session ready for agent {}: {}", agent_id, bootstrap.session_id);
+        info!(
+            "Session ready for agent {}: {}",
+            agent_id, bootstrap.session_id
+        );
         Ok(bootstrap)
     }
 
@@ -1481,9 +1491,7 @@ impl AcpAgent {
                 } => {
                     error!(
                         "Failed to restore ACP session {}. load_session error: {}. resume_session error: {}. Falling back to creating a new session.",
-                        resume_session_id,
-                        load_err,
-                        resume_err
+                        resume_session_id, load_err, resume_err
                     );
                 }
             }
@@ -1671,7 +1679,9 @@ impl AcpAgent {
 
         Ok(SessionConfigSelectors {
             model_selector: Self::parse_model_selector(Some(response.config_options.as_slice())),
-            reasoning_selector: Self::parse_reasoning_selector(Some(response.config_options.as_slice())),
+            reasoning_selector: Self::parse_reasoning_selector(Some(
+                response.config_options.as_slice(),
+            )),
         })
     }
 
@@ -2053,10 +2063,7 @@ impl AcpAgent {
         Ok(())
     }
 
-    pub async fn set_session_config_option(
-        &self,
-        option: AcpSelectOption,
-    ) -> Result<()> {
+    pub async fn set_session_config_option(&self, option: AcpSelectOption) -> Result<()> {
         let config_tx = self
             .config_sender
             .as_ref()

anycode-backend/src/acp_fs.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 use anyhow::{Context, Result};
 use serde_json::json;
 use socketioxide::SocketIo;
-use tokio::sync::{mpsc, oneshot, Mutex};
+use tokio::sync::{Mutex, mpsc, oneshot};
 use tracing::{error, info};
 
 use crate::code::Code;
@@ -78,11 +78,10 @@ async fn handle_write(
     content: &str,
     file2code: &Arc<Mutex<HashMap<String, Code>>>,
     lsp_manager: &Arc<Mutex<LspManager>>,
-    config: &Config,
+    _config: &Config,
     io: &Arc<SocketIo>,
 ) -> Result<()> {
-    let abs_path = abs_file(&path.to_string_lossy())
-        .context("Failed to resolve absolute path")?;
+    let abs_path = abs_file(&path.to_string_lossy()).context("Failed to resolve absolute path")?;
 
     // Lock file2code and check if file is open
     let mut f2c = file2code.lock().await;
@@ -184,8 +183,7 @@ async fn handle_read(
     path: &PathBuf,
     file2code: &Arc<Mutex<HashMap<String, Code>>>,
 ) -> Result<String> {
-    let abs_path = abs_file(&path.to_string_lossy())
-        .context("Failed to resolve absolute path")?;
+    let abs_path = abs_file(&path.to_string_lossy()).context("Failed to resolve absolute path")?;
 
     // Check if file is open in file2code
     let f2c = file2code.lock().await;

anycode-backend/src/acp_history.rs

@@ -1,7 +1,7 @@
-use anyhow::{anyhow, Context, Result};
-use git2::{build::CheckoutBuilder, IndexAddOption, Repository, ResetType, Signature};
+use anyhow::{Context, Result, anyhow};
+use git2::{IndexAddOption, Repository, ResetType, Signature, build::CheckoutBuilder};
 use std::path::{Path, PathBuf};
-use tracing::{info, warn, debug};
+use tracing::{debug, info, warn};
 
 /// Checkpoint representing a state before a user message
 #[derive(Debug, Clone)]
@@ -93,8 +93,7 @@ impl AcpHistoryManager {
         }
 
         // Create history directory if needed
-        std::fs::create_dir_all(&self.history_dir)
-            .context("Failed to create history directory")?;
+        std::fs::create_dir_all(&self.history_dir).context("Failed to create history directory")?;
 
         self.sync_shadow_gitignore()?;
 
@@ -110,7 +109,10 @@ impl AcpHistoryManager {
                 }
                 Err(e) => {
                     // Repository is corrupted or invalid, reinitialize
-                    warn!("Existing repository invalid ({}), removing and reinitializing", e);
+                    warn!(
+                        "Existing repository invalid ({}), removing and reinitializing",
+                        e
+                    );
                     std::fs::remove_dir_all(&git_dir)
                         .context("Failed to remove corrupted git directory")?;
                     self.initialize_new_repo()?;
@@ -127,11 +129,14 @@ impl AcpHistoryManager {
 
     /// Initialize a new git repository
     fn initialize_new_repo(&self) -> Result<()> {
-        info!("Initializing new history repository at {:?}", self.git_dir());
+        info!(
+            "Initializing new history repository at {:?}",
+            self.git_dir()
+        );
 
         // Initialize repository at git_dir
-        let _repo = Repository::init(&self.git_dir())
-            .context("Failed to initialize git repository")?;
+        let _repo =
+            Repository::init(&self.git_dir()).context("Failed to initialize git repository")?;
 
         // Now set the workdir to the project root
         let repo = self.open_repo()?;
@@ -146,8 +151,7 @@ impl AcpHistoryManager {
 
     /// Open the repository with workdir set to project root
     fn open_repo(&self) -> Result<Repository> {
-        let repo = Repository::open(&self.git_dir())
-            .context("Failed to open git repository")?;
+        let repo = Repository::open(&self.git_dir()).context("Failed to open git repository")?;
 
         // Set workdir to project root
         repo.set_workdir(&self.project_root, false)
@@ -167,7 +171,11 @@ impl AcpHistoryManager {
             IndexAddOption::DEFAULT,
             Some(&mut |path, _matched_spec| {
                 let path_str = path.to_string_lossy();
-                if path_str.starts_with(".anycode/") { 1 } else { 0 }
+                if path_str.starts_with(".anycode/") {
+                    1
+                } else {
+                    0
+                }
             }),
         )?;
         index.write()?;
@@ -213,10 +221,8 @@ impl AcpHistoryManager {
                 checkpoints.push(Checkpoint {
                     commit_hash: oid.to_string(),
                     prompt: prompt.clone(),
-                    created_at: chrono::DateTime::from_timestamp(
-                        commit.time().seconds(),
-                        0
-                    ).unwrap_or_else(chrono::Utc::now),
+                    created_at: chrono::DateTime::from_timestamp(commit.time().seconds(), 0)
+                        .unwrap_or_else(chrono::Utc::now),
                 });
             }
         }
@@ -246,7 +252,11 @@ impl AcpHistoryManager {
             IndexAddOption::DEFAULT,
             Some(&mut |path, _matched_spec| {
                 let path_str = path.to_string_lossy();
-                if path_str.starts_with(".anycode/") { 1 } else { 0 }
+                if path_str.starts_with(".anycode/") {
+                    1
+                } else {
+                    0
+                }
             }),
         )?;
 
@@ -268,14 +278,8 @@ impl AcpHistoryManager {
             let sig = Signature::now("AnyCode", "anycode@local")?;
             let commit_message = format!("checkpoint:{}", prompt);
 
-            let commit_id = repo.commit(
-                Some("HEAD"),
-                &sig,
-                &sig,
-                &commit_message,
-                &tree,
-                &[&head],
-            )?;
+            let commit_id =
+                repo.commit(Some("HEAD"), &sig, &sig, &commit_message, &tree, &[&head])?;
 
             commit_id.to_string()
         };
@@ -303,17 +307,19 @@ impl AcpHistoryManager {
     pub fn restore_to_commit(&self, commit_hash: &str) -> Result<()> {
         let repo = self.open_repo()?;
 
-        let oid = git2::Oid::from_str(commit_hash)
-            .context("Invalid commit hash")?;
-        let commit = repo.find_commit(oid)
-            .context("Commit not found")?;
+        let oid = git2::Oid::from_str(commit_hash).context("Invalid commit hash")?;
+        let commit = repo.find_commit(oid).context("Commit not found")?;
 
         // Hard reset to the target commit
         let mut checkout_opts = CheckoutBuilder::new();
         checkout_opts.force();
 
-        repo.reset(commit.as_object(), ResetType::Hard, Some(&mut checkout_opts))
-            .context("Failed to reset to checkpoint")?;
+        repo.reset(
+            commit.as_object(),
+            ResetType::Hard,
+            Some(&mut checkout_opts),
+        )
+        .context("Failed to reset to checkpoint")?;
 
         info!("Restored project to commit {}", commit_hash);