Fix: Fixes progressive update, TODO: Implement file watcher.

Author: kennvene-aws

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

@@ -36,7 +36,7 @@ enum Commands {
         #[arg(short, long, conflicts_with_all = ["file", "line", "column"])]
         name: Option<String>,
         /// File containing the symbol (for position-based search)
-        #[arg(short, long, requires_all = ["line", "column"])]
+        #[arg(short, long, requires_ifs = [("line", "column"), ("column", "line")])]
         file: Option<PathBuf>,
         /// Row number (1-based)
         #[arg(short, long)]

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

@@ -194,6 +194,24 @@ impl LspClient {
             .await
     }
 
+    /// Notify server about file system changes
+    ///
+    /// # Arguments
+    /// * `params` - File change events
+    pub async fn did_change_watched_files(&self, params: DidChangeWatchedFilesParams) -> Result<()> {
+        self.send_notification("workspace/didChangeWatchedFiles", json!(params))
+            .await
+    }
+
+    /// Notify server about document content changes
+    ///
+    /// # Arguments
+    /// * `params` - Document change parameters
+    pub async fn did_change(&self, params: DidChangeTextDocumentParams) -> Result<()> {
+        self.send_notification("textDocument/didChange", json!(params))
+            .await
+    }
+
     /// Generic LSP request handler with automatic response parsing
     async fn send_lsp_request<T, R>(&self, method: &str, params: T) -> Result<Option<R>>
     where

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

@@ -53,7 +53,7 @@ impl LspConfig {
                     }),
                     diagnostic: Some(DiagnosticClientCapabilities {
                         dynamic_registration: Some(true),
-                        related_document_support: Some(false),
+                        related_document_support: Some(true),
                     }),
                     ..Default::default()
                 }),
@@ -70,6 +70,10 @@ impl LspConfig {
                     diagnostic: Some(DiagnosticWorkspaceClientCapabilities {
                         refresh_support: Some(true),
                     }),
+                    did_change_watched_files: Some(DidChangeWatchedFilesClientCapabilities {
+                        dynamic_registration: Some(true),
+                        relative_pattern_support: Some(true),
+                    }),
                     ..Default::default()
                 }),
                 ..Default::default()

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

@@ -34,6 +34,72 @@ impl LspCodingService {
     pub fn new(workspace_service: Box<dyn WorkspaceService>) -> Self {
         Self { workspace_service }
     }
+
+    /// Send proper LSP notifications for file changes
+    async fn notify_file_changes(
+        &self,
+        workspace_manager: &mut WorkspaceManager,
+        workspace_edit: &WorkspaceEdit,
+    ) -> Result<()> {
+        use lsp_types::{DidChangeTextDocumentParams, VersionedTextDocumentIdentifier, TextDocumentContentChangeEvent};
+        use std::collections::HashSet;
+
+        let mut changed_files = HashSet::new();
+
+        // Collect unique files from changes field
+        if let Some(changes) = &workspace_edit.changes {
+            for uri in changes.keys() {
+                if let Ok(file_path) = uri.to_file_path() {
+                    // Only notify for files that are actually opened in LSP
+                    if workspace_manager.is_file_opened(&file_path) {
+                        changed_files.insert((uri.clone(), file_path));
+                    }
+                }
+            }
+        }
+
+        // Collect unique files from document_changes field
+        if let Some(document_changes) = &workspace_edit.document_changes {
+            if let lsp_types::DocumentChanges::Edits(edits) = document_changes {
+                for edit in edits {
+                    if let Ok(file_path) = edit.text_document.uri.to_file_path() {
+                        // Only notify for files that are actually opened in LSP
+                        if workspace_manager.is_file_opened(&file_path) {
+                            changed_files.insert((edit.text_document.uri.clone(), file_path));
+                        }
+                    }
+                }
+            }
+        }
+
+        // Send didChange with full content for each opened file
+        for (uri, file_path) in changed_files {
+            // Get next version number first
+            let version = workspace_manager.get_next_version(&file_path);
+            
+            if let Ok(Some(client)) = workspace_manager.get_client_for_file(&file_path).await {
+                // Read current file content
+                if let Ok(content) = std::fs::read_to_string(&file_path) {
+                    let params = DidChangeTextDocumentParams {
+                        text_document: VersionedTextDocumentIdentifier {
+                            uri: uri.clone(),
+                            version,
+                        },
+                        content_changes: vec![TextDocumentContentChangeEvent {
+                            range: None, // Full document update (safer)
+                            range_length: None,
+                            text: content,
+                        }],
+                    };
+                    
+                    tracing::trace!("Sending didChange for opened file: {:?}, version: {}", file_path, version);
+                    let _ = client.did_change(params).await;
+                }
+            }
+        }
+
+        Ok(())
+    }
 }
 
 #[cfg(test)]
