fix code Args

Author: kennvene-aws

crates/chat-cli/src/cli/chat/tools/code.rs

@@ -37,7 +37,6 @@ pub struct SearchSymbolsParams {
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct FindReferencesParams {
-    pub symbol_name: String,
     pub file_path: String,
     pub row: i32,
     pub column: i32,
@@ -284,11 +283,11 @@ impl Code {
                             if references.is_empty() {
                                 queue!(
                                     _stdout,
-                                    style::Print("\n🔗 No references found for \""),
+                                    style::Print("\n🔗 No references found at "),
                                     StyledText::warning_fg(),
-                                    style::Print(&params.symbol_name),
+                                    style::Print(&format!("{}:{}:{}", params.file_path, params.row, params.column)),
                                     StyledText::reset(),
-                                    style::Print("\"\n"),
+                                    style::Print("\n"),
                                 )?;
                             } else {
                                 queue!(
@@ -297,11 +296,11 @@ impl Code {
                                     StyledText::success_fg(),
                                     style::Print(&references.len().to_string()),
                                     StyledText::reset(),
-                                    style::Print(" reference(s) to \""),
+                                    style::Print(" reference(s) at "),
                                     StyledText::success_fg(),
-                                    style::Print(&params.symbol_name),
+                                    style::Print(&format!("{}:{}:{}", params.file_path, params.row, params.column)),
                                     StyledText::reset(),
-                                    style::Print("\":\n"),
+                                    style::Print(":\n"),
                                 )?;
                                 for (i, reference) in references.iter().enumerate() {
                                     queue!(
@@ -500,11 +499,7 @@ impl Code {
             Code::FindReferences(params) => {
                 queue!(
                     output,
-                    style::Print("🔗 Finding references for "),
-                    StyledText::success_fg(),
-                    style::Print(&format!("\"{}\"", params.symbol_name)),
-                    StyledText::reset(),
-                    style::Print(" at "),
+                    style::Print("🔗 Finding references at "),
                     StyledText::info_fg(),
                     style::Print(&format!("{}:{}:{}", params.file_path, params.row, params.column)),
                     StyledText::reset(),

crates/chat-cli/src/cli/chat/tools/tool_index.json

@@ -458,8 +458,7 @@
             "find_references", 
             "goto_definition",
             "rename_symbol",
-            "format_code",
-            "workspace_outline",
+            "format",
             "get_document_symbols",
             "lookup_symbols",
             "initialize_workspace"
@@ -468,7 +467,7 @@
         },
         "symbol_name": {
           "type": "string",
-          "description": "Name of symbol to search for (required for search_symbols and find_references operations)"
+          "description": "Name of symbol to search for (required for search_symbols operation)"
         },
         "file_path": {
           "type": "string", 

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

@@ -6,6 +6,7 @@ use code_agent_sdk::{
 };
 use code_agent_sdk::model::types::ApiSymbolKind;
 use std::path::PathBuf;
+use std::str::FromStr;
 
 #[derive(Parser)]
 #[command(name = "code-agent-cli")]
@@ -111,7 +112,7 @@ async fn main() -> anyhow::Result<()> {
             let request = FindSymbolsRequest {
                 symbol_name: name,
                 file_path: file,
-                symbol_type: symbol_type.and_then(|s| ApiSymbolKind::from_str(&s)),
+                symbol_type: symbol_type.and_then(|s| ApiSymbolKind::from_str(&s).ok()),
                 limit: None,        // Use default 20
                 exact_match: false, // Enable fuzzy matching
             };
@@ -288,12 +289,14 @@ async fn main() -> anyhow::Result<()> {
                 insert_spaces,
             };
 
-            let has_changes = code_intel.format_code(request).await?;
+            let edit_count = code_intel.format_code(request).await?;
 
-            if !has_changes {
+            if edit_count == 0 {
                 println!("No formatting changes needed");
             } else {
-                println!("✅ File formatted successfully");
+                // Count unique lines affected by calculating from edit count
+                println!("Applied formatting to {} lines", edit_count);
+                println!("✅ Formatting applied successfully");
             }
         }
 

crates/code-agent-sdk/src/mcp/server.rs

@@ -865,8 +865,8 @@ impl CodeIntelligenceServer {
             )
         })?;
 
-        let message = if edits {
-            "Code formatted successfully".to_string()
+        let message = if edits > 0 {
+            format!("Code formatted successfully ({} edits applied)", edits)
         } else {
             "No formatting changes needed".to_string()
         };

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

@@ -492,12 +492,10 @@ impl CodeIntelligence {
     pub async fn format_code(
         &mut self,
         request: FormatCodeRequest,
-    ) -> Result<bool> {
-        let edits = self.coding_service
+    ) -> Result<usize> {
+        self.coding_service
             .format_code(&mut self.workspace_manager, request)
-            .await?;
-            
-        Ok(!edits.is_empty())
+            .await
     }
 
     // File operations - delegate to WorkspaceService

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

@@ -22,7 +22,7 @@ pub trait CodingService: Send + Sync {
         &self,
         workspace_manager: &mut WorkspaceManager,
         request: FormatCodeRequest,
-    ) -> Result<Vec<TextEdit>>;
+    ) -> Result<usize>;
 }
 
 /// LSP-based implementation of CodingService
@@ -79,29 +79,35 @@ impl CodingService for LspCodingService {
         let params = RenameParams {
             text_document_position: TextDocumentPositionParams {
                 text_document: TextDocumentIdentifier { uri },
-                position: crate::utils::to_lsp_position(request.row, request.column),
+                position: Position {
+                    line: request.row,
+                    character: request.column,
+                },
             },
             new_name: request.new_name.clone(),
             work_done_progress_params: Default::default(),
         };
 
-        let workspace_edit = client.rename(params).await?;
+        let result = client.rename(params).await;
 
-        // Apply workspace edit using LSP batch operations if not dry-run
-        if let Some(ref edit) = workspace_edit {
-            if !request.dry_run {
-                client.apply_workspace_edit(edit).await?;
+        // Apply edits if not dry_run
+        if !request.dry_run {
+            if let Ok(Some(ref workspace_edit)) = result {
+                use crate::utils::apply_workspace_edit;
+                if let Err(e) = apply_workspace_edit(workspace_edit) {
+                    tracing::trace!("Failed to apply workspace edit: {}", e);
+                }
             }
         }
 
-        Ok(workspace_edit)
+        result
     }
 
     async fn format_code(
         &self,
         workspace_manager: &mut WorkspaceManager,
         request: FormatCodeRequest,
-    ) -> Result<Vec<TextEdit>> {
+    ) -> Result<usize> {
         // Ensure initialized
         if !workspace_manager.is_initialized() {
             workspace_manager.initialize().await?;
@@ -125,12 +131,12 @@ impl CodingService for LspCodingService {
                     )
                 })?;
 
-            let uri = Url::from_file_path(&canonical_path).map_err(|_| {
-                anyhow::anyhow!("Invalid file path: {}", canonical_path.display())
-            })?;
-
             let params = DocumentFormattingParams {
-                text_document: TextDocumentIdentifier { uri: uri.clone() },
+                text_document: TextDocumentIdentifier {
+                    uri: Url::from_file_path(&canonical_path).map_err(|_| {
+                        anyhow::anyhow!("Invalid file path: {}", canonical_path.display())
+                    })?,
+                },
                 options: FormattingOptions {
                     tab_size: request.tab_size,
                     insert_spaces: request.insert_spaces,
@@ -147,25 +153,18 @@ impl CodingService for LspCodingService {
                 .await?
                 .unwrap_or_default();
 
-            // Apply formatting edits using LSP batch operations
+            let edit_count = edits.len();
+
+            // Apply formatting edits to the actual file
             if !edits.is_empty() {
-                let mut changes = std::collections::HashMap::new();
-                changes.insert(uri, edits.clone());
-                
-                let workspace_edit = WorkspaceEdit {
-                    changes: Some(changes),
-                    document_changes: None,
-                    change_annotations: None,
-                };
-
-                client.apply_workspace_edit(&workspace_edit).await?;
+                use crate::utils::apply_text_edits;
+                apply_text_edits(&canonical_path, &edits)?;
             }
 
-            Ok(edits)
+            Ok(edit_count)
         } else {
             // Format workspace - not commonly supported by LSPs
-            // Return empty edits for now
-            Ok(Vec::new())
+            Ok(0)
         }
     }
 }

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

@@ -78,6 +78,7 @@ pub fn apply_workspace_edit(workspace_edit: &WorkspaceEdit) -> Result<()> {
     let mut applied_files = Vec::new();
     let mut failed_files = Vec::new();
 
+    // Handle changes field
     if let Some(changes) = &workspace_edit.changes {
         for (uri, edits) in changes {
             let file_path = Path::new(uri.path());
@@ -104,6 +105,46 @@ pub fn apply_workspace_edit(workspace_edit: &WorkspaceEdit) -> Result<()> {
             }
         }
     }
+    
+    // Handle document_changes field
+    if let Some(document_changes) = &workspace_edit.document_changes {
+        match document_changes {
+            lsp_types::DocumentChanges::Edits(edits) => {
+                for edit in edits {
+                    let file_path = Path::new(edit.text_document.uri.path());
+                    
+                    // Validate file exists and is writable
+                    if !file_path.exists() {
+                        failed_files.push((file_path.to_path_buf(), "File does not exist".to_string()));
+                        continue;
+                    }
+
+                    if file_path.metadata()?.permissions().readonly() {
+                        failed_files.push((file_path.to_path_buf(), "File is read-only".to_string()));
+                        continue;
+                    }
+
+                    let text_edits: Vec<TextEdit> = edit.edits.iter().map(|e| match e {
+                        lsp_types::OneOf::Left(text_edit) => text_edit.clone(),
+                        lsp_types::OneOf::Right(annotated_edit) => annotated_edit.text_edit.clone(),
+                    }).collect();
+                    
+                    match apply_text_edits(file_path, &text_edits) {
+                        Ok(()) => {
+                            applied_files.push(file_path.to_path_buf());
+                        }
+                        Err(e) => {
+                            failed_files.push((file_path.to_path_buf(), e.to_string()));
+                        }
+                    }
+                }
+            }
+            lsp_types::DocumentChanges::Operations(_) => {
+                // Resource operations not yet supported - log as trace
+                tracing::trace!("Resource operations not yet supported in workspace edit");
+            }
+        }
+    }
 
     // Report results
     if !failed_files.is_empty() {