Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

Make grep tool results clickable in agent panel (#59230)

MartinYe123440211567b8df
diff --git a/crates/agent/src/tools/grep_tool.rs b/crates/agent/src/tools/grep_tool.rs
index 32d872f6578..381639e3e27 100644
--- a/crates/agent/src/tools/grep_tool.rs
+++ b/crates/agent/src/tools/grep_tool.rs
@@ -5,7 +5,7 @@ use futures::{FutureExt as _, StreamExt};
use gpui::{App, Entity, SharedString, Task};
use language::{OffsetRangeExt, ParseStatus, Point};
use project::{
- Project, SearchResults, WorktreeSettings,
+ Project, ProjectPath, SearchResults, WorktreeSettings,
search::{SearchQuery, SearchResult},
};
use schemars::JsonSchema;
@@ -13,7 +13,7 @@ use serde::{Deserialize, Serialize};
use settings::Settings;
use std::{cmp, fmt::Write, sync::Arc};
use util::RangeExt;
-use util::markdown::MarkdownInlineCode;
+use util::markdown::{MarkdownCodeBlock, MarkdownInlineCode};
use util::paths::PathMatcher;
/// Searches the contents of files in the project with a regular expression
@@ -178,6 +178,8 @@ impl AgentTool for GrepTool {
futures::pin_mut!(rx);
let mut output = String::new();
+ let mut content = Vec::new();
+ let mut locations = Vec::new();
let mut skips_remaining = input.offset;
let mut matches_found = 0;
let mut has_more_matches = false;
@@ -203,25 +205,39 @@ impl AgentTool for GrepTool {
continue;
}
- let (Some(path), mut parse_status) = buffer.read_with(cx, |buffer, cx| {
- (buffer.file().map(|file| file.full_path(cx)), buffer.parse_status())
- }) else {
+ let (Some((path, project_path)), mut parse_status) =
+ buffer.read_with(cx, |buffer, cx| {
+ (
+ buffer.file().map(|file| {
+ (
+ file.full_path(cx),
+ ProjectPath {
+ worktree_id: file.worktree_id(cx),
+ path: file.path().clone(),
+ },
+ )
+ }),
+ buffer.parse_status(),
+ )
+ })
+ else {
continue;
};
// Check if this file should be excluded based on its worktree settings
- if let Ok(Some(project_path)) = project.read_with(cx, |project, cx| {
- project.find_project_path(&path, cx)
+ if cx.update(|cx| {
+ let worktree_settings = WorktreeSettings::get(Some((&project_path).into()), cx);
+ worktree_settings.is_path_excluded(&project_path.path)
+ || worktree_settings.is_path_private(&project_path.path)
}) {
- if cx.update(|cx| {
- let worktree_settings = WorktreeSettings::get(Some((&project_path).into()), cx);
- worktree_settings.is_path_excluded(&project_path.path)
- || worktree_settings.is_path_private(&project_path.path)
- }) {
- continue;
- }
+ continue;
}
+ let abs_path = project
+ .read_with(cx, |project, cx| project.absolute_path(&project_path, cx))
+ .ok()
+ .flatten();
+
while *parse_status.borrow() != ParseStatus::Idle {
parse_status.changed().await.map_err(|e| e.to_string())?;
}
@@ -298,18 +314,41 @@ impl AgentTool for GrepTool {
.ok();
}
- if range.start.row == end_row {
- writeln!(output, "L{}", range.start.row + 1)
- .ok();
+ let line_label = if range.start.row == end_row {
+ format!("L{}", range.start.row + 1)
} else {
- writeln!(output, "L{}-{}", range.start.row + 1, end_row + 1)
- .ok();
- }
+ format!("L{}-{}", range.start.row + 1, end_row + 1)
+ };
+ writeln!(output, "{line_label}").ok();
+ let snippet: String = snapshot.text_for_range(range.clone()).collect();
output.push_str("```\n");
- output.extend(snapshot.text_for_range(range));
+ output.push_str(&snippet);
output.push_str("\n```\n");
+ if let Some(abs_path) = &abs_path {
+ content.push(acp::ToolCallContent::Content(acp::Content::new(
+ acp::ContentBlock::ResourceLink(acp::ResourceLink::new(
+ format!("{}#{}", path.display(), line_label),
+ format!("file://{}#{}", abs_path.display(), line_label),
+ )),
+ )));
+ locations.push(
+ acp::ToolCallLocation::new(abs_path).line(Some(range.start.row)),
+ );
+ }
+ // Use a fence longer than any backtick run in the snippet so
+ // matches containing code fences don't break the rendering.
+ content.push(acp::ToolCallContent::Content(acp::Content::new(
+ acp::ContentBlock::Text(acp::TextContent::new(
+ MarkdownCodeBlock {
+ tag: "",
+ text: &snippet,
+ }
+ .to_string(),
+ )),
+ )));
+
if let Some(ancestor_range) = ancestor_range
&& end_row < ancestor_range.end.row {
let remaining_lines = ancestor_range.end.row - end_row;
@@ -321,6 +360,14 @@ impl AgentTool for GrepTool {
}
}
+ if !content.is_empty() {
+ event_stream.update_fields(
+ acp::ToolCallUpdateFields::new()
+ .content(content)
+ .locations(locations),
+ );
+ }
+
if matches_found == 0 {
Ok("No matches found".into())
} else if has_more_matches {
@@ -508,6 +555,158 @@ mod tests {
);
}
+ // The grep tool streams a clickable `file://` ResourceLink and a tool-call
+ // location for every match so each result opens the file at the matched line
+ // in the agent panel. The model-facing text output stays link-free.
+ #[gpui::test]
+ async fn test_grep_results_are_clickable_file_links(cx: &mut TestAppContext) {
+ init_test(cx);
+ cx.executor().allow_parking();
+
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(
+ path!("/root"),
+ json!({
+ "src": {
+ "alpha.txt": "the needle is in alpha",
+ },
+ "beta.txt": "the needle is in beta",
+ }),
+ )
+ .await;
+
+ let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await;
+
+ let tool = Arc::new(GrepTool { project });
+ let (event_stream, mut events) = ToolCallEventStream::test();
+ let input = GrepToolInput {
+ regex: "needle".to_string(),
+ include_pattern: None,
+ offset: 0,
+ case_sensitive: false,
+ };
+ let task = cx.update(|cx| tool.run(ToolInput::resolved(input), event_stream, cx));
+ let output = task.await.expect("grep tool should succeed");
+ let update = events.expect_update_fields().await;
+
+ // Model-facing output is unchanged: matches are rendered as markdown, but
+ // the clickable `file://` URIs only live in the tool-call UI content.
+ assert!(output.contains("## Matches in"));
+ assert!(
+ !output.contains("file://"),
+ "model-facing output should not embed file:// links, got:\n{output}"
+ );
+
+ // Pull the ResourceLink blocks (the clickable links) out of the content.
+ let content = update.content.expect("expected content blocks");
+ let links = content
+ .iter()
+ .filter_map(|block| match block {
+ acp::ToolCallContent::Content(inner) => match &inner.content {
+ acp::ContentBlock::ResourceLink(link) => Some(link),
+ _ => None,
+ },
+ _ => None,
+ })
+ .collect::<Vec<_>>();
+ assert_eq!(links.len(), 2, "expected one resource link per match");
+
+ let alpha_uri = format!("file://{}#L1", path!("/root/src/alpha.txt"));
+ assert!(
+ links.iter().any(|link| {
+ link.name.replace('\\', "/") == "root/src/alpha.txt#L1"
+ && link.uri.replace('\\', "/") == alpha_uri.replace('\\', "/")
+ }),
+ "missing clickable link for alpha.txt, got: {links:?}"
+ );
+
+ let beta_uri = format!("file://{}#L1", path!("/root/beta.txt"));
+ assert!(
+ links.iter().any(|link| {
+ link.name.replace('\\', "/") == "root/beta.txt#L1"
+ && link.uri.replace('\\', "/") == beta_uri.replace('\\', "/")
+ }),
+ "missing clickable link for beta.txt, got: {links:?}"
+ );
+
+ // Each match also reports a location so the panel can reveal the file at
+ // the matched (0-based) row.
+ let locations = update.locations.expect("expected locations");
+ assert_eq!(locations.len(), 2);
+ assert!(
+ locations.iter().any(|location| {
+ location.path.to_string_lossy().replace('\\', "/")
+ == path!("/root/src/alpha.txt").replace('\\', "/")
+ && location.line == Some(0)
+ }),
+ "missing location for alpha.txt, got: {locations:?}"
+ );
+ assert!(
+ locations.iter().any(|location| {
+ location.path.to_string_lossy().replace('\\', "/")
+ == path!("/root/beta.txt").replace('\\', "/")
+ && location.line == Some(0)
+ }),
+ "missing location for beta.txt, got: {locations:?}"
+ );
+ }
+
+ // Snippets that themselves contain a ``` code fence (e.g. matches inside
+ // markdown) must be wrapped in a longer fence so they don't break out of the
+ // surrounding code block when rendered in the agent panel.
+ #[gpui::test]
+ async fn test_grep_snippet_fence_outlives_inner_backticks(cx: &mut TestAppContext) {
+ init_test(cx);
+ cx.executor().allow_parking();
+
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(
+ path!("/root"),
+ json!({
+ "doc.md": "before\n```\nNEEDLE inside fence\n```\nafter",
+ }),
+ )
+ .await;
+
+ let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await;
+
+ let tool = Arc::new(GrepTool { project });
+ let (event_stream, mut events) = ToolCallEventStream::test();
+ let input = GrepToolInput {
+ regex: "NEEDLE".to_string(),
+ include_pattern: None,
+ offset: 0,
+ case_sensitive: false,
+ };
+ let task = cx.update(|cx| tool.run(ToolInput::resolved(input), event_stream, cx));
+ task.await.expect("grep tool should succeed");
+ let update = events.expect_update_fields().await;
+
+ // Find the snippet text block emitted alongside the clickable link.
+ let content = update.content.expect("expected content blocks");
+ let snippet = content
+ .iter()
+ .find_map(|block| match block {
+ acp::ToolCallContent::Content(inner) => match &inner.content {
+ acp::ContentBlock::Text(text) => Some(text.text.as_str()),
+ _ => None,
+ },
+ _ => None,
+ })
+ .expect("expected a snippet text block in the tool-call content");
+
+ // The snippet embeds a three-backtick fence, so the wrapping fence must be
+ // at least four backticks long to avoid breaking out of the code block.
+ assert!(
+ snippet.contains("NEEDLE inside fence"),
+ "snippet should contain the matched line, got:\n{snippet}"
+ );
+ assert!(
+ snippet.starts_with("````\n"),
+ "snippet should be wrapped in a fence longer than the inner ```, got:\n{snippet}"
+ );
+ }
+
/// Helper function to set up a syntax test environment
async fn setup_syntax_test(cx: &mut TestAppContext) -> Entity<Project> {
use unindent::Unindent;
diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rs
index 8028b9bde3a..b938a2572ae 100644
--- a/crates/agent_ui/src/conversation_view/thread_view.rs
+++ b/crates/agent_ui/src/conversation_view/thread_view.rs
@@ -9215,7 +9215,12 @@ impl ThreadView {
};
let label: SharedString = if let Some(abs_path) = is_file {
- if let Some(project_path) = project
+ // Split off an optional `#L<line>` fragment so the path still resolves.
+ let (abs_path, fragment) = abs_path
+ .split_once('#')
+ .map_or((abs_path, None), |(path, fragment)| (path, Some(fragment)));
+
+ let path_label = if let Some(project_path) = project
.read(cx)
.project_path_for_absolute_path(&Path::new(abs_path), cx)
&& let Some(worktree) = project
@@ -9227,9 +9232,13 @@ impl ThreadView {
.full_path(&project_path.path)
.to_string_lossy()
.to_string()
- .into()
} else {
- abs_path.to_string().into()
+ abs_path.to_string()
+ };
+
+ match fragment {
+ Some(fragment) => format!("{path_label}#{fragment}").into(),
+ None => path_label.into(),
}
} else {
uri.clone()