Preserve trailing whitespace in files that already have it

When reading a file, detect whether it has trailing whitespace on any
line. If it does, normalization only converts line endings to LF but
leaves trailing whitespace intact. This prevents the agent from
producing noisy whitespace-only diffs when editing files in repos
that have trailing whitespace.

Files without trailing whitespace continue to be fully normalized
(line endings + trailing ws stripped), ensuring edits stay clean.

- Add has_trailing_whitespace flag to FileFormat (serde-compatible)
- Add detect_trailing_whitespace() and normalize_line_endings()
- Thread preserve_trailing_ws through file_updater functions
- Update Explorer, ACP explorer, and all call sites
- Add tests for both modes

Author: stippi

crates/code_assistant/src/acp/explorer.rs

@@ -7,7 +7,10 @@ use std::sync::{Arc, OnceLock, RwLock};
 use crate::config::{DefaultProjectManager, ProjectManager};
 use crate::types::Project;
 use command_executor::CommandExecutor;
-use fs_explorer::encoding::{apply_file_format, detect_line_ending, normalize_content};
+use fs_explorer::encoding::{
+    apply_file_format, detect_line_ending, detect_trailing_whitespace, normalize_content,
+    normalize_line_endings,
+};
 use fs_explorer::file_updater::{
     apply_matches, apply_replacements_normalized, extract_stable_ranges, find_replacement_matches,
     reconstruct_formatted_replacements,
@@ -165,15 +168,22 @@ impl AcpCodeExplorer {
         .await?;
 
         let line_ending = detect_line_ending(&response.content);
+        let has_trailing_whitespace = detect_trailing_whitespace(&response.content);
         self.store_format(
             &abs,
             FileFormat {
                 encoding: FileEncoding::UTF8,
                 line_ending,
+                has_trailing_whitespace,
             },
         );
 
-        Ok((normalize_content(&response.content), abs))
+        let normalized = if has_trailing_whitespace {
+            normalize_line_endings(&response.content)
+        } else {
+            normalize_content(&response.content)
+        };
+        Ok((normalized, abs))
     }
 
     async fn write_entire(&self, path: &Path, content: &str) -> Result<String> {
@@ -191,15 +201,23 @@ impl AcpCodeExplorer {
             abs.clone(),
         ))
         .await?;
+
         let line_ending = detect_line_ending(&response.content);
+        let has_trailing_whitespace = detect_trailing_whitespace(&response.content);
         self.store_format(
             &abs,
             FileFormat {
                 encoding: FileEncoding::UTF8,
                 line_ending,
+                has_trailing_whitespace,
             },
         );
-        Ok(normalize_content(&response.content))
+        let normalized = if has_trailing_whitespace {
+            normalize_line_endings(&response.content)
+        } else {
+            normalize_content(&response.content)
+        };
+        Ok(normalized)
     }
 }
 
@@ -285,7 +303,12 @@ impl CodeExplorer for AcpCodeExplorer {
         replacements: &[FileReplacement],
     ) -> Result<String> {
         let (original_content, _) = self.read_entire(path).await?;
-        let updated = apply_replacements_normalized(&original_content, replacements)?;
+        let format = self.format_for_path(path);
+        let updated = apply_replacements_normalized(
+            &original_content,
+            replacements,
+            format.has_trailing_whitespace,
+        )?;
         self.write_entire(path, &updated).await
     }
 
