feat(fs_write): fuzzy str_replace with 3-strategy fallback chain + file freshness check

The current str_replace implementation uses exact byte matching only.
When the model's old_str has minor differences from the file (indentation
drift, whitespace, or small context edits), the match fails and the model
either retries wastefully or falls back to destructive shell commands.

Implement str_replace_fuzzy() with a 3-strategy fallback chain inspired
by opencode and cline's diff-apply approaches:

1. Exact match — unchanged behaviour for the common case
2. Line-trimmed match — compares lines after trim(), then replaces using
   byte offsets (prefix-sum table) into the original content. Handles
   indentation drift (tab vs spaces, different indent levels).
3. Block-anchor match — uses first+last line as anchors, scores middle
   lines with Levenshtein similarity, picks the best candidate above a
   0.6 threshold. Handles minor edits in surrounding context lines.

Also adds file freshness checking:
- fs_read now records the file mtime into FileLineTracker.last_read_mtime
  whenever it reads a file
- fs_write str_replace checks the current mtime against the recorded value
  before writing; if the file was modified externally it returns a clear
  error asking the model to re-read before retrying

Also:
- validate() rejects empty old_str before reaching fuzzy matching
- tool_index.json description updated to reflect fuzzy tolerance and
  reinforce read-before-write / no-sed-fallback guidance

Key correctness properties:
- Strategies 2 and 3 return byte ranges — replacement is always at the
  correct position even if matched text appears elsewhere in the file
- block_anchor_match skips first==last anchors (false positive guard)
- similarity_score respects actual content window bounds
- levenshtein uses O(n) rolling-row space, char count for denominator
- build_line_offsets prefix-sum gives O(1) offset lookup
- strip_empty_boundary_lines handles both leading and trailing empty lines

11 tests cover all strategies, edge cases, and error messages.

Author: sandikodev

crates/chat-cli/src/cli/chat/line_tracker.rs

@@ -1,3 +1,5 @@
+use std::time::SystemTime;
+
 use serde::{
     Deserialize,
     Serialize,
@@ -19,6 +21,10 @@ pub struct FileLineTracker {
     pub lines_removed_by_agent: usize,
     /// Whether or not this is the first `fs_write` invocation
     pub is_first_write: bool,
+    /// mtime of the file at the time it was last read by `fs_read`.
+    /// Used by `fs_write` to detect external modifications between read and write.
+    #[serde(skip)]
+    pub last_read_mtime: Option<SystemTime>,
 }
 
 impl Default for FileLineTracker {
@@ -30,6 +36,7 @@ impl Default for FileLineTracker {
             lines_added_by_agent: 0,
             lines_removed_by_agent: 0,
             is_first_write: true,
+            last_read_mtime: None,
         }
     }
 }

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

@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::collections::VecDeque;
 use std::fs::Metadata;
 use std::io::Write;
@@ -43,6 +44,7 @@ use crate::cli::chat::{
     CONTINUATION_LINE,
     sanitize_unicode_tags,
 };
+use crate::cli::chat::line_tracker::FileLineTracker;
 use crate::os::Os;
 use crate::theme::StyledText;
 use crate::util::paths;
@@ -266,7 +268,25 @@ impl FsRead {
         }
     }
 
