feat: add tests for handling empty lines and Unicode normalization in search-replace logic and enhance candidate matching logic

Author: gabrielmaialva33

src/tools/file_write_or_edit.rs

@@ -337,25 +337,59 @@ fn find_contiguous_candidates(
         return Vec::new();
     }
 
+    if ignore_empty_lines {
+        return find_empty_line_tolerant_candidates(lines, block, offset, &search_lines);
+    }
+
     let max_start = lines.len() - search_lines.len();
     (offset..=max_start)
-        .filter_map(|start| match_candidate(lines, &search_lines, block, start, ignore_empty_lines))
+        .filter_map(|start| {
+            let end = start + search_lines.len();
+            let actual_lines: Vec<&String> = lines[start..end].iter().collect();
+            match_candidate(lines, &actual_lines, &search_lines, block, start, end, false)
+        })
+        .collect()
+}
+
+fn find_empty_line_tolerant_candidates(
+    lines: &[String],
+    block: &SearchReplaceBlock,
+    offset: usize,
+    search_lines: &[String],
+) -> Vec<MatchCandidate> {
+    let compact_lines: Vec<(usize, &String)> =
+        lines.iter().enumerate().skip(offset).filter(|(_, line)| !line.trim().is_empty()).collect();
+
+    if compact_lines.len() < search_lines.len() {
+        return Vec::new();
+    }
+
+    let max_start = compact_lines.len() - search_lines.len();
+    (0..=max_start)
+        .filter_map(|compact_start| {
+            let compact_end = compact_start + search_lines.len();
+            let start = compact_lines[compact_start].0;
+            let end = compact_lines[compact_end - 1].0 + 1;
+            let actual_lines: Vec<&String> =
+                compact_lines[compact_start..compact_end].iter().map(|(_, line)| *line).collect();
+            match_candidate(lines, &actual_lines, search_lines, block, start, end, true)
+        })
         .collect()
 }
 
 fn match_candidate(
     lines: &[String],
+    actual_lines: &[&String],
     search_lines: &[String],
     block: &SearchReplaceBlock,
     start: usize,
+    end: usize,
     ignore_empty_lines: bool,
 ) -> Option<MatchCandidate> {
-    let end = start + search_lines.len();
-    let matched = &lines[start..end];
     let mut tolerances = Vec::new();
     let mut score = 0;
 
-    for (actual, expected) in matched.iter().zip(search_lines) {
+    for (actual, expected) in actual_lines.iter().zip(search_lines) {
         let line_match = matching_tolerance(actual, expected)?;
         if let LineMatch::Tolerated(tolerance) = line_match {
             score += tolerance.score();
@@ -374,6 +408,7 @@ fn match_candidate(
         replace = replace.into_iter().map(|line| remove_leading_line_number(&line)).collect();
     }
     if tolerances.contains(&ToleranceKind::IgnoreIndentation) {
+        let matched = &lines[start..end];
         replace = fix_indentation(matched, search_lines, &replace);
     }
 

tests/file_write_edit_test.rs

@@ -516,6 +516,62 @@ class Example:
     Ok(())
 }
 
+#[tokio::test(flavor = "multi_thread")]
+async fn test_search_replace_matches_across_extra_blank_lines() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let bash_state_arc = create_initialized_state(&temp_dir, "blank-lines").await?;
+
+    let file_path = temp_dir.path().join("blank_lines.txt");
+    std::fs::write(&file_path, "alpha\n\nbeta\ngamma\n")?;
+    read_file_before_edit(&bash_state_arc, &file_path).await?;
+
+    let edit = FileWriteOrEdit {
+        file_path: file_path.to_string_lossy().to_string(),
+        percentage_to_change: 10,
+        text_or_search_replace_blocks: r"<<<<<<< SEARCH
+alpha
+beta
+=======
+alpha
+beta-updated
+>>>>>>> REPLACE"
+            .to_string(),
+        thread_id: "blanklines".to_string(),
+    };
+
+    winx_code_agent::tools::file_write_or_edit::handle_tool_call(&bash_state_arc, edit).await?;
+
+    let content = std::fs::read_to_string(&file_path)?;
+    assert_eq!(content, "alpha\nbeta-updated\ngamma\n");
+
+    Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_search_replace_normalizes_common_unicode_mistakes() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let bash_state_arc = create_initialized_state(&temp_dir, "unicode-mistakes").await?;
+
+    let file_path = temp_dir.path().join("unicode.txt");
+    std::fs::write(&file_path, "println!(\"hello - world...\");\n")?;
+    read_file_before_edit(&bash_state_arc, &file_path).await?;
+
+    let edit = FileWriteOrEdit {
+        file_path: file_path.to_string_lossy().to_string(),
+        percentage_to_change: 10,
+        text_or_search_replace_blocks: "<<<<<<< SEARCH\nprintln!(\u{201c}hello \u{2014} world\u{2026}\u{201d});\n=======\nprintln!(\"updated\");\n>>>>>>> REPLACE"
+            .to_string(),
+        thread_id: "unicodemistakes".to_string(),
+    };
+
+    winx_code_agent::tools::file_write_or_edit::handle_tool_call(&bash_state_arc, edit).await?;
+
+    let content = std::fs::read_to_string(&file_path)?;
+    assert_eq!(content, "println!(\"updated\");\n");
+
+    Ok(())
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn test_search_replace_removes_readfiles_line_numbers() -> Result<()> {
     let temp_dir = TempDir::new()?;