Rename works...Again

Author: kennvene-aws

crates/code-agent-sdk/src/cli/cli.rs

@@ -2,9 +2,10 @@ use clap::{Parser, Subcommand};
 use code_agent_sdk::{
     CodeIntelligence, FindReferencesByLocationRequest, FindReferencesByNameRequest,
     FindSymbolsRequest, GetDocumentSymbolsRequest, GotoDefinitionRequest,
-    RenameSymbolRequest, FormatCodeRequest,
+    RenameSymbolRequest, FormatCodeRequest, OpenFileRequest,
 };
 use code_agent_sdk::model::types::ApiSymbolKind;
+use code_agent_sdk::utils::logging;
 use std::path::PathBuf;
 use std::str::FromStr;
 
@@ -92,6 +93,13 @@ enum Commands {
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
+    // Initialize file logging for debugging
+    if let Err(e) = logging::init_file_logging() {
+        eprintln!("Warning: Failed to initialize logging: {}", e);
+    } else {
+        println!("📝 Logging enabled to code_intelligence.log");
+    }
+
     let cli = Cli::parse();
 
     // Auto-detect workspace and initialize
@@ -245,6 +253,17 @@ async fn main() -> anyhow::Result<()> {
             new_name,
             dry_run,
         } => {
+            // Open the file first to ensure LSP server processes it
+            let content = std::fs::read_to_string(&file)?;
+            code_intel.open_file(OpenFileRequest {
+                file_path: file.clone(),
+                content,
+            }).await?;
+            
+            // Wait for LSP server to process the file
+            println!("⏳ Waiting for LSP server to process file...");
+            tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
+            
             let request = RenameSymbolRequest {
                 file_path: file.clone(),
                 row,

crates/code-agent-sdk/src/lsp/client.rs

@@ -155,7 +155,10 @@ impl LspClient {
     /// # Returns
     /// * `Result<Option<WorkspaceEdit>>` - Workspace changes or None
     pub async fn rename(&self, params: RenameParams) -> Result<Option<WorkspaceEdit>> {
-        self.send_lsp_request("textDocument/rename", params).await
+        tracing::trace!("LSP rename request: method=textDocument/rename, params={:?}", params);
+        let result = self.send_lsp_request("textDocument/rename", params).await;
+        tracing::trace!("LSP rename response: {:?}", result);
+        result
     }
 
     /// Format a document
@@ -197,18 +200,27 @@ impl LspClient {
         T: serde::Serialize,
         R: serde::de::DeserializeOwned,
     {
+        tracing::trace!("Sending LSP request: method={}, params={:?}", method, serde_json::to_value(&params)?);
+        
         let (tx, rx) = oneshot::channel();
 
         self.send_request(method, json!(params), move |result| {
+            tracing::trace!("LSP request callback received result: {:?}", result);
             let _ = tx.send(result);
         })
         .await?;
 
+        tracing::trace!("Waiting for LSP response...");
         let result = rx.await??;
+        tracing::trace!("Raw LSP response: {:?}", result);
+        
         if result.is_null() {
+            tracing::trace!("LSP response is null, returning None");
             Ok(None)
         } else {
-            Ok(Some(serde_json::from_value(result)?))
+            let parsed: R = serde_json::from_value(result)?;
+            tracing::trace!("Successfully parsed LSP response");
+            Ok(Some(parsed))
         }
     }
 

crates/code-agent-sdk/src/model/entities.rs

@@ -27,10 +27,29 @@ pub struct RenameResult {
 impl RenameResult {
     /// Create from LSP WorkspaceEdit
     pub fn from_lsp_workspace_edit(edit: &lsp_types::WorkspaceEdit) -> Self {
-        let file_count = edit.changes.as_ref().map(|c| c.len()).unwrap_or(0);
-        let edit_count = edit.changes.as_ref()
-            .map(|changes| changes.values().map(|edits| edits.len()).sum())
-            .unwrap_or(0);
+        let mut file_count = 0;
+        let mut edit_count = 0;
+        
+        // Handle changes field
+        if let Some(changes) = &edit.changes {
+            file_count += changes.len();
+            edit_count += changes.values().map(|edits| edits.len()).sum::<usize>();
+        }
+        
+        // Handle document_changes field
+        if let Some(document_changes) = &edit.document_changes {
+            match document_changes {
+                lsp_types::DocumentChanges::Edits(edits) => {
+                    file_count += edits.len();
+                    edit_count += edits.iter().map(|edit| edit.edits.len()).sum::<usize>();
+                }
+                lsp_types::DocumentChanges::Operations(_) => {
+                    // Operations like create/rename/delete files
+                    file_count += 1;
+                    edit_count += 1;
+                }
+            }
+        }
 
         Self { file_count, edit_count }
     }

crates/code-agent-sdk/src/sdk/services/coding_service.rs

@@ -57,47 +57,60 @@ impl CodingService for LspCodingService {
         workspace_manager: &mut WorkspaceManager,
         request: RenameSymbolRequest,
     ) -> Result<Option<WorkspaceEdit>> {
+        tracing::trace!("Starting rename_symbol: file={:?}, row={}, col={}, new_name={}", 
+            request.file_path, request.row, request.column, request.new_name);
+
         // Ensure initialized
         if !workspace_manager.is_initialized() {
+            tracing::trace!("Workspace not initialized, initializing...");
             workspace_manager.initialize().await?;
         }
 
         let canonical_path = canonicalize_path(&request.file_path)?;
+        tracing::trace!("Canonical path: {:?}", canonical_path);
+        
         let content = std::fs::read_to_string(&canonical_path)?;
+        tracing::trace!("File content length: {} bytes", content.len());
+        
         self.workspace_service
             .open_file(workspace_manager, &canonical_path, content)
             .await?;
+        tracing::trace!("File opened in workspace");
 
         let client = workspace_manager
             .get_client_for_file(&canonical_path)
             .await?
             .ok_or_else(|| anyhow::anyhow!("No language server for file"))?;
+        tracing::trace!("Got LSP client for file");
 
         let uri = Url::from_file_path(&canonical_path)
             .map_err(|_| anyhow::anyhow!("Invalid file path"))?;
+        tracing::trace!("File URI: {}", uri);
 
         let params = RenameParams {
             text_document_position: TextDocumentPositionParams {
-                text_document: TextDocumentIdentifier { uri },
-                position: Position {
-                    line: request.row,
-                    character: request.column,
-                },
+                text_document: TextDocumentIdentifier { uri: uri.clone() },
+                position: crate::utils::position::to_lsp_position(request.row, request.column),
             },
             new_name: request.new_name.clone(),
             work_done_progress_params: Default::default(),
         };
+        tracing::trace!("Sending rename request to LSP: {:?}", params);
 
         let result = client.rename(params).await;
+        tracing::trace!("LSP rename result: {:?}", result);
 
         // Apply edits if not dry_run
         if !request.dry_run {
             if let Ok(Some(ref workspace_edit)) = result {
+                tracing::trace!("Applying workspace edit (not dry-run)");
                 use crate::utils::apply_workspace_edit;
                 if let Err(e) = apply_workspace_edit(workspace_edit) {
                     tracing::trace!("Failed to apply workspace edit: {}", e);
                 }
             }
+        } else {
+            tracing::trace!("Dry-run mode, not applying edits");
         }
 
         result

crates/code-agent-sdk/src/utils/logging.rs

@@ -0,0 +1,24 @@
+use std::fs::OpenOptions;
+use tracing_subscriber::{fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
+
+/// Initialize logging to file with trace level for LSP operations
+pub fn init_file_logging() -> anyhow::Result<()> {
+    let log_file = OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open("code_intelligence.log")?;
+
+    tracing_subscriber::registry()
+        .with(
+            fmt::layer()
+                .with_writer(log_file)
+                .with_ansi(false)
+                .with_target(true)
+                .with_thread_ids(true)
+        )
+        .with(EnvFilter::from_default_env().add_directive("code_agent_sdk=trace".parse()?))
+        .try_init()
+        .map_err(|e| anyhow::anyhow!("Failed to initialize logging: {}", e))?;
+
+    Ok(())
+}

crates/code-agent-sdk/src/utils/mod.rs

@@ -6,6 +6,7 @@
 pub mod file;
 pub mod fuzzy_search;
 pub mod position;
+pub mod logging;
 
 // Re-export commonly used functions for convenience
 pub use file::{apply_text_edits, apply_workspace_edit, canonicalize_path, ensure_absolute_path};