@@ -107,6 +173,10 @@ impl CodingService for LspCodingService {
                 use crate::utils::apply_workspace_edit;
                 if let Err(e) = apply_workspace_edit(workspace_edit) {
                     tracing::trace!("Failed to apply workspace edit: {}", e);
+                } else {
+                    // Send workspace change notifications. 
+                    // TODO: This needs to be improved to have a propper fileWatcher for the repository.
+                    self.notify_file_changes(workspace_manager, workspace_edit).await?;
                 }
             }
         } else {

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

@@ -2,18 +2,25 @@ use crate::config::ConfigManager;
 use crate::lsp::LspRegistry;
 use crate::model::types::{LspInfo, WorkspaceInfo};
 use anyhow::Result;
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 use std::path::{Path, PathBuf};
 use tracing::warn;
 use url::Url;
 
+/// Tracks file state in LSP servers
+#[derive(Debug, Clone)]
+pub struct FileState {
+    pub version: i32,
+    pub is_open: bool,
+}
+
 /// Manages workspace detection and LSP client lifecycle
 #[derive(Debug)]
 pub struct WorkspaceManager {
     workspace_root: PathBuf,
     registry: LspRegistry,
     initialized: bool,
-    opened_files: HashSet<PathBuf>,
+    opened_files: HashMap<PathBuf, FileState>, // Track version and open state
     workspace_info: Option<WorkspaceInfo>,
 }
 
@@ -34,7 +41,7 @@ impl WorkspaceManager {
             workspace_root: resolved_root,
             registry,
             initialized: false,
-            opened_files: HashSet::new(),
+            opened_files: HashMap::new(),
             workspace_info: None,
         }
     }
@@ -285,12 +292,38 @@ impl WorkspaceManager {
 
     /// Check if a file is already opened
     pub fn is_file_opened(&self, file_path: &Path) -> bool {
-        self.opened_files.contains(file_path)
+        self.opened_files.get(file_path).map_or(false, |state| state.is_open)
     }
 
-    /// Mark a file as opened
+    /// Mark a file as opened with initial version
     pub fn mark_file_opened(&mut self, file_path: PathBuf) {
-        self.opened_files.insert(file_path);
+        self.opened_files.insert(file_path, FileState {
+            version: 1,
+            is_open: true,
+        });
+    }
+
+    /// Get next version for file and increment it
+    pub fn get_next_version(&mut self, file_path: &Path) -> i32 {
+        if let Some(state) = self.opened_files.get_mut(file_path) {
+            state.version += 1;
+            state.version
+        } else {
+            // File not tracked, start at version 1
+            self.opened_files.insert(file_path.to_path_buf(), FileState {
+                version: 1,
+                is_open: true,
+            });
+            1
+        }
+    }
+
+    /// Mark file as closed
+    pub fn mark_file_closed(&mut self, file_path: &Path) {
+        if let Some(state) = self.opened_files.get_mut(file_path) {
+            state.is_open = false;
+            state.version = 0;
+        }
     }
 
     /// Get detected workspace languages (cached)