@@ -297,13 +320,22 @@ impl CodeExplorer for AcpCodeExplorer {
         _command_executor: &dyn CommandExecutor,
     ) -> Result<(String, Option<Vec<FileReplacement>>)> {
         let (original_content, _) = self.read_entire(path).await?;
-        let (matches, has_conflicts) = find_replacement_matches(&original_content, replacements)?;
-        let updated_content = apply_matches(&original_content, &matches, replacements)?;
+        let format = self.format_for_path(path);
+        let preserve_trailing_ws = format.has_trailing_whitespace;
+        let (matches, has_conflicts) =
+            find_replacement_matches(&original_content, replacements, preserve_trailing_ws)?;
+        let updated_content = apply_matches(
+            &original_content,
+            &matches,
+            replacements,
+            preserve_trailing_ws,
+        )?;
         let final_content = self.write_entire(path, &updated_content).await?;
         let updated_replacements = if has_conflicts {
             None
         } else {
-            let stable_ranges = extract_stable_ranges(&original_content, &matches);
+            let stable_ranges =
+                extract_stable_ranges(&original_content, &matches, preserve_trailing_ws);
             reconstruct_formatted_replacements(
                 &original_content,
                 &final_content,

crates/code_assistant/src/tests/format_on_save_tests.rs

@@ -25,7 +25,7 @@ fn test_stable_range_extraction_simple() -> Result<()> {
         end: 42,   // End of "console.log('hello');"
     }];
 
-    let stable_ranges = extract_stable_ranges(content, &matches);
+    let stable_ranges = extract_stable_ranges(content, &matches, false);
 
     // Should have stable ranges before and after the match
     assert_eq!(stable_ranges.len(), 2);
@@ -63,7 +63,7 @@ fn test_stable_range_extraction_multiple_matches() -> Result<()> {
         },
     ];
 
-    let stable_ranges = extract_stable_ranges(content, &matches);
+    let stable_ranges = extract_stable_ranges(content, &matches, false);
 
     // Should have one stable range between the two matches
     assert_eq!(stable_ranges.len(), 1);
@@ -91,7 +91,7 @@ fn test_parameter_reconstruction_simple() -> Result<()> {
         end: 21,   // End of "const y=2;"
     }];
 