-    pub async fn invoke(&self, os: &Os, updates: &mut impl Write) -> Result<InvokeOutput> {
+    pub async fn invoke(
+        &self,
+        os: &Os,
+        updates: &mut impl Write,
+        line_tracker: &mut HashMap<String, FileLineTracker>,
+    ) -> Result<InvokeOutput> {
+        // Record mtime for each file-read operation so fs_write can detect
+        // external modifications between read and write.
+        for op in &self.operations {
+            if let Some(path) = op.file_path(os) {
+                if let Ok(meta) = std::fs::metadata(&path) {
+                    if let Ok(mtime) = meta.modified() {
+                        let key = path.to_string_lossy().to_string();
+                        line_tracker.entry(key).or_default().last_read_mtime = Some(mtime);
+                    }
+                }
+            }
+        }
+
         if self.operations.len() == 1 {
             // Single operation - return result directly
             self.operations[0].invoke(os, updates).await
@@ -358,6 +378,15 @@ impl FsRead {
 }
 
 impl FsReadOperation {
+    /// Returns the resolved file path for Line operations (the only type that reads file content).
+    /// Used to record mtime for freshness checking in fs_write.
+    pub fn file_path(&self, os: &Os) -> Option<std::path::PathBuf> {
+        match self {
+            FsReadOperation::Line(fs_line) => Some(sanitize_path_tool_arg(os, &fs_line.path)),
+            _ => None,
+        }
+    }
+
     pub async fn validate(&mut self, os: &Os) -> Result<()> {
         match self {
             FsReadOperation::Line(fs_line) => fs_line.validate(os).await,
@@ -943,7 +972,7 @@ mod tests {
                 });
                 let output = serde_json::from_value::<FsRead>(v)
                     .unwrap()
-                    .invoke(&os, &mut stdout)
+                    .invoke(&os, &mut stdout, &mut HashMap::new())
                     .await
                     .unwrap();
 
@@ -977,7 +1006,7 @@ mod tests {
         assert!(
             serde_json::from_value::<FsRead>(v)
                 .unwrap()
-                .invoke(&os, &mut stdout)
+                .invoke(&os, &mut stdout, &mut HashMap::new())
                 .await
                 .is_err()
         );
@@ -1010,7 +1039,7 @@ mod tests {
         }]});
         let output = serde_json::from_value::<FsRead>(v)
             .unwrap()
-            .invoke(&os, &mut stdout)
+            .invoke(&os, &mut stdout, &mut HashMap::new())
             .await
             .unwrap();
 
@@ -1029,7 +1058,7 @@ mod tests {
         });
         let output = serde_json::from_value::<FsRead>(v)
             .unwrap()
-            .invoke(&os, &mut stdout)
+            .invoke(&os, &mut stdout, &mut HashMap::new())
             .await
             .unwrap();
 
@@ -1055,7 +1084,7 @@ mod tests {
                 let v = serde_json::json!($value);
                 let output = serde_json::from_value::<FsRead>(v)
                     .unwrap()
-                    .invoke(&os, &mut stdout)
+                    .invoke(&os, &mut stdout, &mut HashMap::new())
                     .await
                     .unwrap();
 
@@ -1102,7 +1131,7 @@ mod tests {
         });
         let output = serde_json::from_value::<FsRead>(v)
             .unwrap()
-            .invoke(&os, &mut stdout)
+            .invoke(&os, &mut stdout, &mut HashMap::new())
             .await
             .unwrap();
 
@@ -1134,7 +1163,7 @@ mod tests {
         });
         let output = serde_json::from_value::<FsRead>(v)
             .unwrap()
-            .invoke(&os, &mut stdout)
+            .invoke(&os, &mut stdout, &mut HashMap::new())
             .await
             .unwrap();
 
@@ -1171,7 +1200,7 @@ mod tests {
         });
         let output = serde_json::from_value::<FsRead>(v)
             .unwrap()
-            .invoke(&os, &mut stdout)
+            .invoke(&os, &mut stdout, &mut HashMap::new())
             .await
             .unwrap();
 
@@ -1195,7 +1224,7 @@ mod tests {
         });
         let output = serde_json::from_value::<FsRead>(v)
             .unwrap()
-            .invoke(&os, &mut stdout)
+            .invoke(&os, &mut stdout, &mut HashMap::new())
             .await
             .unwrap();
 
@@ -1232,7 +1261,7 @@ mod tests {
         });
         let output = serde_json::from_value::<FsRead>(v)
             .unwrap()
-            .invoke(&os, &mut stdout)
+            .invoke(&os, &mut stdout, &mut HashMap::new())
             .await
             .unwrap();
 
@@ -1272,7 +1301,7 @@ mod tests {
         });
         let output = serde_json::from_value::<FsRead>(v)
             .unwrap()
-            .invoke(&os, &mut stdout)
+            .invoke(&os, &mut stdout, &mut HashMap::new())
             .await
             .unwrap();
 
@@ -1302,7 +1331,7 @@ mod tests {
         });
         let output = serde_json::from_value::<FsRead>(v)
             .unwrap()
-            .invoke(&os, &mut stdout)
+            .invoke(&os, &mut stdout, &mut HashMap::new())
             .await
             .unwrap();
 
@@ -1321,7 +1350,7 @@ mod tests {
         });
         let output = serde_json::from_value::<FsRead>(v)
             .unwrap()
-            .invoke(&os, &mut stdout)
+            .invoke(&os, &mut stdout, &mut HashMap::new())
             .await
             .unwrap();
 
@@ -1353,7 +1382,7 @@ mod tests {
 
         let output = serde_json::from_value::<FsRead>(v)
             .unwrap()
-            .invoke(&os, &mut stdout)
+            .invoke(&os, &mut stdout, &mut HashMap::new())
             .await
             .unwrap();
         // All text operations should return combined text