Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Fix agent hyperlinks do not open files (#56283)
di4046e9ff7a4f31a
diff --git a/crates/acp_thread/src/mention.rs b/crates/acp_thread/src/mention.rsindex b5e6ab90ab9..93e7b4d846b 100644--- a/crates/acp_thread/src/mention.rs+++ b/crates/acp_thread/src/mention.rs@@ -83,33 +83,6 @@ impl MentionUri {.and_then(|input| input.strip_suffix('`')).unwrap_or(input);- fn parse_line_range(fragment: &str) -> Result<RangeInclusive<u32>> {- let range = fragment.strip_prefix("L").unwrap_or(fragment);-- let (start, end) = if let Some((start, end)) = range.split_once(":") {- (start, end)- } else if let Some((start, end)) = range.split_once("-") {- // Also handle L10-20 or L10-L20 format- (start, end.strip_prefix("L").unwrap_or(end))- } else {- // Single line number like L1872 - treat as a range of one line- (range, range)- };-- let start_line = start- .parse::<u32>()- .context("Parsing line range start")?- .checked_sub(1)- .context("Line numbers should be 1-based")?;- let end_line = end- .parse::<u32>()- .context("Parsing line range end")?- .checked_sub(1)- .context("Line numbers should be 1-based")?;-- Ok(start_line..=end_line)- }-let parse_column =|input: Option<String>| -> Option<u32> { input?.parse::<u32>().ok()?.checked_sub(1) };let validate_query_params = |url: &Url, allowed: &[&str]| -> Result<()> {@@ -121,37 +94,6 @@ impl MentionUri {Ok(())};- let parse_absolute_path = |input: &str| -> Result<Self> {- let (path_input, fragment) = input- .split_once('#')- .map_or((input, None), |(path, fragment)| (path, Some(fragment)));-- if let Some(fragment) = fragment.and_then(|fragment| parse_line_range(fragment).ok()) {- return Ok(MentionUri::Selection {- abs_path: Some(path_input.into()),- line_range: fragment,- column: None,- });- }-- let path_with_position = PathWithPosition::parse_str(path_input);- let abs_path = path_with_position.path;- if let Some(row) = path_with_position.row {- let line = row- .checked_sub(1)- .context("Line numbers should be 1-based")?;- Ok(MentionUri::Selection {- abs_path: Some(abs_path),- line_range: line..=line,- column: path_with_position- .column- .map(|column| column.saturating_sub(1)),- })- } else {- Ok(MentionUri::File { abs_path })- }- };-if is_absolute(input, path_style) && !input.contains("://") {return parse_absolute_path(input).with_context(|| format!("Invalid absolute path mention URI: {input}"));@@ -168,7 +110,10 @@ impl MentionUri {};let decoded = decode(trimmed).unwrap_or(Cow::Borrowed(trimmed));let normalized: Cow<str> = if path_style.is_windows() {- Cow::Owned(decoded.replace('/', "\\"))+ match to_native_windows_path(&decoded) {+ Some(native) => Cow::Owned(native),+ None => decoded,+ }} else {decoded};@@ -337,6 +282,56 @@ impl MentionUri {}}+ /// Parses a hyperlink target from agent-authored Markdown.+ ///+ /// Unlike [`MentionUri::parse`] — which stays strict so canonical mention+ /// URIs round-trip verbatim — bare path targets are normalized first:+ /// percent escapes are decoded (see [`decode_path_escapes`]) and+ /// Windows-compatible spellings like `/C:/foo` or `/c/foo` become native+ /// paths (see [`to_native_windows_path`]).+ pub fn parse_hyperlink(input: &str, path_style: PathStyle) -> Result<Self> {+ if let Some(target) = bare_path_target(input, path_style) {+ return parse_hyperlink_path(target, path_style, DecodePercentEscapes::Yes)+ .with_context(|| format!("Invalid hyperlink path target: {input}"));+ }+ Self::parse(input, path_style)+ }++ /// Returns the literal (un-decoded) interpretation of a bare-path+ /// hyperlink target, for files whose names literally contain an escape+ /// sequence (e.g. `a%20b.rs`). Returns `None` when this wouldn't differ+ /// from [`MentionUri::parse_hyperlink`], including for URLs, whose+ /// escapes are unambiguous.+ pub fn parse_hyperlink_literal(input: &str, path_style: PathStyle) -> Option<Self> {+ let target = bare_path_target(input, path_style)?;+ let (path_input, _) = split_path_fragment(target);+ if !matches!(decode_path_escapes(path_input), Cow::Owned(_)) {+ return None;+ }+ parse_hyperlink_path(target, path_style, DecodePercentEscapes::No).ok()+ }++ /// The absolute path this mention refers to, if it refers to one.+ pub fn abs_path(&self) -> Option<&Path> {+ match self {+ MentionUri::File { abs_path }+ | MentionUri::Directory { abs_path }+ | MentionUri::Symbol { abs_path, .. } => Some(abs_path),+ MentionUri::Selection { abs_path, .. } => abs_path.as_deref(),+ MentionUri::Skill {+ skill_file_path, ..+ } => Some(skill_file_path),+ MentionUri::PastedImage { .. }+ | MentionUri::Thread { .. }+ | MentionUri::Rule { .. }+ | MentionUri::Diagnostics { .. }+ | MentionUri::Fetch { .. }+ | MentionUri::TerminalSelection { .. }+ | MentionUri::GitDiff { .. }+ | MentionUri::MergeConflict { .. } => None,+ }+ }+pub fn name(&self) -> String {match self {MentionUri::File { abs_path, .. } | MentionUri::Directory { abs_path, .. } => abs_path@@ -599,6 +594,217 @@ impl fmt::Display for MentionLink<'_> {}}+#[derive(Clone, Copy, PartialEq, Eq)]+enum DecodePercentEscapes {+ Yes,+ No,+}++fn parse_line_range(fragment: &str) -> Result<RangeInclusive<u32>> {+ let range = fragment.strip_prefix("L").unwrap_or(fragment);++ let (start, end) = if let Some((start, end)) = range.split_once(":") {+ (start, end)+ } else if let Some((start, end)) = range.split_once("-") {+ // Also handle L10-20 or L10-L20 format+ (start, end.strip_prefix("L").unwrap_or(end))+ } else {+ // Single line number like L1872 - treat as a range of one line+ (range, range)+ };++ let start_line = start+ .parse::<u32>()+ .context("Parsing line range start")?+ .checked_sub(1)+ .context("Line numbers should be 1-based")?;+ let end_line = end+ .parse::<u32>()+ .context("Parsing line range end")?+ .checked_sub(1)+ .context("Line numbers should be 1-based")?;++ Ok(start_line..=end_line)+}++/// Returns the mention target as a bare absolute path (not a URL), with the+/// backticks agents sometimes add stripped.+fn bare_path_target(input: &str, path_style: PathStyle) -> Option<&str> {+ let input = input+ .strip_prefix('`')+ .and_then(|input| input.strip_suffix('`'))+ .unwrap_or(input);+ (is_absolute(input, path_style) && !input.contains("://")).then_some(input)+}++fn split_path_fragment(input: &str) -> (&str, Option<&str>) {+ input+ .split_once('#')+ .map_or((input, None), |(path, fragment)| (path, Some(fragment)))+}++fn parse_absolute_path(input: &str) -> Result<MentionUri> {+ let (path_input, fragment) = split_path_fragment(input);+ absolute_path_mention(path_input, fragment)+}++/// Like [`parse_absolute_path`], but normalizes hyperlink spellings first.+fn parse_hyperlink_path(+ input: &str,+ path_style: PathStyle,+ decode_escapes: DecodePercentEscapes,+) -> Result<MentionUri> {+ let (path_input, fragment) = split_path_fragment(input);+ let path_input = normalize_path_mention(path_input, path_style, decode_escapes);+ absolute_path_mention(&path_input, fragment)+}++fn absolute_path_mention(path_input: &str, fragment: Option<&str>) -> Result<MentionUri> {+ if let Some(fragment) = fragment.and_then(|fragment| parse_line_range(fragment).ok()) {+ return Ok(MentionUri::Selection {+ abs_path: Some(path_input.into()),+ line_range: fragment,+ column: None,+ });+ }++ let path_with_position = PathWithPosition::parse_str(path_input);+ let abs_path = path_with_position.path;+ if let Some(row) = path_with_position.row {+ let line = row+ .checked_sub(1)+ .context("Line numbers should be 1-based")?;+ Ok(MentionUri::Selection {+ abs_path: Some(abs_path),+ line_range: line..=line,+ column: path_with_position+ .column+ .map(|column| column.saturating_sub(1)),+ })+ } else {+ Ok(MentionUri::File { abs_path })+ }+}++fn normalize_path_mention(+ input: &str,+ path_style: PathStyle,+ decode_escapes: DecodePercentEscapes,+) -> Cow<'_, str> {+ let decoded = match decode_escapes {+ DecodePercentEscapes::Yes => decode_path_escapes(input),+ DecodePercentEscapes::No => Cow::Borrowed(input),+ };+ if !path_style.is_windows() {+ return decoded;+ }+ match to_native_windows_path(&decoded) {+ Some(native) => Cow::Owned(native),+ None => decoded,+ }+}++/// Decodes percent escapes in a path, leaving separator escapes (`%2F`,+/// `%5C`) encoded so decoding can't change which directories the path+/// traverses. Invalid sequences and non-UTF-8 results leave the input+/// unchanged. Returns `Cow::Owned` iff decoding changed the input+/// (`parse_hyperlink_literal` relies on this).+fn decode_path_escapes(input: &str) -> Cow<'_, str> {+ fn hex_digit(byte: u8) -> Option<u8> {+ match byte {+ b'0'..=b'9' => Some(byte - b'0'),+ b'a'..=b'f' => Some(byte - b'a' + 10),+ b'A'..=b'F' => Some(byte - b'A' + 10),+ _ => None,+ }+ }++ if !input.contains('%') {+ return Cow::Borrowed(input);+ }+ let bytes = input.as_bytes();+ let mut decoded = Vec::with_capacity(bytes.len());+ let mut index = 0;+ while index < bytes.len() {+ if bytes[index] == b'%'+ && let Some(high) = bytes.get(index + 1).copied().and_then(hex_digit)+ && let Some(low) = bytes.get(index + 2).copied().and_then(hex_digit)+ {+ let byte = (high << 4) | low;+ if byte != b'/' && byte != b'\\' {+ decoded.push(byte);+ index += 3;+ continue;+ }+ }+ decoded.push(bytes[index]);+ index += 1;+ }+ if decoded == bytes {+ return Cow::Borrowed(input);+ }+ match String::from_utf8(decoded) {+ Ok(decoded) => Cow::Owned(decoded),+ Err(_) => Cow::Borrowed(input),+ }+}++/// Converts Windows-compatible path spellings into a native Windows path,+/// normalizing separators to backslashes and drive letters to uppercase so+/// parsed paths compare equal to worktree paths. Returns `None` when the+/// input needs no changes.+fn to_native_windows_path(path: &str) -> Option<String> {+ fn join_drive(drive: char, rest: &str) -> String {+ format!(+ "{}:\\{}",+ drive.to_ascii_uppercase(),+ rest.replace('/', "\\")+ )+ }++ if let Some(rest) = path.strip_prefix('/') {+ // URL-style path with a leading slash before the drive: `/C:/foo`.+ let mut chars = rest.chars();+ if let (Some(drive), Some(':'), Some('/' | '\\')) =+ (chars.next(), chars.next(), chars.next())+ && drive.is_ascii_alphabetic()+ {+ return Some(join_drive(drive, chars.as_str()));+ }++ // MSYS/Git Bash style: `/c/foo`. Lowercase-only, since that's what+ // those shells emit and uppercase risks misreading real directories.+ let mut chars = rest.chars();+ if let (Some(drive), Some('/' | '\\')) = (chars.next(), chars.next())+ && drive.is_ascii_lowercase()+ {+ return Some(join_drive(drive, chars.as_str()));+ }+ }++ // A native path with a drive prefix: uppercase the drive and normalize+ // separators, e.g. `c:/foo` or `c:\foo`.+ let mut chars = path.chars();+ if let (Some(drive), Some(':')) = (chars.next(), chars.next())+ && drive.is_ascii_alphabetic()+ {+ if drive.is_ascii_uppercase() && !path.contains('/') {+ return None;+ }+ return Some(format!(+ "{}:{}",+ drive.to_ascii_uppercase(),+ chars.as_str().replace('/', "\\")+ ));+ }++ if path.contains('/') {+ return Some(path.replace('/', "\\"));+ }++ None+}+fn default_include_errors() -> bool {true}@@ -727,6 +933,298 @@ mod tests {}}+ #[test]+ fn test_parse_file_uri_with_spaces() {+ let parsed =+ MentionUri::parse("file:///C:/path%20with%20space/file.rs", PathStyle::Windows)+ .unwrap();+ match parsed {+ MentionUri::File { abs_path } => {+ assert_eq!(abs_path, PathBuf::from("C:\\path with space\\file.rs"));+ }+ other => panic!("Expected File variant, got {other:?}"),+ }+ assert_eq!(+ MentionUri::File {+ abs_path: PathBuf::from("C:\\path with space\\file.rs")+ }+ .to_uri()+ .to_string(),+ "file:///C:/path%20with%20space/file.rs"+ );+ }++ #[test]+ fn test_parse_windows_drive_path_with_leading_slash_and_line() {+ let parsed = MentionUri::parse_hyperlink(+ "/C:/Projects/Example Workspace/Cargo.toml:2",+ PathStyle::Windows,+ )+ .unwrap();+ match parsed {+ MentionUri::Selection {+ abs_path: Some(abs_path),+ line_range,+ ..+ } => {+ assert_eq!(+ abs_path,+ PathBuf::from("C:\\Projects\\Example Workspace\\Cargo.toml")+ );+ assert_eq!(line_range, 1..=1);+ }+ other => panic!("Expected Selection variant, got {other:?}"),+ }+ }++ #[test]+ fn test_parse_windows_path_with_percent_escaped_spaces_and_line() {+ let parsed = MentionUri::parse_hyperlink(+ "C:\\Projects\\Example%20Workspace\\path\\to\\filename.ext:42",+ PathStyle::Windows,+ )+ .unwrap();+ match parsed {+ MentionUri::Selection {+ abs_path: Some(abs_path),+ line_range,+ ..+ } => {+ assert_eq!(+ abs_path,+ PathBuf::from("C:\\Projects\\Example Workspace\\path\\to\\filename.ext")+ );+ assert_eq!(line_range, 41..=41);+ }+ other => panic!("Expected Selection variant, got {other:?}"),+ }+ }++ #[test]+ fn test_parse_windows_compat_path_with_spaces() {+ let parsed = MentionUri::parse_hyperlink(+ "/c/Projects/Example Workspace/AGENTS.md",+ PathStyle::Windows,+ )+ .unwrap();+ match parsed {+ MentionUri::File { abs_path } => {+ assert_eq!(+ abs_path,+ PathBuf::from("C:\\Projects\\Example Workspace\\AGENTS.md")+ );+ }+ other => panic!("Expected File variant, got {other:?}"),+ }+ }++ #[test]+ fn test_parse_windows_drive_path_with_leading_slash_and_fragment_line() {+ let parsed =+ MentionUri::parse_hyperlink("/C:/Projects/Cargo.toml#L4", PathStyle::Windows).unwrap();+ match parsed {+ MentionUri::Selection {+ abs_path: Some(abs_path),+ line_range,+ ..+ } => {+ assert_eq!(abs_path, PathBuf::from("C:\\Projects\\Cargo.toml"));+ assert_eq!(line_range, 3..=3);+ }+ other => panic!("Expected Selection variant, got {other:?}"),+ }+ }++ #[test]+ fn test_windows_drive_path_with_leading_slash_round_trips() {+ let parsed = MentionUri::parse_hyperlink("/C:/dir/file.rs", PathStyle::Windows).unwrap();+ assert_eq!(+ parsed,+ MentionUri::File {+ abs_path: PathBuf::from("C:\\dir\\file.rs")+ }+ );+ let uri = parsed.to_uri().to_string();+ assert_eq!(uri, "file:///C:/dir/file.rs");+ assert_eq!(MentionUri::parse(&uri, PathStyle::Windows).unwrap(), parsed);+ }++ #[test]+ fn test_parse_windows_unc_path() {+ let parsed =+ MentionUri::parse_hyperlink("//server/share/dir/file.rs", PathStyle::Windows).unwrap();+ match parsed {+ MentionUri::File { abs_path } => {+ assert_eq!(abs_path, PathBuf::from("\\\\server\\share\\dir\\file.rs"));+ }+ other => panic!("Expected File variant, got {other:?}"),+ }+ }++ #[test]+ fn test_parse_windows_drive_letters_are_uppercased() {+ for input in [+ "file:///c:/foo/bar.rs",+ "/c:/foo/bar.rs",+ "/c/foo/bar.rs",+ "c:\\foo\\bar.rs",+ "c:/foo/bar.rs",+ ] {+ let parsed = MentionUri::parse_hyperlink(input, PathStyle::Windows).unwrap();+ assert_eq!(+ parsed,+ MentionUri::File {+ abs_path: PathBuf::from("C:\\foo\\bar.rs")+ },+ "input: {input}"+ );+ }+ }++ #[test]+ fn test_msys_style_paths_require_lowercase_drive() {+ // Uppercase `/C/foo` is more likely a real directory than a drive.+ let parsed = MentionUri::parse_hyperlink("/C/Users/readme.md", PathStyle::Windows).unwrap();+ match parsed {+ MentionUri::File { abs_path } => {+ assert_eq!(abs_path, PathBuf::from("\\C\\Users\\readme.md"));+ }+ other => panic!("Expected File variant, got {other:?}"),+ }+ }++ #[test]+ fn test_posix_paths_are_not_rewritten_as_windows_drives() {+ let parsed =+ MentionUri::parse_hyperlink("/c/Projects/AGENTS.md", PathStyle::Posix).unwrap();+ match parsed {+ MentionUri::File { abs_path } => {+ assert_eq!(abs_path, PathBuf::from("/c/Projects/AGENTS.md"));+ }+ other => panic!("Expected File variant, got {other:?}"),+ }+ }++ #[test]+ fn test_hyperlink_percent_escapes_are_decoded() {+ let parsed = MentionUri::parse_hyperlink("/tmp/a%20b.rs", PathStyle::Posix).unwrap();+ assert_eq!(+ parsed,+ MentionUri::File {+ abs_path: PathBuf::from("/tmp/a b.rs")+ }+ );++ // Invalid escape sequences pass through unchanged.+ let parsed =+ MentionUri::parse_hyperlink("C:\\dir\\100%_done.txt", PathStyle::Windows).unwrap();+ assert_eq!(+ parsed,+ MentionUri::File {+ abs_path: PathBuf::from("C:\\dir\\100%_done.txt")+ }+ );++ // Separator escapes stay encoded (no introduced path traversal).+ let parsed = MentionUri::parse_hyperlink("/tmp/a%2Fb.rs", PathStyle::Posix).unwrap();+ assert_eq!(+ parsed,+ MentionUri::File {+ abs_path: PathBuf::from("/tmp/a%2Fb.rs")+ }+ );+ let parsed =+ MentionUri::parse_hyperlink("/tmp/..%2F..%2Fsecret", PathStyle::Posix).unwrap();+ assert_eq!(+ parsed,+ MentionUri::File {+ abs_path: PathBuf::from("/tmp/..%2F..%2Fsecret")+ }+ );+ }++ #[test]+ fn test_parse_keeps_bare_path_targets_verbatim() {+ let parsed = MentionUri::parse("/tmp/a%20b.rs", PathStyle::Posix).unwrap();+ assert_eq!(+ parsed,+ MentionUri::File {+ abs_path: PathBuf::from("/tmp/a%20b.rs")+ }+ );++ let parsed = MentionUri::parse("/c/Projects/AGENTS.md", PathStyle::Windows).unwrap();+ assert_eq!(+ parsed,+ MentionUri::File {+ abs_path: PathBuf::from("/c/Projects/AGENTS.md")+ }+ );+ }++ #[test]+ fn test_parse_hyperlink_literal_keeps_percent_escapes() {+ let literal =+ MentionUri::parse_hyperlink_literal("/tmp/a%20b.rs", PathStyle::Posix).unwrap();+ assert_eq!(+ literal,+ MentionUri::File {+ abs_path: PathBuf::from("/tmp/a%20b.rs")+ }+ );++ // Line suffixes still parse.+ let literal =+ MentionUri::parse_hyperlink_literal("/tmp/a%20b.rs:42", PathStyle::Posix).unwrap();+ assert_eq!(+ literal,+ MentionUri::Selection {+ abs_path: Some(PathBuf::from("/tmp/a%20b.rs")),+ line_range: 41..=41,+ column: None,+ }+ );++ // Windows normalization still applies.+ let literal =+ MentionUri::parse_hyperlink_literal("/C:/dir/a%20b.rs", PathStyle::Windows).unwrap();+ assert_eq!(+ literal,+ MentionUri::File {+ abs_path: PathBuf::from("C:\\dir\\a%20b.rs")+ }+ );+ }++ #[test]+ fn test_parse_hyperlink_literal_returns_none_when_unambiguous() {+ // No percent escapes: identical to `parse_hyperlink`.+ assert_eq!(+ MentionUri::parse_hyperlink_literal("/tmp/a b.rs", PathStyle::Posix),+ None+ );+ // Invalid escape sequences are also left alone by `parse_hyperlink`.+ assert_eq!(+ MentionUri::parse_hyperlink_literal("/tmp/100%_done.txt", PathStyle::Posix),+ None+ );+ // Separator escapes are never decoded, so they're not ambiguous.+ assert_eq!(+ MentionUri::parse_hyperlink_literal("/tmp/a%2Fb.rs", PathStyle::Posix),+ None+ );+ // URLs are spec-encoded, not ambiguous.+ assert_eq!(+ MentionUri::parse_hyperlink_literal("file:///tmp/a%20b.rs", PathStyle::Posix),+ None+ );+ // Relative paths are not bare-path mentions.+ assert_eq!(+ MentionUri::parse_hyperlink_literal("tmp/a%20b.rs", PathStyle::Posix),+ None+ );+ }+#[test]fn test_to_directory_uri_without_slash() {let uri = MentionUri::Directory {diff --git a/crates/agent/src/tools/find_path_tool.rs b/crates/agent/src/tools/find_path_tool.rsindex 481f1433fbf..eb08000d3a8 100644--- a/crates/agent/src/tools/find_path_tool.rs+++ b/crates/agent/src/tools/find_path_tool.rs@@ -1,4 +1,5 @@use crate::{AgentTool, ToolCallEventStream, ToolInput};+use acp_thread::MentionUri;use agent_client_protocol::schema::v1 as acp;use anyhow::{Result, anyhow};use futures::FutureExt as _;@@ -155,10 +156,13 @@ impl AgentTool for FindPathTool {paginated_matches.iter().map(|path| {+ let uri = MentionUri::File {+ abs_path: path.clone(),+ };acp::ToolCallContent::Content(acp::Content::new(acp::ContentBlock::ResourceLink(acp::ResourceLink::new(path.to_string_lossy(),- format!("file://{}", path.display()),+ uri.to_uri().to_string(),)),))})diff --git a/crates/agent/src/tools/grep_tool.rs b/crates/agent/src/tools/grep_tool.rsindex 748642b3cda..5af92b2e451 100644--- a/crates/agent/src/tools/grep_tool.rs+++ b/crates/agent/src/tools/grep_tool.rs@@ -1,4 +1,5 @@use crate::{AgentTool, ToolCallEventStream, ToolInput};+use acp_thread::MentionUri;use agent_client_protocol::schema::v1 as acp;use anyhow::Result;use futures::{FutureExt as _, StreamExt};@@ -327,10 +328,15 @@ impl AgentTool for GrepTool {output.push_str("\n```\n");if let Some(abs_path) = &abs_path {+ let uri = MentionUri::Selection {+ abs_path: Some(abs_path.clone()),+ line_range: range.start.row..=end_row,+ column: None,+ };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),+ uri.to_uri().to_string(),)),)));locations.push(@@ -393,6 +399,7 @@ mod tests {use project::{FakeFs, Project};use serde_json::json;use settings::SettingsStore;+ use std::path::PathBuf;use unindent::Unindent;use util::path;@@ -611,21 +618,30 @@ mod tests {.collect::<Vec<_>>();assert_eq!(links.len(), 2, "expected one resource link per match");- let alpha_uri = format!("file://{}#L1", path!("/root/src/alpha.txt"));+ let selection_uri = |abs_path: &str| {+ MentionUri::Selection {+ abs_path: Some(PathBuf::from(abs_path)),+ line_range: 0..=0,+ column: None,+ }+ .to_uri()+ .to_string()+ };++ let alpha_uri = selection_uri(path!("/root/src/alpha.txt"));assert!(links.iter().any(|link| {- link.name.replace('\\', "/") == "root/src/alpha.txt#L1"- && link.uri.replace('\\', "/") == alpha_uri.replace('\\', "/")+ link.name.replace('\\', "/") == "root/src/alpha.txt#L1" && link.uri == alpha_uri}),"missing clickable link for alpha.txt, got: {links:?}");- let beta_uri = format!("file://{}#L1", path!("/root/beta.txt"));+ let beta_uri = selection_uri(path!("/root/beta.txt"));assert!(- links.iter().any(|link| {- link.name.replace('\\', "/") == "root/beta.txt#L1"- && link.uri.replace('\\', "/") == beta_uri.replace('\\', "/")- }),+ links+ .iter()+ .any(|link| link.name.replace('\\', "/") == "root/beta.txt#L1"+ && link.uri == beta_uri),"missing clickable link for beta.txt, got: {links:?}");diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rsindex 1949a5965a8..ccaf59f72b0 100644--- a/crates/agent_ui/src/agent_ui.rs+++ b/crates/agent_ui/src/agent_ui.rs@@ -65,7 +65,7 @@ use serde::{Deserialize, Serialize};use settings::{LanguageModelSelection, Settings as _, SettingsStore, SidebarSide};use std::any::TypeId;use std::path::{Path, PathBuf};-use workspace::Workspace;+use workspace::{OpenOptions, Workspace};use crate::agent_configuration::ManageProfilesModal;pub use crate::agent_connection_store::{ActiveAcpConnection, AgentConnectionStore};@@ -118,40 +118,68 @@ pub(crate) fn resolve_agent_image(None}+/// Opens `abs_path` in the workspace, moving the cursor to `point` when one+/// is given. Paths outside every worktree are only opened when a file exists+/// there, so broken agent links don't create empty buffers.pub(crate) fn open_abs_path_at_point(workspace: &mut Workspace,abs_path: PathBuf,- point: Point,+ point: Option<Point>,window: &mut Window,cx: &mut Context<Workspace>,-) -> bool {- let project = workspace.project();- let Some(path) = project.update(cx, |project, cx| project.find_project_path(abs_path, cx))- else {- return false;- };-- let item = workspace.open_path(path, None, true, window, cx);+) {+ let project_path = workspace+ .project()+ .update(cx, |project, cx| project.find_project_path(&abs_path, cx));+ let fs = workspace.project().read(cx).fs().clone();+ let workspace = cx.weak_entity();window.spawn(cx, async move |cx| {- let Some(editor) = item.await?.downcast::<Editor>() else {+ let item = if let Some(project_path) = project_path {+ workspace+ .update_in(cx, |workspace, window, cx| {+ workspace.open_path(project_path, None, true, window, cx)+ })?+ .await?+ } else {+ let metadata = fs.metadata(&abs_path).await?;+ anyhow::ensure!(+ metadata.is_some_and(|metadata| !metadata.is_dir),+ "no file found at path {abs_path:?}"+ );+ workspace+ .update_in(cx, |workspace, window, cx| {+ workspace.open_abs_path(+ abs_path,+ OpenOptions {+ focus: Some(true),+ ..Default::default()+ },+ window,+ cx,+ )+ })?+ .await?+ };+ let Some(point) = point else {+ return Ok(());+ };+ let Some(editor) = item.downcast::<Editor>() else {return Ok(());};- let range = point..point;editor.update_in(cx, |editor, window, cx| {editor.change_selections(SelectionEffects::scroll(Autoscroll::center()),window,cx,- |selections| selections.select_ranges([range]),+ |selections| selections.select_ranges([point..point]),);}).ok();anyhow::Ok(())}).detach_and_log_err(cx);- true}pub const DEFAULT_THREAD_TITLE: &str = "New Agent Thread";diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rsindex 42a22219883..2d7c6b6ca40 100644--- a/crates/agent_ui/src/conversation_view/thread_view.rs+++ b/crates/agent_ui/src/conversation_view/thread_view.rs@@ -11931,19 +11931,31 @@ pub(crate) fn open_link(return;};- if let Some(mention) = MentionUri::parse(&url, workspace.read(cx).path_style(cx)).log_err() {+ let path_style = workspace.read(cx).path_style(cx);+ if let Some(mention) = MentionUri::parse_hyperlink(&url, path_style).log_err() {+ // Percent escapes in bare paths are ambiguous: prefer the decoded+ // interpretation, falling back to the literal one (e.g. a file+ // actually named `a%20b.rs`) only when the decoded path doesn't+ // resolve in the project but the literal one does.+ let resolves_in_project = |mention: &MentionUri, cx: &App| {+ mention.abs_path().is_some_and(|abs_path| {+ let project = workspace.read(cx).project().read(cx);+ project+ .find_project_path(abs_path, cx)+ .is_some_and(|path| project.entry_for_path(&path, cx).is_some())+ })+ };+ let mention = match MentionUri::parse_hyperlink_literal(&url, path_style) {+ Some(literal)+ if !resolves_in_project(&mention, cx) && resolves_in_project(&literal, cx) =>+ {+ literal+ }+ _ => mention,+ };workspace.update(cx, |workspace, cx| match mention {MentionUri::File { abs_path } => {- let project = workspace.project();- let Some(path) =- project.update(cx, |project, cx| project.find_project_path(abs_path, cx))- else {- return;- };-- workspace- .open_path(path, None, true, window, cx)- .detach_and_log_err(cx);+ open_abs_path_at_point(workspace, abs_path, None, window, cx);}MentionUri::PastedImage { .. } => {}MentionUri::Directory { abs_path } => {@@ -11967,7 +11979,7 @@ pub(crate) fn open_link(open_abs_path_at_point(workspace,path,- Point::new(*line_range.start(), 0),+ Some(Point::new(*line_range.start(), 0)),window,cx,);@@ -11980,7 +11992,7 @@ pub(crate) fn open_link(open_abs_path_at_point(workspace,path,- Point::new(*line_range.start(), column.unwrap_or(0)),+ Some(Point::new(*line_range.start(), column.unwrap_or(0))),window,cx,);@@ -12067,6 +12079,7 @@ mod tests {use super::*;use project::{FakeFs, Project};use serde_json::json;+ use std::path::Path;use util::path;use workspace::MultiWorkspace;@@ -12171,6 +12184,118 @@ mod tests {assert!(*active.path == *"src/main.rs");});}++ #[gpui::test]+ async fn test_open_link_percent_escape_disambiguation(cx: &mut gpui::TestAppContext) {+ crate::test_support::init_test(cx);++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree(+ path!("/project"),+ json!({+ "a%20b.rs": "literal",+ "a b.rs": "decoded",+ "c d.rs": "",+ "e%20f.rs": "",+ }),+ )+ .await;++ let project = Project::test(fs, [path!("/project").as_ref()], cx).await;+ let (multi_workspace, cx) =+ cx.add_window_view(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));+ let workspace = multi_workspace.read_with(cx, |mw, _| mw.workspace().clone());+ let workspace_weak = workspace.downgrade();++ let open_link_and_active_path = |url: String, cx: &mut gpui::VisualTestContext| {+ multi_workspace.update_in(cx, |_, window, cx| {+ open_link(url.into(), &workspace_weak, window, cx);+ });+ cx.run_until_parked();+ workspace.read_with(cx, |workspace, cx| {+ workspace+ .active_item(cx)+ .and_then(|item| item.project_path(cx))+ .expect("file should be open")+ .path+ })+ };++ // Both interpretations exist: the decoded one wins.+ let path = open_link_and_active_path(path!("/project/a%20b.rs").to_string(), cx);+ assert_eq!(*path, *"a b.rs");++ // Only the decoded file exists.+ let path = open_link_and_active_path(path!("/project/c%20d.rs").to_string(), cx);+ assert_eq!(*path, *"c d.rs");++ // Only the literally-named file exists: fall back to it.+ let path = open_link_and_active_path(path!("/project/e%20f.rs").to_string(), cx);+ assert_eq!(*path, *"e%20f.rs");+ }++ #[gpui::test]+ async fn test_open_link_out_of_project_path(cx: &mut gpui::TestAppContext) {+ crate::test_support::init_test(cx);++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree(path!("/project"), json!({"src": {"main.rs": ""}}))+ .await;+ fs.insert_tree(path!("/outside"), json!({"notes.md": "one\ntwo\nthree\n"}))+ .await;++ let project = Project::test(fs, [path!("/project").as_ref()], cx).await;+ let (multi_workspace, cx) =+ cx.add_window_view(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));+ let workspace = multi_workspace.read_with(cx, |mw, _| mw.workspace().clone());+ let workspace_weak = workspace.downgrade();++ // A nonexistent out-of-project path opens nothing, not even an+ // empty buffer.+ multi_workspace.update_in(cx, |_, window, cx| {+ open_link(+ path!("/outside/missing.md").to_string().into(),+ &workspace_weak,+ window,+ cx,+ );+ });+ cx.run_until_parked();+ workspace.read_with(cx, |workspace, cx| {+ assert!(+ workspace.active_item(cx).is_none(),+ "nothing should open for a nonexistent path"+ );+ });++ // An existing out-of-project file opens at the linked line.+ multi_workspace.update_in(cx, |_, window, cx| {+ open_link(+ format!("{}:2", path!("/outside/notes.md")).into(),+ &workspace_weak,+ window,+ cx,+ );+ });+ cx.run_until_parked();+ let editor = workspace.read_with(cx, |workspace, cx| {+ let item = workspace.active_item(cx).expect("file should be open");+ let project_path = item.project_path(cx).expect("item should have a path");+ let abs_path = workspace+ .project()+ .read(cx)+ .absolute_path(&project_path, cx);+ assert_eq!(+ abs_path.as_deref(),+ Some(Path::new(path!("/outside/notes.md")))+ );+ item.downcast::<Editor>().expect("should be an editor")+ });+ editor.update_in(cx, |editor, window, cx| {+ let snapshot = editor.snapshot(window, cx);+ assert_eq!(editor.selections.newest::<Point>(&snapshot).head().row, 1);+ });+ }}const FAST_MODE_WARNING_NAMESPACE: &str = "fast-mode-warning-dismissed";diff --git a/crates/agent_ui/src/ui/mention_crease.rs b/crates/agent_ui/src/ui/mention_crease.rsindex 97f45526cdc..6959b5bc4c0 100644--- a/crates/agent_ui/src/ui/mention_crease.rs+++ b/crates/agent_ui/src/ui/mention_crease.rs@@ -160,14 +160,14 @@ fn open_mention_uri(workspace.update(cx, |workspace, cx| match mention_uri {MentionUri::File { abs_path } => {- open_file(workspace, abs_path, None, window, cx);+ open_abs_path_at_point(workspace, abs_path, None, window, cx);}MentionUri::Symbol {abs_path,line_range,..} => {- open_file(+ open_abs_path_at_point(workspace,abs_path,Some(Point::new(*line_range.start(), 0)),@@ -180,7 +180,7 @@ fn open_mention_uri(line_range,column,} => {- open_file(+ open_abs_path_at_point(workspace,abs_path,Some(Point::new(*line_range.start(), column.unwrap_or(0))),@@ -339,41 +339,6 @@ fn open_skill_content_buffer(workspace.add_item(pane, Box::new(editor), None, true, true, window, cx);}-fn open_file(- workspace: &mut Workspace,- abs_path: PathBuf,- point: Option<Point>,- window: &mut Window,- cx: &mut Context<Workspace>,-) {- if let Some(point) = point {- if open_abs_path_at_point(workspace, abs_path.clone(), point, window, cx) {- return;- }- }-- let project = workspace.project();- if let Some(project_path) =- project.update(cx, |project, cx| project.find_project_path(&abs_path, cx))- {- workspace- .open_path(project_path, None, true, window, cx)- .detach_and_log_err(cx);- } else if abs_path.exists() {- workspace- .open_abs_path(- abs_path,- OpenOptions {- focus: Some(true),- ..Default::default()- },- window,- cx,- )- .detach_and_log_err(cx);- }-}-fn reveal_in_project_panel(workspace: &mut Workspace,abs_path: PathBuf,