assistant edit tool: Revert fuzzy matching (#26996)

#26935 is leading to bad edits, so let's revert it for now. I'll bring
back a version of this, but it'll likely just focus on indentation
instead of making the whole search fuzzy.

Release Notes: 

- N/A

crates/assistant_tools/src/edit_files_tool.rs

@@ -1,6 +1,5 @@
 mod edit_action;
 pub mod log;
-mod resolve_search_block;
 
 use anyhow::{anyhow, Context, Result};
 use assistant_tool::{ActionLog, Tool};
@@ -8,17 +7,16 @@ use collections::HashSet;
 use edit_action::{EditAction, EditActionParser};
 use futures::StreamExt;
 use gpui::{App, AsyncApp, Entity, Task};
-use language::OffsetRangeExt;
 use language_model::{
     LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, MessageContent, Role,
 };
 use log::{EditToolLog, EditToolRequestId};
-use project::Project;
-use resolve_search_block::resolve_search_block;
+use project::{search::SearchQuery, Project};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::fmt::Write;
 use std::sync::Arc;
+use util::paths::PathMatcher;
 use util::ResultExt;
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
@@ -131,11 +129,24 @@ struct EditToolRequest {
     parser: EditActionParser,
     output: String,
     changed_buffers: HashSet<Entity<language::Buffer>>,
+    bad_searches: Vec<BadSearch>,
     project: Entity<Project>,
     action_log: Entity<ActionLog>,
     tool_log: Option<(Entity<EditToolLog>, EditToolRequestId)>,
 }
 
+#[derive(Debug)]
+enum DiffResult {
+    BadSearch(BadSearch),
+    Diff(language::Diff),
+}
+
+#[derive(Debug)]
+struct BadSearch {
+    file_path: String,
+    search: String,
+}
+
 impl EditToolRequest {
     fn new(
         input: EditFilesToolInput,
@@ -193,6 +204,7 @@ impl EditToolRequest {
                 // we start with the success header so we don't need to shift the output in the common case
                 output: Self::SUCCESS_OUTPUT_HEADER.to_string(),
                 changed_buffers: HashSet::default(),
+                bad_searches: Vec::new(),
                 action_log,
                 project,
                 tool_log,
@@ -239,30 +251,36 @@ impl EditToolRequest {
             .update(cx, |project, cx| project.open_buffer(project_path, cx))?
             .await?;
 
-        let diff = match action {
+        let result = match action {
             EditAction::Replace {
                 old,
                 new,
-                file_path: _,
+                file_path,
             } => {
                 let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot())?;
 
-                let diff = cx
-                    .background_executor()
-                    .spawn(Self::replace_diff(old, new, snapshot))
-                    .await;
-
-                anyhow::Ok(diff)
+                cx.background_executor()
+                    .spawn(Self::replace_diff(old, new, file_path, snapshot))
+                    .await
             }
-            EditAction::Write { content, .. } => Ok(buffer
-                .read_with(cx, |buffer, cx| buffer.diff(content, cx))?
-                .await),
+            EditAction::Write { content, .. } => Ok(DiffResult::Diff(
+                buffer
+                    .read_with(cx, |buffer, cx| buffer.diff(content, cx))?
+                    .await,
+            )),
         }?;
 
-        let _clock = buffer.update(cx, |buffer, cx| buffer.apply_diff(diff, cx))?;
+        match result {
+            DiffResult::BadSearch(invalid_replace) => {
+                self.bad_searches.push(invalid_replace);
+            }
+            DiffResult::Diff(diff) => {
+                let _clock = buffer.update(cx, |buffer, cx| buffer.apply_diff(diff, cx))?;
 
-        write!(&mut self.output, "\n\n{}", source)?;
-        self.changed_buffers.insert(buffer);
+                write!(&mut self.output, "\n\n{}", source)?;
+                self.changed_buffers.insert(buffer);
+            }
+        }
 
         Ok(())
     }
@@ -270,9 +288,29 @@ impl EditToolRequest {
     async fn replace_diff(
         old: String,
         new: String,
+        file_path: std::path::PathBuf,
         snapshot: language::BufferSnapshot,
-    ) -> language::Diff {
-        let edit_range = resolve_search_block(&snapshot, &old).to_offset(&snapshot);
+    ) -> Result<DiffResult> {
+        let query = SearchQuery::text(
+            old.clone(),
+            false,
+            true,
+            true,
+            PathMatcher::new(&[])?,
+            PathMatcher::new(&[])?,
+            None,
+        )?;
+
+        let matches = query.search(&snapshot, None).await;
+
+        if matches.is_empty() {
+            return Ok(DiffResult::BadSearch(BadSearch {
+                search: new.clone(),
+                file_path: file_path.display().to_string(),
+            }));
+        }
+
+        let edit_range = matches[0].clone();
         let diff = language::text_diff(&old, &new);
 
         let edits = diff
@@ -290,7 +328,7 @@ impl EditToolRequest {
             edits,
         };
 
-        diff
+        anyhow::Ok(DiffResult::Diff(diff))
     }
 
     const SUCCESS_OUTPUT_HEADER: &str = "Successfully applied. Here's a list of changes:";
@@ -314,7 +352,7 @@ impl EditToolRequest {
 
         let errors = self.parser.errors();
 
-        if errors.is_empty() {
+        if errors.is_empty() && self.bad_searches.is_empty() {
             if changed_buffer_count == 0 {
                 return Err(anyhow!(
                     "The instructions didn't lead to any changes. You might need to consult the file contents first."
@@ -337,6 +375,24 @@ impl EditToolRequest {
                 );
             }
 
+            if !self.bad_searches.is_empty() {
+                writeln!(
+                    &mut output,
+                    "\n\nThese searches failed because they didn't match any strings:"
+                )?;
+
+                for replace in self.bad_searches {
+                    writeln!(
+                        &mut output,
+                        "- '{}' does not appear in `{}`",
+                        replace.search.replace("\r", "\\r").replace("\n", "\\n"),
+                        replace.file_path
+                    )?;
+                }
+
+                write!(&mut output, "Make sure to use exact searches.")?;
+            }
+
             if !errors.is_empty() {
                 writeln!(
                     &mut output,