Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
agent: LSP tools (#55744)
Cameron Mcloughlinf482f9e18c1d
diff --git a/assets/settings/default.json b/assets/settings/default.jsonindex cd2e164dfb0..624dcc0f012 100644--- a/assets/settings/default.json+++ b/assets/settings/default.json@@ -1108,13 +1108,18 @@"create_directory": true,"delete_path": true,"diagnostics": true,+ "apply_code_action": true,"edit_file": true,"fetch": true,+ "find_path": true,+ "find_references": true,+ "get_code_actions": true,+ "go_to_definition": true,"list_directory": true,"project_notifications": false,"move_path": true,"now": true,- "find_path": true,+ "rename_symbol": true,"read_file": true,"restore_file_from_disk": true,"save_file": true,@@ -1138,6 +1143,9 @@"project_notifications": false,"now": true,"find_path": true,+ "find_references": true,+ "get_code_actions": true,+ "go_to_definition": true,"read_file": true,"open": true,"grep": true,diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rsindex 308bc843b1a..c6979391673 100644--- a/crates/agent/src/thread.rs+++ b/crates/agent/src/thread.rs@@ -1,14 +1,15 @@use crate::{- ContextServerRegistry, CopyPathTool, CreateDirectoryTool, DbLanguageModel, DbThread,- DeletePathTool, DiagnosticsTool, EditFileTool, FetchTool, FindPathTool, GrepTool,- ListDirectoryTool, MovePathTool, NowTool, OpenTool, ProjectSnapshot, ReadFileTool,+ ApplyCodeActionTool, CodeActionStore, ContextServerRegistry, CopyPathTool, CreateDirectoryTool,+ DbLanguageModel, DbThread, DeletePathTool, DiagnosticsTool, EditFileTool, FetchTool,+ FindPathTool, FindReferencesTool, GetCodeActionsTool, GoToDefinitionTool, GrepTool,+ ListDirectoryTool, MovePathTool, NowTool, OpenTool, ProjectSnapshot, ReadFileTool, RenameTool,RestoreFileFromDiskTool, SaveFileTool, SpawnAgentTool, SystemPromptTemplate, Template,Templates, TerminalTool, ToolPermissionDecision, UpdatePlanTool, WebSearchTool,decide_permission_from_settings,};use acp_thread::{MentionUri, UserMessageId};use action_log::ActionLog;-use feature_flags::{FeatureFlagAppExt as _, UpdatePlanToolFeatureFlag};+use feature_flags::{FeatureFlagAppExt as _, LspToolFeatureFlag, UpdatePlanToolFeatureFlag};use agent_client_protocol::schema as acp;use agent_settings::{@@ -1542,7 +1543,6 @@ impl Thread {self.project.clone(),self.action_log.clone(),));- self.add_tool(DiagnosticsTool::new(self.project.clone()));self.add_tool(EditFileTool::new(self.project.clone(),cx.weak_entity(),@@ -1569,6 +1569,22 @@ impl Thread {self.add_tool(TerminalTool::new(self.project.clone(), environment.clone()));self.add_tool(WebSearchTool);+ self.add_tool(DiagnosticsTool::new(self.project.clone()));+ if cx.has_flag::<LspToolFeatureFlag>() {+ let code_action_store: CodeActionStore = cx.new(|_cx| None);+ self.add_tool(FindReferencesTool::new(self.project.clone()));+ self.add_tool(GetCodeActionsTool::new(+ self.project.clone(),+ code_action_store.clone(),+ ));+ self.add_tool(ApplyCodeActionTool::new(+ self.project.clone(),+ code_action_store,+ ));+ self.add_tool(GoToDefinitionTool::new(self.project.clone()));+ self.add_tool(RenameTool::new(self.project.clone()));+ }+if self.depth() < MAX_SUBAGENT_DEPTH {self.add_tool(SpawnAgentTool::new(environment));}diff --git a/crates/agent/src/tools.rs b/crates/agent/src/tools.rsindex b9db30ce432..e629f41e6d5 100644--- a/crates/agent/src/tools.rs+++ b/crates/agent/src/tools.rs@@ -1,3 +1,4 @@+mod apply_code_action_tool;mod context_server_registry;mod copy_path_tool;mod create_directory_tool;@@ -8,15 +9,20 @@ mod edit_file_tool;mod evals;mod fetch_tool;mod find_path_tool;+mod find_references_tool;+mod get_code_actions_tool;+mod go_to_definition_tool;mod grep_tool;mod list_directory_tool;mod move_path_tool;mod now_tool;mod open_tool;mod read_file_tool;+mod rename_tool;mod restore_file_from_disk_tool;mod save_file_tool;mod spawn_agent_tool;+mod symbol_locator;mod terminal_tool;mod tool_permissions;mod update_plan_tool;@@ -25,6 +31,7 @@ mod web_search_tool;use crate::AgentTool;use language_model::{LanguageModelRequestTool, LanguageModelToolSchemaFormat};+pub use apply_code_action_tool::*;pub use context_server_registry::*;pub use copy_path_tool::*;pub use create_directory_tool::*;@@ -33,15 +40,20 @@ pub use diagnostics_tool::*;pub use edit_file_tool::*;pub use fetch_tool::*;pub use find_path_tool::*;+pub use find_references_tool::*;+pub use get_code_actions_tool::*;+pub use go_to_definition_tool::*;pub use grep_tool::*;pub use list_directory_tool::*;pub use move_path_tool::*;pub use now_tool::*;pub use open_tool::*;pub use read_file_tool::*;+pub use rename_tool::*;pub use restore_file_from_disk_tool::*;pub use save_file_tool::*;pub use spawn_agent_tool::*;+pub use symbol_locator::*;pub use terminal_tool::*;pub use tool_permissions::*;pub use update_plan_tool::*;@@ -116,6 +128,7 @@ macro_rules! tools {}tools! {+ ApplyCodeActionTool,CopyPathTool,CreateDirectoryTool,DeletePathTool,@@ -123,12 +136,16 @@ tools! {EditFileTool,FetchTool,FindPathTool,+ FindReferencesTool,+ GetCodeActionsTool,+ GoToDefinitionTool,GrepTool,ListDirectoryTool,MovePathTool,NowTool,OpenTool,ReadFileTool,+ RenameTool,RestoreFileFromDiskTool,SaveFileTool,SpawnAgentTool,diff --git a/crates/agent/src/tools/apply_code_action_tool.rs b/crates/agent/src/tools/apply_code_action_tool.rsnew file mode 100644index 00000000000..409546d89d0--- /dev/null+++ b/crates/agent/src/tools/apply_code_action_tool.rs@@ -0,0 +1,145 @@+use std::fmt::Write;+use std::sync::Arc;++use agent_client_protocol::schema as acp;+use gpui::{App, Entity, SharedString, Task};+use project::Project;+use schemars::JsonSchema;+use serde::{Deserialize, Serialize};++use super::symbol_locator::CodeActionStore;+use crate::{AgentTool, ToolCallEventStream, ToolInput};++/// Applies a code action previously retrieved by get_code_actions.+///+/// You must call get_code_actions first to get the list of available actions,+/// then use the number from that list to choose which action to apply.+///+/// After applying a code action, the list is cleared. If you want to apply+/// another action, call get_code_actions again.+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]+pub struct ApplyCodeActionToolInput {+ /// The 1-based index of the code action to apply, from the list+ /// returned by get_code_actions.+ pub index: u32,+}++pub struct ApplyCodeActionTool {+ project: Entity<Project>,+ code_action_store: CodeActionStore,+}++impl ApplyCodeActionTool {+ pub fn new(project: Entity<Project>, code_action_store: CodeActionStore) -> Self {+ Self {+ project,+ code_action_store,+ }+ }+}++impl AgentTool for ApplyCodeActionTool {+ type Input = ApplyCodeActionToolInput;+ type Output = String;++ const NAME: &'static str = "apply_code_action";++ fn kind() -> acp::ToolKind {+ acp::ToolKind::Other+ }++ fn initial_title(+ &self,+ input: Result<Self::Input, serde_json::Value>,+ cx: &mut App,+ ) -> SharedString {+ if let Ok(input) = input {+ let title = self+ .code_action_store+ .read(cx)+ .as_ref()+ .and_then(|pending| {+ let index = input.index.checked_sub(1)? as usize;+ Some(pending.actions.get(index)?.lsp_action.title().to_string())+ });+ if let Some(title) = title {+ format!("Apply code action: {title}").into()+ } else {+ format!("Apply code action #{}", input.index).into()+ }+ } else {+ "Apply code action".into()+ }+ }++ fn run(+ self: Arc<Self>,+ input: ToolInput<Self::Input>,+ _event_stream: ToolCallEventStream,+ cx: &mut App,+ ) -> Task<Result<String, String>> {+ let project = self.project.clone();+ let store = self.code_action_store.clone();+ cx.spawn(async move |cx| {+ let input = input+ .recv()+ .await+ .map_err(|e| format!("Failed to receive tool input: {e}"))?;++ let pending = store.update(cx, |store, _cx| store.take()).ok_or_else(|| {+ "No code actions available. Call get_code_actions first.".to_string()+ })?;++ let zero_based_index = input+ .index+ .checked_sub(1)+ .ok_or_else(|| "Index must be 1 or greater.".to_string())?;++ let action = pending+ .actions+ .get(zero_based_index as usize)+ .cloned()+ .ok_or_else(|| {+ format!(+ "Index {} is out of range. There were {} code action(s) available.",+ input.index,+ pending.actions.len()+ )+ })?;++ let title = action.lsp_action.title().to_string();+ let buffer = pending.buffer.clone();++ let apply_task = project.update(cx, |project, cx| {+ project.apply_code_action(buffer, action, true, cx)+ });++ let transaction = apply_task+ .await+ .map_err(|e| format!("Failed to apply code action '{title}': {e}"))?;++ if transaction.0.is_empty() {+ return Ok(format!(+ "Code action '{title}' was applied but made no changes.",+ ));+ }++ let mut output = format!(+ "Applied code action '{title}'. Modified {} file(s):\n",+ transaction.0.len()+ );++ for (buffer, _) in &transaction.0 {+ buffer.read_with(cx, |buffer, cx| {+ let path = buffer+ .file()+ .map(|f| f.full_path(cx).display().to_string())+ .unwrap_or_else(|| "<untitled>".to_string());+ writeln!(output, "- {path}").ok();+ });+ }++ Ok(output)+ })+ }+}diff --git a/crates/agent/src/tools/find_references_tool.rs b/crates/agent/src/tools/find_references_tool.rsnew file mode 100644index 00000000000..f829e150464--- /dev/null+++ b/crates/agent/src/tools/find_references_tool.rs@@ -0,0 +1,104 @@+use std::fmt::Write;+use std::sync::Arc;++use super::symbol_locator::{LocationDisplay, SymbolLocator};+use crate::{AgentTool, ToolCallEventStream, ToolInput};+use agent_client_protocol::schema as acp;+use gpui::{App, Entity, SharedString, Task};+use project::Project;+use schemars::JsonSchema;+use serde::{Deserialize, Serialize};++/// Finds all references to a symbol across the project using the language server.+///+/// Returns a list of locations where the symbol is referenced, including file paths,+/// line numbers, and code snippets for each reference.+///+/// Before using this tool, use read_file or grep to find the exact symbol+/// name and line number.+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]+pub struct FindReferencesToolInput {+ /// The symbol to find references of.+ pub symbol: SymbolLocator,+}++pub struct FindReferencesTool {+ project: Entity<Project>,+}++impl FindReferencesTool {+ pub fn new(project: Entity<Project>) -> Self {+ Self { project }+ }+}++impl AgentTool for FindReferencesTool {+ type Input = FindReferencesToolInput;+ type Output = String;++ const NAME: &'static str = "find_references";++ fn kind() -> acp::ToolKind {+ acp::ToolKind::Search+ }++ fn initial_title(+ &self,+ input: Result<Self::Input, serde_json::Value>,+ _cx: &mut App,+ ) -> SharedString {+ if let Ok(input) = input {+ format!("Find references to `{}`", input.symbol.symbol_name).into()+ } else {+ "Find references".into()+ }+ }++ fn run(+ self: Arc<Self>,+ input: ToolInput<Self::Input>,+ _event_stream: ToolCallEventStream,+ cx: &mut App,+ ) -> Task<Result<String, String>> {+ let project = self.project.clone();+ cx.spawn(async move |cx| {+ let input = input+ .recv()+ .await+ .map_err(|e| format!("Failed to receive tool input: {e}"))?;++ let resolved = input.symbol.resolve(&project, cx).await?;++ let references_task = project.update(cx, |project, cx| {+ project.references(&resolved.buffer, resolved.position, cx)+ });++ let references = references_task+ .await+ .map_err(|e| format!("Find references failed: {e}"))?+ .unwrap_or_default();++ if references.is_empty() {+ return Ok(format!(+ "No references found for '{}'.",+ input.symbol.symbol_name+ ));+ }++ let mut output = format!(+ "Found {} references to `{}`:\n",+ references.len(),+ input.symbol.symbol_name+ );++ for location in &references {+ let display = location+ .buffer+ .read_with(cx, |_, cx| LocationDisplay::from_location(location, cx));+ write!(output, "\n## {display}\n").ok();+ }++ Ok(output)+ })+ }+}diff --git a/crates/agent/src/tools/get_code_actions_tool.rs b/crates/agent/src/tools/get_code_actions_tool.rsnew file mode 100644index 00000000000..7f4fc81ec3f--- /dev/null+++ b/crates/agent/src/tools/get_code_actions_tool.rs@@ -0,0 +1,119 @@+use std::fmt::Write;+use std::sync::Arc;++use agent_client_protocol::schema as acp;+use gpui::{App, Entity, SharedString, Task};+use project::Project;+use schemars::JsonSchema;+use serde::{Deserialize, Serialize};++use super::symbol_locator::{CodeActionStore, PendingCodeActions, SymbolLocator};+use crate::{AgentTool, ToolCallEventStream, ToolInput};++/// Gets the list of available code actions at a symbol location from the language server.+///+/// Code actions include quick fixes, refactorings, and other automated transformations+/// suggested by the language server (e.g. "Add missing import", "Extract to function").+///+/// Returns a numbered list of available actions. Use apply_code_action with the+/// corresponding number to apply one.+///+/// Before using this tool, use read_file or grep to find the exact symbol+/// name and line number.+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]+pub struct GetCodeActionsToolInput {+ /// The symbol to get code actions for.+ pub symbol: SymbolLocator,+}++pub struct GetCodeActionsTool {+ project: Entity<Project>,+ code_action_store: CodeActionStore,+}++impl GetCodeActionsTool {+ pub fn new(project: Entity<Project>, code_action_store: CodeActionStore) -> Self {+ Self {+ project,+ code_action_store,+ }+ }+}++impl AgentTool for GetCodeActionsTool {+ type Input = GetCodeActionsToolInput;+ type Output = String;++ const NAME: &'static str = "get_code_actions";++ fn kind() -> acp::ToolKind {+ acp::ToolKind::Search+ }++ fn initial_title(+ &self,+ input: Result<Self::Input, serde_json::Value>,+ _cx: &mut App,+ ) -> SharedString {+ if let Ok(input) = input {+ format!("Get code actions for `{}`", input.symbol.symbol_name).into()+ } else {+ "Get code actions".into()+ }+ }++ fn run(+ self: Arc<Self>,+ input: ToolInput<Self::Input>,+ _event_stream: ToolCallEventStream,+ cx: &mut App,+ ) -> Task<Result<String, String>> {+ let project = self.project.clone();+ let store = self.code_action_store.clone();+ cx.spawn(async move |cx| {+ let input = input+ .recv()+ .await+ .map_err(|e| format!("Failed to receive tool input: {e}"))?;++ let resolved = input.symbol.resolve(&project, cx).await?;++ let actions_task = project.update(cx, |project, cx| {+ let range = resolved.position..resolved.position;+ project.code_actions(&resolved.buffer, range, None, cx)+ });++ let actions = actions_task+ .await+ .map_err(|e| format!("Failed to get code actions: {e}"))?+ .unwrap_or_default();++ if actions.is_empty() {+ store.update(cx, |store, _cx| *store = None);+ return Ok(format!(+ "No code actions available for '{}' at this location.",+ input.symbol.symbol_name+ ));+ }++ let mut output = format!("Found {} code action(s):\n", actions.len());+ for (i, action) in actions.iter().enumerate() {+ writeln!(output, "{}. {}", i + 1, action.lsp_action.title()).ok();+ }+ write!(+ output,+ "\nUse apply_code_action with the number of the action you want to apply."+ )+ .ok();++ store.update(cx, |store, _cx| {+ *store = Some(PendingCodeActions {+ actions,+ buffer: resolved.buffer,+ });+ });++ Ok(output)+ })+ }+}diff --git a/crates/agent/src/tools/go_to_definition_tool.rs b/crates/agent/src/tools/go_to_definition_tool.rsnew file mode 100644index 00000000000..2061da124b0--- /dev/null+++ b/crates/agent/src/tools/go_to_definition_tool.rs@@ -0,0 +1,113 @@+use std::fmt::Write;+use std::sync::Arc;++use super::symbol_locator::{LocationDisplay, SymbolLocator};+use crate::{AgentTool, ToolCallEventStream, ToolInput};+use agent_client_protocol::schema as acp;+use gpui::{App, Entity, SharedString, Task};+use project::Project;+use schemars::JsonSchema;+use serde::{Deserialize, Serialize};++/// Jumps to the definition of a symbol using the language server.+///+/// Returns the file path and line number of the symbol's definition,+/// along with a snippet of the source code at that location.+///+/// Before using this tool, use read_file or grep to find the exact symbol+/// name and line number of a usage you want to navigate from.+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]+pub struct GoToDefinitionToolInput {+ /// The symbol to find the definition of.+ pub symbol: SymbolLocator,+}++pub struct GoToDefinitionTool {+ project: Entity<Project>,+}++impl GoToDefinitionTool {+ pub fn new(project: Entity<Project>) -> Self {+ Self { project }+ }+}++impl AgentTool for GoToDefinitionTool {+ type Input = GoToDefinitionToolInput;+ type Output = String;++ const NAME: &'static str = "go_to_definition";++ fn kind() -> acp::ToolKind {+ acp::ToolKind::Search+ }++ fn initial_title(+ &self,+ input: Result<Self::Input, serde_json::Value>,+ _cx: &mut App,+ ) -> SharedString {+ if let Ok(input) = input {+ format!("Go to definition of `{}`", input.symbol.symbol_name).into()+ } else {+ "Go to definition".into()+ }+ }++ fn run(+ self: Arc<Self>,+ input: ToolInput<Self::Input>,+ _event_stream: ToolCallEventStream,+ cx: &mut App,+ ) -> Task<Result<String, String>> {+ let project = self.project.clone();+ cx.spawn(async move |cx| {+ let input = input+ .recv()+ .await+ .map_err(|e| format!("Failed to receive tool input: {e}"))?;++ let resolved = input.symbol.resolve(&project, cx).await?;++ let definitions_task = project.update(cx, |project, cx| {+ project.definitions(&resolved.buffer, resolved.position, cx)+ });++ let definitions = definitions_task+ .await+ .map_err(|e| format!("Go to definition failed: {e}"))?+ .unwrap_or_default();++ if definitions.is_empty() {+ return Ok(format!(+ "No definition found for '{}'.",+ input.symbol.symbol_name+ ));+ }++ let mut output = String::new();++ if definitions.len() == 1 {+ write!(output, "Definition of `{}`:\n", input.symbol.symbol_name).ok();+ } else {+ write!(+ output,+ "Found {} definitions of `{}`:\n",+ definitions.len(),+ input.symbol.symbol_name+ )+ .ok();+ }++ for link in &definitions {+ let display = link+ .target+ .buffer+ .read_with(cx, |_, cx| LocationDisplay::from_location(&link.target, cx));+ write!(output, "\n## {display}\n").ok();+ }++ Ok(output)+ })+ }+}diff --git a/crates/agent/src/tools/rename_tool.rs b/crates/agent/src/tools/rename_tool.rsnew file mode 100644index 00000000000..7abc45d6956--- /dev/null+++ b/crates/agent/src/tools/rename_tool.rs@@ -0,0 +1,121 @@+use std::fmt::Write;+use std::sync::Arc;++use agent_client_protocol::schema as acp;+use gpui::{App, Entity, SharedString, Task};+use project::Project;+use schemars::JsonSchema;+use serde::{Deserialize, Serialize};++use super::symbol_locator::SymbolLocator;+use crate::{AgentTool, ToolCallEventStream, ToolInput};++/// Renames a symbol across the project using the language server.+///+/// This performs a semantic rename, updating all references to the symbol+/// across all files in the project. The language server determines which+/// occurrences to rename based on the symbol's type and scope.+///+/// Before using this tool, use read_file or grep to find the exact symbol+/// name and line number.+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]+pub struct RenameToolInput {+ /// The symbol to rename.+ pub symbol: SymbolLocator,++ /// The new name for the symbol.+ pub new_name: String,+}++pub struct RenameTool {+ project: Entity<Project>,+}++impl RenameTool {+ pub fn new(project: Entity<Project>) -> Self {+ Self { project }+ }+}++impl AgentTool for RenameTool {+ type Input = RenameToolInput;+ type Output = String;++ const NAME: &'static str = "rename_symbol";++ fn kind() -> acp::ToolKind {+ acp::ToolKind::Other+ }++ fn initial_title(+ &self,+ input: Result<Self::Input, serde_json::Value>,+ _cx: &mut App,+ ) -> SharedString {+ if let Ok(input) = input {+ format!(+ "Rename `{}` to `{}`",+ input.symbol.symbol_name, input.new_name+ )+ .into()+ } else {+ "Rename symbol".into()+ }+ }++ fn run(+ self: Arc<Self>,+ input: ToolInput<Self::Input>,+ _event_stream: ToolCallEventStream,+ cx: &mut App,+ ) -> Task<Result<String, String>> {+ let project = self.project.clone();+ cx.spawn(async move |cx| {+ let input = input+ .recv()+ .await+ .map_err(|e| format!("Failed to receive tool input: {e}"))?;++ let resolved = input.symbol.resolve(&project, cx).await?;++ let rename_task = project.update(cx, |project, cx| {+ project.perform_rename(+ resolved.buffer.clone(),+ resolved.position,+ input.new_name.clone(),+ cx,+ )+ });++ let transaction = rename_task+ .await+ .map_err(|e| format!("Rename failed: {e}"))?;++ if transaction.0.is_empty() {+ return Ok(format!(+ "No changes were made. The language server could not rename '{}'.",+ input.symbol.symbol_name+ ));+ }++ let mut output = format!(+ "Renamed `{}` to `{}` in {} file(s):\n",+ input.symbol.symbol_name,+ input.new_name,+ transaction.0.len()+ );++ for (buffer, _) in &transaction.0 {+ buffer.read_with(cx, |buffer, cx| {+ let path = buffer+ .file()+ .map(|f| f.full_path(cx).display().to_string())+ .unwrap_or_else(|| "<untitled>".to_string());+ writeln!(output, "- {path}").ok();+ });+ }++ Ok(output)+ })+ }+}diff --git a/crates/agent/src/tools/symbol_locator.rs b/crates/agent/src/tools/symbol_locator.rsnew file mode 100644index 00000000000..cb38101877e--- /dev/null+++ b/crates/agent/src/tools/symbol_locator.rs@@ -0,0 +1,239 @@+use std::collections::VecDeque;+use std::fmt;++use gpui::{App, AsyncApp, Entity};+use language::{Buffer, Location};+use project::{CodeAction, Project};+use schemars::JsonSchema;+use serde::{Deserialize, Serialize};+use text::ToPoint as _;+use text::{Anchor, Point};++/// Identifies a specific symbol (declaration or usage) in the source code.+///+/// Use the file path, line number, and symbol name from file outlines, grep results,+/// or other tool outputs to populate these fields.+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]+pub struct SymbolLocator {+ /// The relative path of the file containing the symbol+ /// (e.g. "crates/editor/src/editor.rs").+ pub file_path: String,++ /// The 1-based line number where the symbol appears.+ /// Use the line numbers from file outlines or grep results.+ pub line: u32,++ /// The name of the symbol (function name, type name, variable name, etc.)+ pub symbol_name: String,+}++pub struct PendingCodeActions {+ pub actions: Vec<CodeAction>,+ pub buffer: Entity<Buffer>,+}++pub type CodeActionStore = Entity<Option<PendingCodeActions>>;++pub struct ResolvedSymbol {+ pub buffer: Entity<Buffer>,+ pub position: Anchor,+ pub line_text: String,+ pub truncated: bool,+}++pub const MAX_LINE_DISPLAY_LEN: usize = 200;++pub struct LocationDisplay {+ pub path: String,+ pub start_line: u32,+ pub end_line: u32,+ pub snippet: String,+ pub truncated: bool,+}++impl LocationDisplay {+ pub fn from_location(location: &Location, cx: &App) -> Self {+ let snapshot = location.buffer.read(cx).snapshot();+ let range =+ location.range.start.to_point(&snapshot)..location.range.end.to_point(&snapshot);+ let path = location+ .buffer+ .read(cx)+ .file()+ .map(|f| f.full_path(cx).display().to_string())+ .unwrap_or_else(|| "<untitled>".to_string());++ let start_line = range.start.row + 1;+ let end_line = range.end.row + 1;++ let line_len = snapshot.line_len(range.start.row);+ let truncated = line_len as usize > MAX_LINE_DISPLAY_LEN;+ let snippet: String = snapshot+ .text_for_range(Point::new(range.start.row, 0)..Point::new(range.start.row, line_len))+ .flat_map(|chunk| chunk.chars())+ .skip_while(|c| c.is_whitespace())+ .take(MAX_LINE_DISPLAY_LEN)+ .collect::<String>();+ let snippet = snippet.trim_end().to_string();++ Self {+ path,+ start_line,+ end_line,+ snippet,+ truncated,+ }+ }+}++impl fmt::Display for LocationDisplay {+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ let truncated_label = if self.truncated { " (truncated)" } else { "" };+ if self.start_line == self.end_line {+ writeln!(f, "{}#L{}{truncated_label}", self.path, self.start_line)?;+ } else {+ writeln!(+ f,+ "{}#L{}-{}{truncated_label}",+ self.path, self.start_line, self.end_line+ )?;+ }+ writeln!(f, "```")?;+ writeln!(f, "{}", self.snippet)?;+ write!(f, "```")+ }+}++/// Searches for `needle` in a char iterator, returning the byte offset of the+/// first occurrence without collecting the full iterator into a string.+///+/// Equivalent to [`str::find`]+fn find_in_char_iter(chars: impl Iterator<Item = char>, needle: &str) -> Option<usize> {+ let needle_chars: Vec<char> = needle.chars().collect();+ if needle_chars.is_empty() {+ return Some(0);+ }++ let mut window: VecDeque<char> = VecDeque::with_capacity(needle_chars.len());+ let mut byte_offsets: VecDeque<usize> = VecDeque::with_capacity(needle_chars.len());+ let mut byte_offset = 0usize;++ for ch in chars {+ window.push_back(ch);+ byte_offsets.push_back(byte_offset);+ byte_offset += ch.len_utf8();++ if window.len() > needle_chars.len() {+ window.pop_front();+ byte_offsets.pop_front();+ }++ if window.len() == needle_chars.len()+ && window.iter().zip(needle_chars.iter()).all(|(a, b)| a == b)+ {+ return byte_offsets.front().copied();+ }+ }++ None+}++impl SymbolLocator {+ /// Resolves this locator into a concrete buffer and position.+ ///+ /// Opens the file at `file_path`, then searches for `symbol_name` on the+ /// specified `line`. Returns an error if the file can't be found, the line+ /// is out of range, or the symbol name doesn't appear on that line.+ /// If the symbol name appears multiple times on the line, uses the first+ /// occurrence.+ pub async fn resolve(+ &self,+ project: &Entity<Project>,+ cx: &mut AsyncApp,+ ) -> Result<ResolvedSymbol, String> {+ let Self {+ file_path,+ line,+ symbol_name,+ } = self;++ let open_buffer_task = project.update(cx, |project, cx| {+ let Some(project_path) = project.find_project_path(file_path, cx) else {+ return Err(format!("Could not find path '{file_path}' in project",));+ };+ Ok(project.open_buffer(project_path, cx))+ })?;++ let buffer = open_buffer_task+ .await+ .map_err(|e| format!("Failed to open '{}': {e}", self.file_path))?;++ let (position, line_text, truncated) = buffer.read_with(cx, |buffer, _cx| {+ let snapshot = buffer.snapshot();+ let row = line.saturating_sub(1);++ if row > snapshot.max_point().row {+ let line_count = snapshot.max_point().row + 1;+ return Err(format!(+ "Line {line} is beyond the end of '{file_path}' (file has {line_count} lines)",+ ));+ }++ let line_len = snapshot.line_len(row);+ let truncated = line_len as usize > MAX_LINE_DISPLAY_LEN;+ let line_start = Point::new(row, 0);+ let line_end = Point::new(row, line_len);+ let line_chars = || {+ snapshot+ .text_for_range(line_start..line_end)+ .flat_map(|chunk| chunk.chars())+ };++ let byte_offset = find_in_char_iter(line_chars(), symbol_name).ok_or_else(|| {+ let preview: String = line_chars()+ .skip_while(|c| c.is_whitespace())+ .take(MAX_LINE_DISPLAY_LEN)+ .collect();+ format!(+ "Symbol '{symbol_name}' not found on line {line} of '{file_path}'. \+ Line content: '{}'",+ preview.trim_end()+ )+ })?;++ let position = snapshot.anchor_before(Point::new(row, byte_offset as u32));+ let display_text: String = line_chars()+ .skip_while(|c| c.is_whitespace())+ .take(MAX_LINE_DISPLAY_LEN)+ .collect::<String>();+ let display_text = display_text.trim_end().to_string();++ Ok((position, display_text, truncated))+ })?;++ Ok(ResolvedSymbol {+ buffer,+ position,+ line_text,+ truncated,+ })+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use gpui::proptest::prelude::*;++ #[gpui::property_test]+ fn find_in_char_iter_test(+ // limited character sets to increase odds of finding matches+ #[strategy = "[abcd]{100,1000}"] haystack: String,+ #[strategy = "[abcd]{1,5}"] needle: String,+ ) -> Result<(), TestCaseError> {+ let expected = haystack.find(&needle);+ let actual = find_in_char_iter(haystack.chars(), &needle);+ prop_assert_eq!(actual, expected);+ Ok::<_, TestCaseError>(())+ }+}diff --git a/crates/feature_flags/src/flags.rs b/crates/feature_flags/src/flags.rsindex 56e3d135d9e..d9af542efea 100644--- a/crates/feature_flags/src/flags.rs+++ b/crates/feature_flags/src/flags.rs@@ -59,6 +59,18 @@ impl FeatureFlag for UpdatePlanToolFeatureFlag {}register_feature_flag!(UpdatePlanToolFeatureFlag);+pub struct LspToolFeatureFlag;++impl FeatureFlag for LspToolFeatureFlag {+ const NAME: &'static str = "lsp-tool";+ type Value = PresenceFlag;++ fn enabled_for_staff() -> bool {+ false+ }+}+register_feature_flag!(LspToolFeatureFlag);+pub struct ProjectPanelUndoRedoFeatureFlag;impl FeatureFlag for ProjectPanelUndoRedoFeatureFlag {diff --git a/crates/gpui/src/test.rs b/crates/gpui/src/test.rsindex 9f224871330..a93424edeab 100644--- a/crates/gpui/src/test.rs+++ b/crates/gpui/src/test.rs@@ -71,16 +71,20 @@ pub fn apply_seed_to_proptest_config(////// Doesn't support many features of [`run_test`], since these are provided by/// proptest.-pub fn run_test_once(seed: u64, test_fn: Box<dyn UnwindSafe + FnOnce(TestDispatcher)>) {+pub fn run_test_once<R>(+ seed: u64,+ test_fn: Box<dyn UnwindSafe + FnOnce(TestDispatcher) -> R>,+) -> R {let result = panic::catch_unwind(|| {let dispatcher = TestDispatcher::new(seed);let scheduler = dispatcher.scheduler().clone();- test_fn(dispatcher);+ let res = test_fn(dispatcher);scheduler.end_test();+ res});match result {- Ok(()) => {}+ Ok(r) => r,Err(e) => panic::resume_unwind(e),}}diff --git a/crates/settings_ui/src/pages/tool_permissions_setup.rs b/crates/settings_ui/src/pages/tool_permissions_setup.rsindex e6b49dd6c8a..12693cb99d9 100644--- a/crates/settings_ui/src/pages/tool_permissions_setup.rs+++ b/crates/settings_ui/src/pages/tool_permissions_setup.rs@@ -1407,13 +1407,18 @@ mod tests {// 2. Add it to this list with a comment explaining why it's excluded.const EXCLUDED_TOOLS: &[&str] = &[// Read-only / low-risk tools that don't call decide_permission_from_settings+ "apply_code_action","diagnostics","find_path",+ "find_references",+ "get_code_actions",+ "go_to_definition","grep","list_directory","now","open","read_file",+ "rename_symbol","thinking",// streaming_edit_file uses "edit_file" for permission lookups,// so its rules are configured under the edit_file entry.