-    let stable_ranges = extract_stable_ranges(original_content, &matches);
+    let stable_ranges = extract_stable_ranges(original_content, &matches, false);
 
     let original_replacements = vec![FileReplacement {
         search: "const y=2;".to_string(),
@@ -128,7 +128,7 @@ fn test_parameter_reconstruction_failure() -> Result<()> {
         end: 32,   // End of "// Comment"
     }];
 
-    let stable_ranges = extract_stable_ranges(original_content, &matches);
+    let stable_ranges = extract_stable_ranges(original_content, &matches, false);
 
     let original_replacements = vec![FileReplacement {
         search: "// Comment".to_string(),

crates/code_assistant/src/tests/mocks.rs

@@ -550,7 +550,7 @@ impl CodeExplorer for MockExplorer {
             .ok_or_else(|| anyhow::anyhow!("File not found: {}", path.display()))?
             .clone();
 
-        let updated_content = apply_replacements_normalized(&content, replacements)?;
+        let updated_content = apply_replacements_normalized(&content, replacements, false)?;
 
         // Update the stored content
         files.insert(path.to_path_buf(), updated_content.clone());
@@ -569,7 +569,9 @@ impl CodeExplorer for MockExplorer {
         let original_content = self.read_file(path).await?;
 
         // Find matches and detect adjacency/overlap
-        let (matches, has_conflicts) = find_replacement_matches(&original_content, replacements)?;
+
+        let (matches, has_conflicts) =
+            find_replacement_matches(&original_content, replacements, false)?;
 
         // Apply replacements first
         let updated_content = self.apply_replacements(path, replacements).await?;
@@ -601,7 +603,7 @@ impl CodeExplorer for MockExplorer {
         let updated_replacements = if has_conflicts {
             None
         } else {
-            let stable_ranges = extract_stable_ranges(&original_content, &matches);
+            let stable_ranges = extract_stable_ranges(&original_content, &matches, false);
             reconstruct_formatted_replacements(
                 &original_content,
                 &final_content,

crates/fs_explorer/src/encoding.rs

@@ -150,21 +150,49 @@ pub fn detect_line_ending(content: &str) -> LineEnding {
     }
 }
 
+/// Detects whether the content has trailing whitespace on any line
+pub fn detect_trailing_whitespace(content: &str) -> bool {
+    // Normalize line endings first so we split correctly
+    let content = content.replace("\r\n", "\n").replace('\r', "\n");
+    content.lines().any(|line| {
+        let trimmed = line.trim_end();
+        trimmed.len() < line.len()
+    })
+}
+
 /// Normalizes text content by:
 /// 1. Converting all line endings to LF (\n)
 /// 2. Removing trailing whitespace from each line
 /// 3. Preserving empty lines
 /// 4. NOT adding a trailing newline (this happens at file write time)
 pub fn normalize_content(content: &str) -> String {
+    normalize_content_impl(content, true)
+}
+
+/// Normalizes line endings to LF but preserves trailing whitespace on each line.
+/// Used for files that originally had trailing whitespace to avoid noisy diffs.
+pub fn normalize_line_endings(content: &str) -> String {
+    normalize_content_impl(content, false)
+}
+
+/// Normalizes content: always converts line endings to LF,
+/// optionally strips trailing whitespace from each line.
+fn normalize_content_impl(content: &str, strip_trailing_ws: bool) -> String {
     // First normalize all line endings to LF
     let content = content.replace("\r\n", "\n").replace('\r', "\n");
 
-    // Process each line - preserve empty lines but trim trailing whitespace
-    content
-        .lines()
-        .map(|line| line.trim_end())
-        .collect::<Vec<&str>>()
-        .join("\n")
+    if strip_trailing_ws {
+        // Process each line - preserve empty lines but trim trailing whitespace
+        content
+            .lines()
+            .map(|line| line.trim_end())
+            .collect::<Vec<&str>>()
+            .join("\n")
+    } else {
+        // Only normalize line endings, preserve trailing whitespace
+        // .lines() strips the trailing newline, which is what we want
+        content.lines().collect::<Vec<&str>>().join("\n")
+    }
 }
 
 /// Restores the original line endings of content
@@ -264,11 +292,13 @@ mod tests {
         let crlf_format = FileFormat {
             encoding: FileEncoding::UTF8,
             line_ending: LineEnding::Crlf,
+            has_trailing_whitespace: false,
         };
 
         let cr_format = FileFormat {
             encoding: FileEncoding::UTF8,
             line_ending: LineEnding::CR,
+            has_trailing_whitespace: false,
         };
 
         assert_eq!(
@@ -296,6 +326,7 @@ mod tests {
         let format = FileFormat {
             encoding: FileEncoding::UTF8,
             line_ending: LineEnding::LF,
+            has_trailing_whitespace: false,
         };
 
         // All cases should result in content with exactly one trailing newline
@@ -315,4 +346,48 @@ mod tests {
             assert_eq!(content, expected);
         }
     }
+
+    #[test]
+    fn test_detect_trailing_whitespace() {
+        // No trailing whitespace
+        assert!(!detect_trailing_whitespace("Line1\nLine2\nLine3"));
+        // Trailing spaces on a line
+        assert!(detect_trailing_whitespace("Line1  \nLine2\nLine3"));
+        // Trailing tab
+        assert!(detect_trailing_whitespace("Line1\t\nLine2\nLine3"));
+        // Only on last line
+        assert!(detect_trailing_whitespace("Line1\nLine2\nLine3  "));
+        // With CRLF
+        assert!(detect_trailing_whitespace("Line1  \r\nLine2\r\nLine3"));
+        // No trailing whitespace with CRLF
+        assert!(!detect_trailing_whitespace("Line1\r\nLine2\r\nLine3"));
+    }
+
+    #[test]
+    fn test_normalize_line_endings() {
+        // Should preserve trailing whitespace but normalize line endings
+        assert_eq!(
+            normalize_line_endings("Line1  \r\nLine2 \r\nLine3"),
+            "Line1  \nLine2 \nLine3"
+        );
+        // CR line endings
+        assert_eq!(
+            normalize_line_endings("Line1  \rLine2 \rLine3"),
+            "Line1  \nLine2 \nLine3"
+        );
+        // LF already - no change
+        assert_eq!(
+            normalize_line_endings("Line1  \nLine2 \nLine3"),
+            "Line1  \nLine2 \nLine3"
+        );
+    }
+
+    #[test]
+    fn test_normalize_content_strips_trailing_ws() {
+        // normalize_content should strip trailing whitespace
+        assert_eq!(
+            normalize_content("Line1  \nLine2 \nLine3"),
+            "Line1\nLine2\nLine3"
+        );
+    }
 }