From 6f60939d301ae08e0dd384154a0a325dfa409f43 Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Wed, 16 Jul 2025 14:48:50 -0400 Subject: [PATCH 0001/1052] Bump Zed to v0.197 (#34569) Release Notes: -N/A --- Cargo.lock | 2 +- crates/zed/Cargo.toml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 3950871688..b1b3ec32c8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -20095,7 +20095,7 @@ dependencies = [ [[package]] name = "zed" -version = "0.196.0" +version = "0.197.0" dependencies = [ "activity_indicator", "agent", diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml index 3af1709b74..ae96a48b53 100644 --- a/crates/zed/Cargo.toml +++ b/crates/zed/Cargo.toml @@ -2,7 +2,7 @@ description = "The fast, collaborative code editor." edition.workspace = true name = "zed" -version = "0.196.0" +version = "0.197.0" publish.workspace = true license = "GPL-3.0-or-later" authors = ["Zed Team "] From 0bde929d548dc2f0733d8a33449067c642737d44 Mon Sep 17 00:00:00 2001 From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com> Date: Wed, 16 Jul 2025 15:50:53 -0400 Subject: [PATCH 0002/1052] Add keymap editor UI telemetry events (#34571) - Search queries - Keybinding update or removed - Copy action name - Copy context name cc @katie-z-geer Release Notes: - N/A Co-authored-by: Ben Kunkle --- Cargo.lock | 1 + crates/settings/src/keymap_file.rs | 52 +++++++++++++++++ crates/settings_ui/Cargo.toml | 1 + crates/settings_ui/src/keybindings.rs | 81 ++++++++++++++++++++++++++- 4 files changed, 132 insertions(+), 3 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index b1b3ec32c8..091b944169 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -14720,6 +14720,7 @@ dependencies = [ "serde", "serde_json", "settings", + "telemetry", "theme", "tree-sitter-json", "tree-sitter-rust", diff --git a/crates/settings/src/keymap_file.rs b/crates/settings/src/keymap_file.rs index d738e30c4f..e6a32f731b 100644 --- a/crates/settings/src/keymap_file.rs +++ b/crates/settings/src/keymap_file.rs @@ -847,6 +847,7 @@ impl KeymapFile { } } +#[derive(Clone)] pub enum KeybindUpdateOperation<'a> { Replace { /// Describes the keybind to create @@ -865,6 +866,47 @@ pub enum KeybindUpdateOperation<'a> { }, } +impl KeybindUpdateOperation<'_> { + pub fn generate_telemetry( + &self, + ) -> ( + // The keybind that is created + String, + // The keybinding that was removed + String, + // The source of the keybinding + String, + ) { + let (new_binding, removed_binding, source) = match &self { + KeybindUpdateOperation::Replace { + source, + target, + target_keybind_source, + } => (Some(source), Some(target), Some(*target_keybind_source)), + KeybindUpdateOperation::Add { source, .. } => (Some(source), None, None), + KeybindUpdateOperation::Remove { + target, + target_keybind_source, + } => (None, Some(target), Some(*target_keybind_source)), + }; + + let new_binding = new_binding + .map(KeybindUpdateTarget::telemetry_string) + .unwrap_or("null".to_owned()); + let removed_binding = removed_binding + .map(KeybindUpdateTarget::telemetry_string) + .unwrap_or("null".to_owned()); + + let source = source + .as_ref() + .map(KeybindSource::name) + .map(ToOwned::to_owned) + .unwrap_or("null".to_owned()); + + (new_binding, removed_binding, source) + } +} + impl<'a> KeybindUpdateOperation<'a> { pub fn add(source: KeybindUpdateTarget<'a>) -> Self { Self::Add { source, from: None } @@ -905,6 +947,16 @@ impl<'a> KeybindUpdateTarget<'a> { keystrokes.pop(); keystrokes } + + fn telemetry_string(&self) -> String { + format!( + "action_name: {}, context: {}, action_arguments: {}, keystrokes: {}", + self.action_name, + self.context.unwrap_or("global"), + self.action_arguments.unwrap_or("none"), + self.keystrokes_unparsed() + ) + } } #[derive(Clone, Copy, PartialEq, Eq)] diff --git a/crates/settings_ui/Cargo.toml b/crates/settings_ui/Cargo.toml index 4502d994e7..e512c4e4d4 100644 --- a/crates/settings_ui/Cargo.toml +++ b/crates/settings_ui/Cargo.toml @@ -34,6 +34,7 @@ search.workspace = true serde.workspace = true serde_json.workspace = true settings.workspace = true +telemetry.workspace = true theme.workspace = true tree-sitter-json.workspace = true tree-sitter-rust.workspace = true diff --git a/crates/settings_ui/src/keybindings.rs b/crates/settings_ui/src/keybindings.rs index 78636f7023..e0105fa875 100644 --- a/crates/settings_ui/src/keybindings.rs +++ b/crates/settings_ui/src/keybindings.rs @@ -1,6 +1,7 @@ use std::{ ops::{Not as _, Range}, sync::Arc, + time::Duration, }; use anyhow::{Context as _, anyhow}; @@ -12,7 +13,7 @@ use gpui::{ Action, Animation, AnimationExt, AppContext as _, AsyncApp, Axis, ClickEvent, Context, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, FontWeight, Global, IsZero, KeyContext, Keystroke, Modifiers, ModifiersChangedEvent, MouseButton, Point, ScrollStrategy, - ScrollWheelEvent, StyledText, Subscription, WeakEntity, actions, anchored, deferred, div, + ScrollWheelEvent, StyledText, Subscription, Task, WeakEntity, actions, anchored, deferred, div, }; use language::{Language, LanguageConfig, ToOffset as _}; use notifications::status_toast::{StatusToast, ToastIcon}; @@ -151,6 +152,13 @@ impl SearchMode { SearchMode::KeyStroke { .. } => SearchMode::Normal, } } + + fn exact_match(&self) -> bool { + match self { + SearchMode::Normal => false, + SearchMode::KeyStroke { exact_match } => *exact_match, + } + } } #[derive(Default, PartialEq, Copy, Clone)] @@ -249,6 +257,7 @@ struct KeymapEditor { keybinding_conflict_state: ConflictState, filter_state: FilterState, search_mode: SearchMode, + search_query_debounce: Option>, // corresponds 1 to 1 with keybindings string_match_candidates: Arc>, matches: Vec, @@ -347,6 +356,7 @@ impl KeymapEditor { context_menu: None, previous_edit: None, humanized_action_names, + search_query_debounce: None, }; this.on_keymap_changed(cx); @@ -371,10 +381,32 @@ impl KeymapEditor { } } - fn on_query_changed(&self, cx: &mut Context) { + fn on_query_changed(&mut self, cx: &mut Context) { let action_query = self.current_action_query(cx); let keystroke_query = self.current_keystroke_query(cx); + let exact_match = self.search_mode.exact_match(); + let timer = cx.background_executor().timer(Duration::from_secs(1)); + self.search_query_debounce = Some(cx.background_spawn({ + let action_query = action_query.clone(); + let keystroke_query = keystroke_query.clone(); + async move { + timer.await; + + let keystroke_query = keystroke_query + .into_iter() + .map(|keystroke| keystroke.unparse()) + .collect::>() + .join(" "); + + telemetry::event!( + "Keystroke Search Completed", + action_query = action_query, + keystroke_query = keystroke_query, + keystroke_exact_match = exact_match + ) + } + })); cx.spawn(async move |this, cx| { Self::update_matches(this.clone(), action_query, keystroke_query, cx).await?; this.update(cx, |this, cx| { @@ -474,6 +506,7 @@ impl KeymapEditor { } this.selected_index.take(); this.matches = matches; + cx.notify(); }) } @@ -864,6 +897,26 @@ impl KeymapEditor { return; }; let keymap_editor = cx.entity(); + + let arguments = keybind + .action_arguments + .as_ref() + .map(|arguments| arguments.text.clone()); + let context = keybind + .context + .as_ref() + .map(|context| context.local_str().unwrap_or("global")); + let source = keybind.source.as_ref().map(|source| source.1.clone()); + + telemetry::event!( + "Edit Keybinding Modal Opened", + keystroke = keybind.keystroke_text, + action = keybind.action_name, + source = source, + context = context, + arguments = arguments, + ); + self.workspace .update(cx, |workspace, cx| { let fs = workspace.app_state().fs.clone(); @@ -899,7 +952,7 @@ impl KeymapEditor { return; }; - let Ok(fs) = self + let std::result::Result::Ok(fs) = self .workspace .read_with(cx, |workspace, _| workspace.app_state().fs.clone()) else { @@ -929,6 +982,8 @@ impl KeymapEditor { let Some(context) = context else { return; }; + + telemetry::event!("Keybinding Context Copied", context = context.clone()); cx.write_to_clipboard(gpui::ClipboardItem::new_string(context.clone())); } @@ -944,6 +999,8 @@ impl KeymapEditor { let Some(action) = action else { return; }; + + telemetry::event!("Keybinding Action Copied", action = action.clone()); cx.write_to_clipboard(gpui::ClipboardItem::new_string(action.clone())); } @@ -2222,6 +2279,9 @@ async fn save_keybinding_update( from: Some(target), } }; + + let (new_keybinding, removed_keybinding, source) = operation.generate_telemetry(); + let updated_keymap_contents = settings::KeymapFile::update_keybinding(operation, keymap_contents, tab_size) .context("Failed to update keybinding")?; @@ -2231,6 +2291,13 @@ async fn save_keybinding_update( ) .await .context("Failed to write keymap file")?; + + telemetry::event!( + "Keybinding Updated", + new_keybinding = new_keybinding, + removed_keybinding = removed_keybinding, + source = source + ); Ok(()) } @@ -2266,6 +2333,7 @@ async fn remove_keybinding( .unwrap_or(KeybindSource::User), }; + let (new_keybinding, removed_keybinding, source) = operation.generate_telemetry(); let updated_keymap_contents = settings::KeymapFile::update_keybinding(operation, keymap_contents, tab_size) .context("Failed to update keybinding")?; @@ -2275,6 +2343,13 @@ async fn remove_keybinding( ) .await .context("Failed to write keymap file")?; + + telemetry::event!( + "Keybinding Removed", + new_keybinding = new_keybinding, + removed_keybinding = removed_keybinding, + source = source + ); Ok(()) } From 0023773c68d8c065cfd99d2a6dad3f8c23bf856c Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Wed, 16 Jul 2025 15:57:02 -0400 Subject: [PATCH 0003/1052] docs: Add Zed as Git Editor example (#34572) Release Notes: - N/A --- docs/src/git.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/docs/src/git.md b/docs/src/git.md index 642861c7b0..76db15a767 100644 --- a/docs/src/git.md +++ b/docs/src/git.md @@ -151,3 +151,17 @@ When viewing files with changes, Zed displays diff hunks that can be expanded or | {#action editor::ToggleSelectedDiffHunks} | {#kb editor::ToggleSelectedDiffHunks} | > Not all actions have default keybindings, but can be bound by [customizing your keymap](./key-bindings.md#user-keymaps). + +## Git CLI Configuration + +If you would like to also use Zed for your [git commit message editor](https://git-scm.com/book/en/v2/Customizing-Git-Git-Configuration#_core_editor) when committing from the command line you can use `zed --wait`: + +```sh +git config --global core.editor "zed --wait" +``` + +Or add the following to your shell environment (in `~/.zshrc`, `~/.bashrc`, etc): + +```sh +export GIT_EDITOR="zed --wait" +``` From b4c2ae5196910d204370731892863aa3f931c90d Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Wed, 16 Jul 2025 16:31:31 -0400 Subject: [PATCH 0004/1052] Handle `upstream_http_error` completion responses (#34573) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Addresses upstream errors such as: Screenshot 2025-07-16 at 3 37 03 PM These should now automatically retry like other upstream HTTP error codes. Release Notes: - N/A --- crates/language_model/src/language_model.rs | 128 ++++++++++++++++++++ 1 file changed, 128 insertions(+) diff --git a/crates/language_model/src/language_model.rs b/crates/language_model/src/language_model.rs index 81a0f7d8a1..8962e9d8d1 100644 --- a/crates/language_model/src/language_model.rs +++ b/crates/language_model/src/language_model.rs @@ -178,6 +178,21 @@ pub enum LanguageModelCompletionError { } impl LanguageModelCompletionError { + fn parse_upstream_error_json(message: &str) -> Option<(StatusCode, String)> { + let error_json = serde_json::from_str::(message).ok()?; + let upstream_status = error_json + .get("upstream_status") + .and_then(|v| v.as_u64()) + .and_then(|status| u16::try_from(status).ok()) + .and_then(|status| StatusCode::from_u16(status).ok())?; + let inner_message = error_json + .get("message") + .and_then(|v| v.as_str()) + .unwrap_or(message) + .to_string(); + Some((upstream_status, inner_message)) + } + pub fn from_cloud_failure( upstream_provider: LanguageModelProviderName, code: String, @@ -191,6 +206,18 @@ impl LanguageModelCompletionError { Self::PromptTooLarge { tokens: Some(tokens), } + } else if code == "upstream_http_error" { + if let Some((upstream_status, inner_message)) = + Self::parse_upstream_error_json(&message) + { + return Self::from_http_status( + upstream_provider, + upstream_status, + inner_message, + retry_after, + ); + } + anyhow!("completion request failed, code: {code}, message: {message}").into() } else if let Some(status_code) = code .strip_prefix("upstream_http_") .and_then(|code| StatusCode::from_str(code).ok()) @@ -701,3 +728,104 @@ impl From for LanguageModelProviderName { Self(SharedString::from(value)) } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_from_cloud_failure_with_upstream_http_error() { + let error = LanguageModelCompletionError::from_cloud_failure( + String::from("anthropic").into(), + "upstream_http_error".to_string(), + r#"{"code":"upstream_http_error","message":"Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers. reset reason: connection timeout","upstream_status":503}"#.to_string(), + None, + ); + + match error { + LanguageModelCompletionError::ServerOverloaded { provider, .. } => { + assert_eq!(provider.0, "anthropic"); + } + _ => panic!( + "Expected ServerOverloaded error for 503 status, got: {:?}", + error + ), + } + + let error = LanguageModelCompletionError::from_cloud_failure( + String::from("anthropic").into(), + "upstream_http_error".to_string(), + r#"{"code":"upstream_http_error","message":"Internal server error","upstream_status":500}"#.to_string(), + None, + ); + + match error { + LanguageModelCompletionError::ApiInternalServerError { provider, message } => { + assert_eq!(provider.0, "anthropic"); + assert_eq!(message, "Internal server error"); + } + _ => panic!( + "Expected ApiInternalServerError for 500 status, got: {:?}", + error + ), + } + } + + #[test] + fn test_from_cloud_failure_with_standard_format() { + let error = LanguageModelCompletionError::from_cloud_failure( + String::from("anthropic").into(), + "upstream_http_503".to_string(), + "Service unavailable".to_string(), + None, + ); + + match error { + LanguageModelCompletionError::ServerOverloaded { provider, .. } => { + assert_eq!(provider.0, "anthropic"); + } + _ => panic!("Expected ServerOverloaded error for upstream_http_503"), + } + } + + #[test] + fn test_upstream_http_error_connection_timeout() { + let error = LanguageModelCompletionError::from_cloud_failure( + String::from("anthropic").into(), + "upstream_http_error".to_string(), + r#"{"code":"upstream_http_error","message":"Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers. reset reason: connection timeout","upstream_status":503}"#.to_string(), + None, + ); + + match error { + LanguageModelCompletionError::ServerOverloaded { provider, .. } => { + assert_eq!(provider.0, "anthropic"); + } + _ => panic!( + "Expected ServerOverloaded error for connection timeout with 503 status, got: {:?}", + error + ), + } + + let error = LanguageModelCompletionError::from_cloud_failure( + String::from("anthropic").into(), + "upstream_http_error".to_string(), + r#"{"code":"upstream_http_error","message":"Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers. reset reason: connection timeout","upstream_status":500}"#.to_string(), + None, + ); + + match error { + LanguageModelCompletionError::ApiInternalServerError { provider, message } => { + assert_eq!(provider.0, "anthropic"); + assert_eq!( + message, + "Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers. reset reason: connection timeout" + ); + } + _ => panic!( + "Expected ApiInternalServerError for connection timeout with 500 status, got: {:?}", + error + ), + } + } +} From f82ef1f76ffd06670ebd7a509dd34666346fb679 Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Wed, 16 Jul 2025 16:55:54 -0400 Subject: [PATCH 0005/1052] agent: Support GEMINI_API_KEY environment variable (#34574) Google Gemini Docs now recommend usage of `GEMINI_API_KEY` and the legacy `GOOGLE_AI_API_KEY` variable is no longer supported in the modern SDKs. Zed will now accept either. Release Notes: - N/A --- crates/language_models/src/provider/google.rs | 9 ++++++--- docs/src/ai/configuration.md | 2 +- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/crates/language_models/src/provider/google.rs b/crates/language_models/src/provider/google.rs index d1539dd22c..bd8a09970a 100644 --- a/crates/language_models/src/provider/google.rs +++ b/crates/language_models/src/provider/google.rs @@ -94,6 +94,7 @@ pub struct State { _subscription: Subscription, } +const GEMINI_API_KEY_VAR: &str = "GEMINI_API_KEY"; const GOOGLE_AI_API_KEY_VAR: &str = "GOOGLE_AI_API_KEY"; impl State { @@ -151,6 +152,8 @@ impl State { cx.spawn(async move |this, cx| { let (api_key, from_env) = if let Ok(api_key) = std::env::var(GOOGLE_AI_API_KEY_VAR) { (api_key, true) + } else if let Ok(api_key) = std::env::var(GEMINI_API_KEY_VAR) { + (api_key, true) } else { let (_, api_key) = credentials_provider .read_credentials(&api_url, &cx) @@ -903,7 +906,7 @@ impl Render for ConfigurationView { ) .child( Label::new( - format!("You can also assign the {GOOGLE_AI_API_KEY_VAR} environment variable and restart Zed."), + format!("You can also assign the {GEMINI_API_KEY_VAR} environment variable and restart Zed."), ) .size(LabelSize::Small).color(Color::Muted), ) @@ -922,7 +925,7 @@ impl Render for ConfigurationView { .gap_1() .child(Icon::new(IconName::Check).color(Color::Success)) .child(Label::new(if env_var_set { - format!("API key set in {GOOGLE_AI_API_KEY_VAR} environment variable.") + format!("API key set in {GEMINI_API_KEY_VAR} environment variable.") } else { "API key configured.".to_string() })), @@ -935,7 +938,7 @@ impl Render for ConfigurationView { .icon_position(IconPosition::Start) .disabled(env_var_set) .when(env_var_set, |this| { - this.tooltip(Tooltip::text(format!("To reset your API key, unset the {GOOGLE_AI_API_KEY_VAR} environment variable."))) + this.tooltip(Tooltip::text(format!("To reset your API key, make sure {GEMINI_API_KEY_VAR} and {GOOGLE_AI_API_KEY_VAR} environment variables are unset."))) }) .on_click(cx.listener(|this, _, window, cx| this.reset_api_key(window, cx))), ) diff --git a/docs/src/ai/configuration.md b/docs/src/ai/configuration.md index 56eb4ab76c..1201fa2173 100644 --- a/docs/src/ai/configuration.md +++ b/docs/src/ai/configuration.md @@ -237,7 +237,7 @@ You can use Gemini models with the Zed agent by choosing it via the model dropdo The Google AI API key will be saved in your keychain. -Zed will also use the `GOOGLE_AI_API_KEY` environment variable if it's defined. +Zed will also use the `GEMINI_API_KEY` environment variable if it's defined. See [Using Gemini API keys](Using Gemini API keys) in the Gemini docs for more. #### Custom Models {#google-ai-custom-models} From e23a4564ccf9f12c79ea4d32c30c4055cbb754f3 Mon Sep 17 00:00:00 2001 From: Umesh Yadav <23421535+imumesh18@users.noreply.github.com> Date: Thu, 17 Jul 2025 03:00:08 +0530 Subject: [PATCH 0006/1052] keymap_ui: Open Keymap editor from settings dropdown (#34576) @probably-neb I guess we should be opening the keymap editor from title bar and menu as well. I believe this got missed in this: #34568. Release Notes: - Open Keymap editor from settings from menu and title bar. --- Cargo.lock | 1 + crates/title_bar/Cargo.toml | 1 + crates/title_bar/src/title_bar.rs | 5 +++-- crates/zed/src/zed/app_menus.rs | 3 ++- 4 files changed, 7 insertions(+), 3 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 091b944169..59e444f1f8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -16452,6 +16452,7 @@ dependencies = [ "schemars", "serde", "settings", + "settings_ui", "smallvec", "story", "telemetry", diff --git a/crates/title_bar/Cargo.toml b/crates/title_bar/Cargo.toml index 123d0468ac..3c39e6b946 100644 --- a/crates/title_bar/Cargo.toml +++ b/crates/title_bar/Cargo.toml @@ -40,6 +40,7 @@ rpc.workspace = true schemars.workspace = true serde.workspace = true settings.workspace = true +settings_ui.workspace = true smallvec.workspace = true story = { workspace = true, optional = true } telemetry.workspace = true diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs index 4b8902d14e..453bb54db8 100644 --- a/crates/title_bar/src/title_bar.rs +++ b/crates/title_bar/src/title_bar.rs @@ -30,6 +30,7 @@ use onboarding_banner::OnboardingBanner; use project::Project; use rpc::proto; use settings::Settings as _; +use settings_ui::keybindings; use std::sync::Arc; use theme::ActiveTheme; use title_bar_settings::TitleBarSettings; @@ -683,7 +684,7 @@ impl TitleBar { ) .separator() .action("Settings", zed_actions::OpenSettings.boxed_clone()) - .action("Key Bindings", Box::new(zed_actions::OpenKeymap)) + .action("Key Bindings", Box::new(keybindings::OpenKeymapEditor)) .action( "Themes…", zed_actions::theme_selector::Toggle::default().boxed_clone(), @@ -727,7 +728,7 @@ impl TitleBar { .menu(|window, cx| { ContextMenu::build(window, cx, |menu, _, _| { menu.action("Settings", zed_actions::OpenSettings.boxed_clone()) - .action("Key Bindings", Box::new(zed_actions::OpenKeymap)) + .action("Key Bindings", Box::new(keybindings::OpenKeymapEditor)) .action( "Themes…", zed_actions::theme_selector::Toggle::default().boxed_clone(), diff --git a/crates/zed/src/zed/app_menus.rs b/crates/zed/src/zed/app_menus.rs index ddab724f4a..c4131dbee9 100644 --- a/crates/zed/src/zed/app_menus.rs +++ b/crates/zed/src/zed/app_menus.rs @@ -1,5 +1,6 @@ use collab_ui::collab_panel; use gpui::{Menu, MenuItem, OsAction}; +use settings_ui::keybindings; use terminal_view::terminal_panel; pub fn app_menus() -> Vec { @@ -16,7 +17,7 @@ pub fn app_menus() -> Vec { name: "Settings".into(), items: vec![ MenuItem::action("Open Settings", super::OpenSettings), - MenuItem::action("Open Key Bindings", zed_actions::OpenKeymap), + MenuItem::action("Open Key Bindings", keybindings::OpenKeymapEditor), MenuItem::action("Open Default Settings", super::OpenDefaultSettings), MenuItem::action( "Open Default Key Bindings", From f43bcc14927f68fa99d721bad41e52810cdc630b Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Wed, 16 Jul 2025 18:04:53 -0400 Subject: [PATCH 0007/1052] collab: Remove `GET /billing/subscriptions` endpoint (#34580) This PR removes the `GET /billing/subscriptions` endpoint, as it has been moved to `cloud.zed.dev`. Release Notes: - N/A --- crates/collab/src/api/billing.rs | 89 +------------------------------- 1 file changed, 1 insertion(+), 88 deletions(-) diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs index 72a9a1b46b..1ca71726f9 100644 --- a/crates/collab/src/api/billing.rs +++ b/crates/collab/src/api/billing.rs @@ -49,10 +49,7 @@ use crate::{ pub fn router() -> Router { Router::new() .route("/billing/preferences", put(update_billing_preferences)) - .route( - "/billing/subscriptions", - get(list_billing_subscriptions).post(create_billing_subscription), - ) + .route("/billing/subscriptions", post(create_billing_subscription)) .route( "/billing/subscriptions/manage", post(manage_billing_subscription), @@ -166,90 +163,6 @@ async fn update_billing_preferences( })) } -#[derive(Debug, Deserialize)] -struct ListBillingSubscriptionsParams { - github_user_id: i32, -} - -#[derive(Debug, Serialize)] -struct BillingSubscriptionJson { - id: BillingSubscriptionId, - name: String, - status: StripeSubscriptionStatus, - period: Option, - trial_end_at: Option, - cancel_at: Option, - /// Whether this subscription can be canceled. - is_cancelable: bool, -} - -#[derive(Debug, Serialize)] -struct BillingSubscriptionPeriodJson { - start_at: String, - end_at: String, -} - -#[derive(Debug, Serialize)] -struct ListBillingSubscriptionsResponse { - subscriptions: Vec, -} - -async fn list_billing_subscriptions( - Extension(app): Extension>, - Query(params): Query, -) -> Result> { - let user = app - .db - .get_user_by_github_user_id(params.github_user_id) - .await? - .context("user not found")?; - - let subscriptions = app.db.get_billing_subscriptions(user.id).await?; - - Ok(Json(ListBillingSubscriptionsResponse { - subscriptions: subscriptions - .into_iter() - .map(|subscription| BillingSubscriptionJson { - id: subscription.id, - name: match subscription.kind { - Some(SubscriptionKind::ZedPro) => "Zed Pro".to_string(), - Some(SubscriptionKind::ZedProTrial) => "Zed Pro (Trial)".to_string(), - Some(SubscriptionKind::ZedFree) => "Zed Free".to_string(), - None => "Zed LLM Usage".to_string(), - }, - status: subscription.stripe_subscription_status, - period: maybe!({ - let start_at = subscription.current_period_start_at()?; - let end_at = subscription.current_period_end_at()?; - - Some(BillingSubscriptionPeriodJson { - start_at: start_at.to_rfc3339_opts(SecondsFormat::Millis, true), - end_at: end_at.to_rfc3339_opts(SecondsFormat::Millis, true), - }) - }), - trial_end_at: if subscription.kind == Some(SubscriptionKind::ZedProTrial) { - maybe!({ - let end_at = subscription.stripe_current_period_end?; - let end_at = DateTime::from_timestamp(end_at, 0)?; - - Some(end_at.to_rfc3339_opts(SecondsFormat::Millis, true)) - }) - } else { - None - }, - cancel_at: subscription.stripe_cancel_at.map(|cancel_at| { - cancel_at - .and_utc() - .to_rfc3339_opts(SecondsFormat::Millis, true) - }), - is_cancelable: subscription.kind != Some(SubscriptionKind::ZedFree) - && subscription.stripe_subscription_status.is_cancelable() - && subscription.stripe_cancel_at.is_none(), - }) - .collect(), - })) -} - #[derive(Debug, PartialEq, Clone, Copy, Deserialize)] #[serde(rename_all = "snake_case")] enum ProductCode { From c0261a1ea9c380b59c914c7dc6304add40496e24 Mon Sep 17 00:00:00 2001 From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com> Date: Wed, 16 Jul 2025 18:05:26 -0400 Subject: [PATCH 0008/1052] keymap ui: Fix keymap editor search bugs (#34579) Keystroke input now gets cleared when toggling to normal search mode Main search bar is focused when toggling to normal search mode This also gets rid of highlight on focus from keystroke_editor because it also matched the search bool field and was redundant Release Notes: - N/A --- crates/settings_ui/src/keybindings.rs | 24 ++++++++---------------- 1 file changed, 8 insertions(+), 16 deletions(-) diff --git a/crates/settings_ui/src/keybindings.rs b/crates/settings_ui/src/keybindings.rs index e0105fa875..21eec538b3 100644 --- a/crates/settings_ui/src/keybindings.rs +++ b/crates/settings_ui/src/keybindings.rs @@ -303,7 +303,7 @@ impl KeymapEditor { let keystroke_editor = cx.new(|cx| { let mut keystroke_editor = KeystrokeInput::new(None, window, cx); - keystroke_editor.highlight_on_focus = false; + keystroke_editor.search = true; keystroke_editor }); @@ -1029,18 +1029,16 @@ impl KeymapEditor { self.search_mode = self.search_mode.invert(); self.on_query_changed(cx); - // Update the keystroke editor to turn the `search` bool on - self.keystroke_editor.update(cx, |keystroke_editor, cx| { - keystroke_editor - .set_search_mode(matches!(self.search_mode, SearchMode::KeyStroke { .. })); - cx.notify(); - }); - match self.search_mode { SearchMode::KeyStroke { .. } => { window.focus(&self.keystroke_editor.read(cx).recording_focus_handle(cx)); } - SearchMode::Normal => {} + SearchMode::Normal => { + self.keystroke_editor.update(cx, |editor, cx| { + editor.clear_keystrokes(&ClearKeystrokes, window, cx) + }); + window.focus(&self.filter_editor.focus_handle(cx)); + } } } @@ -2373,7 +2371,6 @@ enum KeyPress<'a> { struct KeystrokeInput { keystrokes: Vec, placeholder_keystrokes: Option>, - highlight_on_focus: bool, outer_focus_handle: FocusHandle, inner_focus_handle: FocusHandle, intercept_subscription: Option, @@ -2401,7 +2398,6 @@ impl KeystrokeInput { Self { keystrokes: Vec::new(), placeholder_keystrokes, - highlight_on_focus: true, inner_focus_handle, outer_focus_handle, intercept_subscription: None, @@ -2618,10 +2614,6 @@ impl KeystrokeInput { self.inner_focus_handle.clone() } - fn set_search_mode(&mut self, search: bool) { - self.search = search; - } - fn start_recording(&mut self, _: &StartRecording, window: &mut Window, cx: &mut Context) { if !self.outer_focus_handle.is_focused(window) { return; @@ -2781,7 +2773,7 @@ impl Render for KeystrokeInput { .track_focus(&self.inner_focus_handle) .on_modifiers_changed(cx.listener(Self::on_modifiers_changed)) .size_full() - .when(self.highlight_on_focus, |this| { + .when(!self.search, |this| { this.focus(|mut style| { style.border_color = Some(colors.border_focused); style From b9ff538747556f3f2f5ed4ee109654eb80cc9c9c Mon Sep 17 00:00:00 2001 From: Cole Miller Date: Wed, 16 Jul 2025 19:35:30 -0400 Subject: [PATCH 0009/1052] docs: Discuss `inlay_hints.show_value_hints` in debugger docs (#34581) This isn't under the `debugger` settings key, but it seems good to document on the debugger page anyway. Release Notes: - N/A --- docs/src/debugger.md | 34 ++++++++++++++++++++++++++-------- 1 file changed, 26 insertions(+), 8 deletions(-) diff --git a/docs/src/debugger.md b/docs/src/debugger.md index 02c17c4127..7cfbf63cd8 100644 --- a/docs/src/debugger.md +++ b/docs/src/debugger.md @@ -177,8 +177,8 @@ The debug adapter will then stop whenever an exception of a given kind occurs. W ### Stepping granularity - Description: The Step granularity that the debugger will use -- Default: line -- Setting: debugger.stepping_granularity +- Default: `line` +- Setting: `debugger.stepping_granularity` **Options** @@ -217,8 +217,8 @@ The debug adapter will then stop whenever an exception of a given kind occurs. W ### Save Breakpoints - Description: Whether the breakpoints should be saved across Zed sessions. -- Default: true -- Setting: debugger.save_breakpoints +- Default: `true` +- Setting: `debugger.save_breakpoints` **Options** @@ -235,8 +235,8 @@ The debug adapter will then stop whenever an exception of a given kind occurs. W ### Button - Description: Whether the button should be displayed in the debugger toolbar. -- Default: true -- Setting: debugger.show_button +- Default: `true` +- Setting: `debugger.show_button` **Options** @@ -253,8 +253,8 @@ The debug adapter will then stop whenever an exception of a given kind occurs. W ### Timeout - Description: Time in milliseconds until timeout error when connecting to a TCP debug adapter. -- Default: 2000 -- Setting: debugger.timeout +- Default: `2000` +- Setting: `debugger.timeout` **Options** @@ -268,6 +268,24 @@ The debug adapter will then stop whenever an exception of a given kind occurs. W } ``` +### Inline Values + +- Description: Whether to enable editor inlay hints showing the values of variables in your code during debugging sessions. +- Default: `true` +- Setting: `inlay_hints.show_value_hints` + +**Options** + +```json +{ + "inlay_hints": { + "show_value_hints": false + } +} +``` + +Inline value hints can also be toggled from the Editor Controls menu in the editor toolbar. + ### Log Dap Communications - Description: Whether to log messages between active debug adapters and Zed. (Used for DAP development) From ebad5ca50e11fc9d3fbbab397888d0944a825bb7 Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Thu, 17 Jul 2025 06:36:02 +0530 Subject: [PATCH 0010/1052] =?UTF-8?q?linux:=20Fix=20buttons=20clicks=20wou?= =?UTF-8?q?ldn=E2=80=99t=20work=20on=20startup=20until=20clicked=20on=20ce?= =?UTF-8?q?nter=20pane=20(#34590)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closes #31805 This is an issue with Linux currently that `window.focus` is `None` upon startup in both X11 and Wayland. Specifically, the order in which [this](https://github.com/zed-industries/zed/blob/8d05a3d389b6a1caa80bb18f26c3dac0c26debcb/crates/gpui/src/window.rs#L3116) and [this](https://github.com/zed-industries/zed/blob/8d05a3d389b6a1caa80bb18f26c3dac0c26debcb/crates/gpui/src/app.rs#L956) are executed varies between Linux and macOS. That is, one tries to remove (blur) focus from a window, while other checks window focus to put that focus id to a frame. In macOS, blur happens afterwards setting focus on a frame, but in Linux, the inverse of it happens, leading to `window.focus` to `None`. For the time being, we handle all visible buttons to take care of this **focus can be `None`** case, and make it work anyway. But, we should look at the deeper issue mentioned above with GPUI. Created new issue to track that https://github.com/zed-industries/zed/issues/34591. Release Notes: - Fixed an issue where button clicks wouldn’t work on startup until clicked on the center pane on Linux. --- crates/title_bar/src/title_bar.rs | 9 +++++---- crates/workspace/src/dock.rs | 3 +++ 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs index 453bb54db8..977b5c3ecd 100644 --- a/crates/title_bar/src/title_bar.rs +++ b/crates/title_bar/src/title_bar.rs @@ -22,9 +22,9 @@ use auto_update::AutoUpdateStatus; use call::ActiveCall; use client::{Client, UserStore}; use gpui::{ - Action, AnyElement, App, Context, Corner, Element, Entity, InteractiveElement, IntoElement, - MouseButton, ParentElement, Render, StatefulInteractiveElement, Styled, Subscription, - WeakEntity, Window, actions, div, + Action, AnyElement, App, Context, Corner, Element, Entity, Focusable, InteractiveElement, + IntoElement, MouseButton, ParentElement, Render, StatefulInteractiveElement, Styled, + Subscription, WeakEntity, Window, actions, div, }; use onboarding_banner::OnboardingBanner; use project::Project; @@ -504,7 +504,8 @@ impl TitleBar { ) }) .on_click(move |_, window, cx| { - let _ = workspace.update(cx, |_this, cx| { + let _ = workspace.update(cx, |this, cx| { + window.focus(&this.active_pane().focus_handle(cx)); window.dispatch_action(zed_actions::git::Branch.boxed_clone(), cx); }); }) diff --git a/crates/workspace/src/dock.rs b/crates/workspace/src/dock.rs index c8301dcf35..4e39c2d182 100644 --- a/crates/workspace/src/dock.rs +++ b/crates/workspace/src/dock.rs @@ -873,6 +873,8 @@ impl Render for PanelButtons { (action, icon_tooltip.into()) }; + let focus_handle = dock.focus_handle(cx); + Some( right_click_menu(name) .menu(move |window, cx| { @@ -909,6 +911,7 @@ impl Render for PanelButtons { .on_click({ let action = action.boxed_clone(); move |_, window, cx| { + window.focus(&focus_handle); window.dispatch_action(action.boxed_clone(), cx) } }) From 9f302df6d6977626e3ae0fe5d8df3fc5ebcb0c88 Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Wed, 16 Jul 2025 20:09:38 -0600 Subject: [PATCH 0011/1052] Don't override ascii graphical shortcuts (#34592) Closes #34536 Release Notes: - (preview only) Fix shortcuts on Extended Latin keyboards on Linux --- crates/gpui/src/platform/linux/platform.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crates/gpui/src/platform/linux/platform.rs b/crates/gpui/src/platform/linux/platform.rs index bab44e0069..1e901387b0 100644 --- a/crates/gpui/src/platform/linux/platform.rs +++ b/crates/gpui/src/platform/linux/platform.rs @@ -827,6 +827,9 @@ impl crate::Keystroke { let name = xkb::keysym_get_name(key_sym).to_lowercase(); if key_sym.is_keypad_key() { name.replace("kp_", "") + } else if key_utf8.len() == 1 && key_utf8.chars().next().unwrap().is_ascii_graphic() + { + key_utf8.clone() } else if let Some(key_en) = guess_ascii(keycode, modifiers.shift) { String::from(key_en) } else { From 1ce384bbda2afa90069eac4f9d36c342cd860f8c Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Wed, 16 Jul 2025 21:27:46 -0600 Subject: [PATCH 0012/1052] Fix ctrl-q on AZERTY on Linux (#34597) Closes #ISSUE Release Notes: - N/A --- crates/gpui/src/platform/linux/platform.rs | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/crates/gpui/src/platform/linux/platform.rs b/crates/gpui/src/platform/linux/platform.rs index 1e901387b0..a24838339e 100644 --- a/crates/gpui/src/platform/linux/platform.rs +++ b/crates/gpui/src/platform/linux/platform.rs @@ -822,14 +822,28 @@ impl crate::Keystroke { Keysym::underscore => "_".to_owned(), Keysym::equal => "=".to_owned(), Keysym::plus => "+".to_owned(), + Keysym::space => "space".to_owned(), + Keysym::BackSpace => "backspace".to_owned(), + Keysym::Tab => "tab".to_owned(), + Keysym::Delete => "delete".to_owned(), + Keysym::Escape => "escape".to_owned(), _ => { let name = xkb::keysym_get_name(key_sym).to_lowercase(); if key_sym.is_keypad_key() { name.replace("kp_", "") - } else if key_utf8.len() == 1 && key_utf8.chars().next().unwrap().is_ascii_graphic() + } else if let Some(key) = key_utf8.chars().next() + && key_utf8.len() == 1 + && key.is_ascii() { - key_utf8.clone() + if key.is_ascii_graphic() { + key_utf8.clone() + // map ctrl-a to a + } else if key_utf32 <= 0x1f { + ((key_utf32 as u8 + 0x60) as char).to_string() + } else { + name + } } else if let Some(key_en) = guess_ascii(keycode, modifiers.shift) { String::from(key_en) } else { From 1d72fa8e9e4b358bf8a207dd73bf934b90d56cd9 Mon Sep 17 00:00:00 2001 From: Eric Cornelissen Date: Thu, 17 Jul 2025 05:39:54 +0200 Subject: [PATCH 0013/1052] git: Add ability to pass `--signoff` (#29874) This adds an option for `--signoff` to the git panel and commit modal. It allows users to enable the [`--signoff` flag](https://git-scm.com/docs/git-commit#Documentation/git-commit.txt-code--signoffcode) when committing through Zed. The option is added to the context menu of the commit button (following the style of the "Editor Controls"). To support this, the commit+amend experience was revamped (following the ideas of [this comment](https://github.com/zed-industries/zed/pull/29874#issuecomment-2950848000)). Amending is now also a toggle in the commit button's dropdown menu. I've kept some of the original experience such as the changed button text and ability to cancel outside the context menu. The tooltip of the commit buttons now also includes the flags that will be used based on the amending and signoff status (which I couldn't capture in screenshots unfortunately). So, by default the tooltip will say `git commit` and if you toggle, e.g., amending on it will say `git commit --amend`. | What | Panel | Modal | | --- | --- | --- | | Not amending, dropdown | ![git modal preview, not amending, dropdown](https://github.com/user-attachments/assets/82c2b338-b3b5-418c-97bf-98c33202d7dd) | ![commit modal preview, not amending, dropdown](https://github.com/user-attachments/assets/f7a6f2fb-902d-447d-a473-2efb4ba0f444) | | Amending, dropdown | ![git modal preview, amending, dropdown](https://github.com/user-attachments/assets/9e755975-4a27-43f0-aa62-be002ecd3a92) | ![commit modal preview, amending, dropdown](https://github.com/user-attachments/assets/cad03817-14e1-46f6-ba39-8ccc7dd12161) | | Amending | ![git modal preview, amending](https://github.com/user-attachments/assets/e1ec4eba-174e-4e5f-9659-5867d6b0fdc2) | - | The initial implementation was based on the changeset of https://github.com/zed-industries/zed/pull/28187. Closes https://github.com/zed-industries/zed/discussions/26114 Release Notes: - Added git `--signoff` support. - Update the git `--amend` experience. - Improved git panel to persist width as well as amend and signoff on a per-workspace basis. --- crates/git/src/git.rs | 2 + crates/git/src/repository.rs | 5 + crates/git_ui/src/commit_modal.rs | 253 +++++++++--------- crates/git_ui/src/git_panel.rs | 416 +++++++++++++++--------------- crates/project/src/git_store.rs | 2 + crates/proto/proto/git.proto | 1 + 6 files changed, 342 insertions(+), 337 deletions(-) diff --git a/crates/git/src/git.rs b/crates/git/src/git.rs index fccedaa809..3714086dd0 100644 --- a/crates/git/src/git.rs +++ b/crates/git/src/git.rs @@ -77,6 +77,8 @@ actions!( Commit, /// Amends the last commit with staged changes. Amend, + /// Enable the --signoff option. + Signoff, /// Cancels the current git operation. Cancel, /// Expands the commit message editor. diff --git a/crates/git/src/repository.rs b/crates/git/src/repository.rs index 2ecd4bb894..9cc3442392 100644 --- a/crates/git/src/repository.rs +++ b/crates/git/src/repository.rs @@ -96,6 +96,7 @@ impl Upstream { #[derive(Clone, Copy, Default)] pub struct CommitOptions { pub amend: bool, + pub signoff: bool, } #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)] @@ -1209,6 +1210,10 @@ impl GitRepository for RealGitRepository { cmd.arg("--amend"); } + if options.signoff { + cmd.arg("--signoff"); + } + if let Some((name, email)) = name_and_email { cmd.arg("--author").arg(&format!("{name} <{email}>")); } diff --git a/crates/git_ui/src/commit_modal.rs b/crates/git_ui/src/commit_modal.rs index 15d0bec313..ac3d24e3eb 100644 --- a/crates/git_ui/src/commit_modal.rs +++ b/crates/git_ui/src/commit_modal.rs @@ -1,8 +1,8 @@ use crate::branch_picker::{self, BranchList}; use crate::git_panel::{GitPanel, commit_message_editor}; use git::repository::CommitOptions; -use git::{Amend, Commit, GenerateCommitMessage}; -use panel::{panel_button, panel_editor_style, panel_filled_button}; +use git::{Amend, Commit, GenerateCommitMessage, Signoff}; +use panel::{panel_button, panel_editor_style}; use ui::{ ContextMenu, KeybindingHint, PopoverMenu, PopoverMenuHandle, SplitButton, Tooltip, prelude::*, }; @@ -273,14 +273,51 @@ impl CommitModal { .child(Icon::new(IconName::ChevronDownSmall).size(IconSize::XSmall)), ), ) - .menu(move |window, cx| { - Some(ContextMenu::build(window, cx, |context_menu, _, _| { - context_menu - .when_some(keybinding_target.clone(), |el, keybinding_target| { - el.context(keybinding_target.clone()) - }) - .action("Amend", Amend.boxed_clone()) - })) + .menu({ + let git_panel_entity = self.git_panel.clone(); + move |window, cx| { + let git_panel = git_panel_entity.read(cx); + let amend_enabled = git_panel.amend_pending(); + let signoff_enabled = git_panel.signoff_enabled(); + let has_previous_commit = git_panel.head_commit(cx).is_some(); + + Some(ContextMenu::build(window, cx, |context_menu, _, _| { + context_menu + .when_some(keybinding_target.clone(), |el, keybinding_target| { + el.context(keybinding_target.clone()) + }) + .when(has_previous_commit, |this| { + this.toggleable_entry( + "Amend", + amend_enabled, + IconPosition::Start, + Some(Box::new(Amend)), + { + let git_panel = git_panel_entity.clone(); + move |window, cx| { + git_panel.update(cx, |git_panel, cx| { + git_panel.toggle_amend_pending(&Amend, window, cx); + }) + } + }, + ) + }) + .toggleable_entry( + "Signoff", + signoff_enabled, + IconPosition::Start, + Some(Box::new(Signoff)), + { + let git_panel = git_panel_entity.clone(); + move |window, cx| { + git_panel.update(cx, |git_panel, cx| { + git_panel.toggle_signoff_enabled(&Signoff, window, cx); + }) + } + }, + ) + })) + } }) .with_handle(self.commit_menu_handle.clone()) .anchor(Corner::TopRight) @@ -295,7 +332,7 @@ impl CommitModal { generate_commit_message, active_repo, is_amend_pending, - has_previous_commit, + is_signoff_enabled, ) = self.git_panel.update(cx, |git_panel, cx| { let (can_commit, tooltip) = git_panel.configure_commit_button(cx); let title = git_panel.commit_button_title(); @@ -303,10 +340,7 @@ impl CommitModal { let generate_commit_message = git_panel.render_generate_commit_message_button(cx); let active_repo = git_panel.active_repository.clone(); let is_amend_pending = git_panel.amend_pending(); - let has_previous_commit = active_repo - .as_ref() - .and_then(|repo| repo.read(cx).head_commit.as_ref()) - .is_some(); + let is_signoff_enabled = git_panel.signoff_enabled(); ( can_commit, tooltip, @@ -315,7 +349,7 @@ impl CommitModal { generate_commit_message, active_repo, is_amend_pending, - has_previous_commit, + is_signoff_enabled, ) }); @@ -396,126 +430,59 @@ impl CommitModal { .px_1() .gap_4() .children(close_kb_hint) - .when(is_amend_pending, |this| { - let focus_handle = focus_handle.clone(); - this.child( - panel_filled_button(commit_label) - .tooltip(move |window, cx| { - if can_commit { - Tooltip::for_action_in( - tooltip, - &Amend, - &focus_handle, - window, - cx, - ) - } else { - Tooltip::simple(tooltip, cx) - } - }) - .disabled(!can_commit) - .on_click(cx.listener(move |this, _: &ClickEvent, window, cx| { - telemetry::event!("Git Amended", source = "Git Modal"); - this.git_panel.update(cx, |git_panel, cx| { - git_panel.set_amend_pending(false, cx); - git_panel.commit_changes( - CommitOptions { amend: true }, - window, - cx, - ); - }); - cx.emit(DismissEvent); - })), + .child(SplitButton::new( + ui::ButtonLike::new_rounded_left(ElementId::Name( + format!("split-button-left-{}", commit_label).into(), + )) + .layer(ui::ElevationIndex::ModalSurface) + .size(ui::ButtonSize::Compact) + .child( + div() + .child(Label::new(commit_label).size(LabelSize::Small)) + .mr_0p5(), ) - }) - .when(!is_amend_pending, |this| { - this.when(has_previous_commit, |this| { - this.child(SplitButton::new( - ui::ButtonLike::new_rounded_left(ElementId::Name( - format!("split-button-left-{}", commit_label).into(), - )) - .layer(ui::ElevationIndex::ModalSurface) - .size(ui::ButtonSize::Compact) - .child( - div() - .child(Label::new(commit_label).size(LabelSize::Small)) - .mr_0p5(), + .on_click(cx.listener(move |this, _: &ClickEvent, window, cx| { + telemetry::event!("Git Committed", source = "Git Modal"); + this.git_panel.update(cx, |git_panel, cx| { + git_panel.commit_changes( + CommitOptions { + amend: is_amend_pending, + signoff: is_signoff_enabled, + }, + window, + cx, ) - .on_click(cx.listener(move |this, _: &ClickEvent, window, cx| { - telemetry::event!("Git Committed", source = "Git Modal"); - this.git_panel.update(cx, |git_panel, cx| { - git_panel.commit_changes( - CommitOptions { amend: false }, - window, - cx, - ) - }); - cx.emit(DismissEvent); - })) - .disabled(!can_commit) - .tooltip({ - let focus_handle = focus_handle.clone(); - move |window, cx| { - if can_commit { - Tooltip::with_meta_in( - tooltip, - Some(&git::Commit), - "git commit", - &focus_handle.clone(), - window, - cx, - ) - } else { - Tooltip::simple(tooltip, cx) - } - } - }), - self.render_git_commit_menu( - ElementId::Name( - format!("split-button-right-{}", commit_label).into(), - ), - Some(focus_handle.clone()), - ) - .into_any_element(), - )) - }) - .when(!has_previous_commit, |this| { - this.child( - panel_filled_button(commit_label) - .tooltip(move |window, cx| { - if can_commit { - Tooltip::with_meta_in( - tooltip, - Some(&git::Commit), - "git commit", - &focus_handle, - window, - cx, - ) - } else { - Tooltip::simple(tooltip, cx) - } - }) - .disabled(!can_commit) - .on_click(cx.listener( - move |this, _: &ClickEvent, window, cx| { - telemetry::event!( - "Git Committed", - source = "Git Modal" - ); - this.git_panel.update(cx, |git_panel, cx| { - git_panel.commit_changes( - CommitOptions { amend: false }, - window, - cx, - ) - }); - cx.emit(DismissEvent); - }, - )), - ) - }) - }), + }); + cx.emit(DismissEvent); + })) + .disabled(!can_commit) + .tooltip({ + let focus_handle = focus_handle.clone(); + move |window, cx| { + if can_commit { + Tooltip::with_meta_in( + tooltip, + Some(&git::Commit), + format!( + "git commit{}{}", + if is_amend_pending { " --amend" } else { "" }, + if is_signoff_enabled { " --signoff" } else { "" } + ), + &focus_handle.clone(), + window, + cx, + ) + } else { + Tooltip::simple(tooltip, cx) + } + } + }), + self.render_git_commit_menu( + ElementId::Name(format!("split-button-right-{}", commit_label).into()), + Some(focus_handle.clone()), + ) + .into_any_element(), + )), ) } @@ -534,7 +501,14 @@ impl CommitModal { } telemetry::event!("Git Committed", source = "Git Modal"); self.git_panel.update(cx, |git_panel, cx| { - git_panel.commit_changes(CommitOptions { amend: false }, window, cx) + git_panel.commit_changes( + CommitOptions { + amend: false, + signoff: git_panel.signoff_enabled(), + }, + window, + cx, + ) }); cx.emit(DismissEvent); } @@ -559,7 +533,14 @@ impl CommitModal { telemetry::event!("Git Amended", source = "Git Modal"); self.git_panel.update(cx, |git_panel, cx| { git_panel.set_amend_pending(false, cx); - git_panel.commit_changes(CommitOptions { amend: true }, window, cx); + git_panel.commit_changes( + CommitOptions { + amend: true, + signoff: git_panel.signoff_enabled(), + }, + window, + cx, + ); }); cx.emit(DismissEvent); } diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index 52bed2cc79..2397f51f82 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -25,7 +25,7 @@ use git::repository::{ UpstreamTrackingStatus, get_git_committer, }; use git::status::StageStatus; -use git::{Amend, ToggleStaged, repository::RepoPath, status::FileStatus}; +use git::{Amend, Signoff, ToggleStaged, repository::RepoPath, status::FileStatus}; use git::{ExpandCommitEditor, RestoreTrackedFiles, StageAll, TrashUntrackedFiles, UnstageAll}; use gpui::{ Action, Animation, AnimationExt as _, AsyncApp, AsyncWindowContext, Axis, ClickEvent, Corner, @@ -61,8 +61,8 @@ use std::{collections::HashSet, sync::Arc, time::Duration, usize}; use strum::{IntoEnumIterator, VariantNames}; use time::OffsetDateTime; use ui::{ - Checkbox, ContextMenu, ElevationIndex, PopoverMenu, Scrollbar, ScrollbarState, SplitButton, - Tooltip, prelude::*, + Checkbox, ContextMenu, ElevationIndex, IconPosition, Label, LabelSize, PopoverMenu, Scrollbar, + ScrollbarState, SplitButton, Tooltip, prelude::*, }; use util::{ResultExt, TryFutureExt, maybe}; @@ -174,6 +174,10 @@ pub enum Event { #[derive(Serialize, Deserialize)] struct SerializedGitPanel { width: Option, + #[serde(default)] + amend_pending: bool, + #[serde(default)] + signoff_enabled: bool, } #[derive(Debug, PartialEq, Eq, Clone, Copy)] @@ -337,6 +341,7 @@ pub struct GitPanel { pending: Vec, pending_commit: Option>, amend_pending: bool, + signoff_enabled: bool, pending_serialization: Task>, pub(crate) project: Entity, scroll_handle: UniformListScrollHandle, @@ -512,6 +517,7 @@ impl GitPanel { pending: Vec::new(), pending_commit: None, amend_pending: false, + signoff_enabled: false, pending_serialization: Task::ready(None), single_staged_entry: None, single_tracked_entry: None, @@ -690,14 +696,38 @@ impl GitPanel { cx.notify(); } + fn serialization_key(workspace: &Workspace) -> Option { + workspace + .database_id() + .map(|id| i64::from(id).to_string()) + .or(workspace.session_id()) + .map(|id| format!("{}-{:?}", GIT_PANEL_KEY, id)) + } + fn serialize(&mut self, cx: &mut Context) { let width = self.width; + let amend_pending = self.amend_pending; + let signoff_enabled = self.signoff_enabled; + + let Some(serialization_key) = self + .workspace + .read_with(cx, |workspace, _| Self::serialization_key(workspace)) + .ok() + .flatten() + else { + return; + }; + self.pending_serialization = cx.background_spawn( async move { KEY_VALUE_STORE .write_kvp( - GIT_PANEL_KEY.into(), - serde_json::to_string(&SerializedGitPanel { width })?, + serialization_key, + serde_json::to_string(&SerializedGitPanel { + width, + amend_pending, + signoff_enabled, + })?, ) .await?; anyhow::Ok(()) @@ -1432,7 +1462,14 @@ impl GitPanel { .contains_focused(window, cx) { telemetry::event!("Git Committed", source = "Git Panel"); - self.commit_changes(CommitOptions { amend: false }, window, cx) + self.commit_changes( + CommitOptions { + amend: false, + signoff: self.signoff_enabled, + }, + window, + cx, + ) } else { cx.propagate(); } @@ -1444,19 +1481,21 @@ impl GitPanel { .focus_handle(cx) .contains_focused(window, cx) { - if self - .active_repository - .as_ref() - .and_then(|repo| repo.read(cx).head_commit.as_ref()) - .is_some() - { + if self.head_commit(cx).is_some() { if !self.amend_pending { self.set_amend_pending(true, cx); self.load_last_commit_message_if_empty(cx); } else { telemetry::event!("Git Amended", source = "Git Panel"); self.set_amend_pending(false, cx); - self.commit_changes(CommitOptions { amend: true }, window, cx); + self.commit_changes( + CommitOptions { + amend: true, + signoff: self.signoff_enabled, + }, + window, + cx, + ); } } } else { @@ -1464,21 +1503,21 @@ impl GitPanel { } } + pub fn head_commit(&self, cx: &App) -> Option { + self.active_repository + .as_ref() + .and_then(|repo| repo.read(cx).head_commit.as_ref()) + .cloned() + } + pub fn load_last_commit_message_if_empty(&mut self, cx: &mut Context) { if !self.commit_editor.read(cx).is_empty(cx) { return; } - let Some(active_repository) = self.active_repository.as_ref() else { - return; - }; - let Some(recent_sha) = active_repository - .read(cx) - .head_commit - .as_ref() - .map(|commit| commit.sha.to_string()) - else { + let Some(head_commit) = self.head_commit(cx) else { return; }; + let recent_sha = head_commit.sha.to_string(); let detail_task = self.load_commit_details(recent_sha, cx); cx.spawn(async move |this, cx| { if let Ok(message) = detail_task.await.map(|detail| detail.message) { @@ -1495,12 +1534,6 @@ impl GitPanel { .detach(); } - fn cancel(&mut self, _: &git::Cancel, _: &mut Window, cx: &mut Context) { - if self.amend_pending { - self.set_amend_pending(false, cx); - } - } - fn custom_or_suggested_commit_message( &self, window: &mut Window, @@ -3003,14 +3036,35 @@ impl GitPanel { .child(Icon::new(IconName::ChevronDownSmall).size(IconSize::XSmall)), ), ) - .menu(move |window, cx| { - Some(ContextMenu::build(window, cx, |context_menu, _, _| { - context_menu - .when_some(keybinding_target.clone(), |el, keybinding_target| { - el.context(keybinding_target.clone()) - }) - .action("Amend", Amend.boxed_clone()) - })) + .menu({ + let has_previous_commit = self.head_commit(cx).is_some(); + let amend = self.amend_pending(); + let signoff = self.signoff_enabled; + + move |window, cx| { + Some(ContextMenu::build(window, cx, |context_menu, _, _| { + context_menu + .when_some(keybinding_target.clone(), |el, keybinding_target| { + el.context(keybinding_target.clone()) + }) + .when(has_previous_commit, |this| { + this.toggleable_entry( + "Amend", + amend, + IconPosition::Start, + Some(Box::new(Amend)), + move |window, cx| window.dispatch_action(Box::new(Amend), cx), + ) + }) + .toggleable_entry( + "Signoff", + signoff, + IconPosition::Start, + Some(Box::new(Signoff)), + move |window, cx| window.dispatch_action(Box::new(Signoff), cx), + ) + })) + } }) .anchor(Corner::TopRight) } @@ -3187,7 +3241,6 @@ impl GitPanel { let editor_is_long = self.commit_editor.update(cx, |editor, cx| { editor.max_point(cx).row().0 >= MAX_PANEL_EDITOR_LINES as u32 }); - let has_previous_commit = head_commit.is_some(); let footer = v_flex() .child(PanelRepoFooter::new( @@ -3231,7 +3284,7 @@ impl GitPanel { h_flex() .gap_0p5() .children(enable_coauthors) - .child(self.render_commit_button(has_previous_commit, cx)), + .child(self.render_commit_button(cx)), ), ) .child( @@ -3280,14 +3333,12 @@ impl GitPanel { Some(footer) } - fn render_commit_button( - &self, - has_previous_commit: bool, - cx: &mut Context, - ) -> impl IntoElement { + fn render_commit_button(&self, cx: &mut Context) -> impl IntoElement { let (can_commit, tooltip) = self.configure_commit_button(cx); let title = self.commit_button_title(); let commit_tooltip_focus_handle = self.commit_editor.focus_handle(cx); + let amend = self.amend_pending(); + let signoff = self.signoff_enabled; div() .id("commit-wrapper") @@ -3296,165 +3347,86 @@ impl GitPanel { *hovered && !this.has_staged_changes() && !this.has_unstaged_conflicts(); cx.notify() })) - .when(self.amend_pending, { - |this| { - this.h_flex() - .gap_1() - .child( - panel_filled_button("Cancel") - .tooltip({ - let handle = commit_tooltip_focus_handle.clone(); - move |window, cx| { - Tooltip::for_action_in( - "Cancel amend", - &git::Cancel, - &handle, - window, - cx, - ) - } - }) - .on_click(move |_, window, cx| { - window.dispatch_action(Box::new(git::Cancel), cx); - }), - ) - .child( - panel_filled_button(title) - .tooltip({ - let handle = commit_tooltip_focus_handle.clone(); - move |window, cx| { - if can_commit { - Tooltip::for_action_in( - tooltip, &Amend, &handle, window, cx, - ) - } else { - Tooltip::simple(tooltip, cx) - } - } - }) - .disabled(!can_commit || self.modal_open) - .on_click({ - let git_panel = cx.weak_entity(); - move |_, window, cx| { - telemetry::event!("Git Amended", source = "Git Panel"); - git_panel - .update(cx, |git_panel, cx| { - git_panel.set_amend_pending(false, cx); - git_panel.commit_changes( - CommitOptions { amend: true }, - window, - cx, - ); - }) - .ok(); - } - }), - ) - } - }) - .when(!self.amend_pending, |this| { - this.when(has_previous_commit, |this| { - this.child(SplitButton::new( - ui::ButtonLike::new_rounded_left(ElementId::Name( - format!("split-button-left-{}", title).into(), - )) - .layer(ui::ElevationIndex::ModalSurface) - .size(ui::ButtonSize::Compact) - .child( - div() - .child(Label::new(title).size(LabelSize::Small)) - .mr_0p5(), - ) - .on_click({ - let git_panel = cx.weak_entity(); - move |_, window, cx| { - telemetry::event!("Git Committed", source = "Git Panel"); - git_panel - .update(cx, |git_panel, cx| { - git_panel.commit_changes( - CommitOptions { amend: false }, - window, - cx, - ); - }) - .ok(); - } - }) - .disabled(!can_commit || self.modal_open) - .tooltip({ - let handle = commit_tooltip_focus_handle.clone(); - move |window, cx| { - if can_commit { - Tooltip::with_meta_in( - tooltip, - Some(&git::Commit), - "git commit", - &handle.clone(), - window, - cx, - ) - } else { - Tooltip::simple(tooltip, cx) - } - } - }), - self.render_git_commit_menu( - ElementId::Name(format!("split-button-right-{}", title).into()), - Some(commit_tooltip_focus_handle.clone()), - cx, - ) - .into_any_element(), - )) - }) - .when(!has_previous_commit, |this| { - this.child( - panel_filled_button(title) - .tooltip(move |window, cx| { - if can_commit { - Tooltip::with_meta_in( - tooltip, - Some(&git::Commit), - "git commit", - &commit_tooltip_focus_handle, - window, - cx, - ) - } else { - Tooltip::simple(tooltip, cx) - } + .child(SplitButton::new( + ui::ButtonLike::new_rounded_left(ElementId::Name( + format!("split-button-left-{}", title).into(), + )) + .layer(ui::ElevationIndex::ModalSurface) + .size(ui::ButtonSize::Compact) + .child( + div() + .child(Label::new(title).size(LabelSize::Small)) + .mr_0p5(), + ) + .on_click({ + let git_panel = cx.weak_entity(); + move |_, window, cx| { + telemetry::event!("Git Committed", source = "Git Panel"); + git_panel + .update(cx, |git_panel, cx| { + git_panel.set_amend_pending(false, cx); + git_panel.commit_changes( + CommitOptions { amend, signoff }, + window, + cx, + ); }) - .disabled(!can_commit || self.modal_open) - .on_click({ - let git_panel = cx.weak_entity(); - move |_, window, cx| { - telemetry::event!("Git Committed", source = "Git Panel"); - git_panel - .update(cx, |git_panel, cx| { - git_panel.commit_changes( - CommitOptions { amend: false }, - window, - cx, - ); - }) - .ok(); - } - }), - ) + .ok(); + } }) - }) + .disabled(!can_commit || self.modal_open) + .tooltip({ + let handle = commit_tooltip_focus_handle.clone(); + move |window, cx| { + if can_commit { + Tooltip::with_meta_in( + tooltip, + Some(&git::Commit), + format!( + "git commit{}{}", + if amend { " --amend" } else { "" }, + if signoff { " --signoff" } else { "" } + ), + &handle.clone(), + window, + cx, + ) + } else { + Tooltip::simple(tooltip, cx) + } + } + }), + self.render_git_commit_menu( + ElementId::Name(format!("split-button-right-{}", title).into()), + Some(commit_tooltip_focus_handle.clone()), + cx, + ) + .into_any_element(), + )) } fn render_pending_amend(&self, cx: &mut Context) -> impl IntoElement { - div() - .p_2() + h_flex() + .py_1p5() + .px_2() + .gap_1p5() + .justify_between() .border_t_1() - .border_color(cx.theme().colors().border) + .border_color(cx.theme().colors().border.opacity(0.8)) .child( - Label::new( - "This will update your most recent commit. Cancel to make a new one instead.", - ) - .size(LabelSize::Small), + div() + .flex_grow() + .overflow_hidden() + .max_w(relative(0.85)) + .child( + Label::new("This will update your most recent commit.") + .size(LabelSize::Small) + .truncate(), + ), ) + .child(panel_button("Cancel").size(ButtonSize::Default).on_click( + cx.listener(|this, _, window, cx| this.toggle_amend_pending(&Amend, window, cx)), + )) } fn render_previous_commit(&self, cx: &mut Context) -> Option { @@ -4218,17 +4190,56 @@ impl GitPanel { cx.notify(); } + pub fn toggle_amend_pending( + &mut self, + _: &Amend, + _window: &mut Window, + cx: &mut Context, + ) { + self.set_amend_pending(!self.amend_pending, cx); + self.serialize(cx); + } + + pub fn signoff_enabled(&self) -> bool { + self.signoff_enabled + } + + pub fn set_signoff_enabled(&mut self, value: bool, cx: &mut Context) { + self.signoff_enabled = value; + self.serialize(cx); + cx.notify(); + } + + pub fn toggle_signoff_enabled( + &mut self, + _: &Signoff, + _window: &mut Window, + cx: &mut Context, + ) { + self.set_signoff_enabled(!self.signoff_enabled, cx); + } + pub async fn load( workspace: WeakEntity, mut cx: AsyncWindowContext, ) -> anyhow::Result> { - let serialized_panel = cx - .background_spawn(async move { KEY_VALUE_STORE.read_kvp(&GIT_PANEL_KEY) }) - .await - .context("loading git panel") - .log_err() + let serialized_panel = match workspace + .read_with(&cx, |workspace, _| Self::serialization_key(workspace)) + .ok() .flatten() - .and_then(|panel| serde_json::from_str::(&panel).log_err()); + { + Some(serialization_key) => cx + .background_spawn(async move { KEY_VALUE_STORE.read_kvp(&serialization_key) }) + .await + .context("loading git panel") + .log_err() + .flatten() + .map(|panel| serde_json::from_str::(&panel)) + .transpose() + .log_err() + .flatten(), + None => None, + }; workspace.update_in(&mut cx, |workspace, window, cx| { let panel = GitPanel::new(workspace, window, cx); @@ -4236,6 +4247,8 @@ impl GitPanel { if let Some(serialized_panel) = serialized_panel { panel.update(cx, |panel, cx| { panel.width = serialized_panel.width; + panel.amend_pending = serialized_panel.amend_pending; + panel.signoff_enabled = serialized_panel.signoff_enabled; cx.notify(); }) } @@ -4320,7 +4333,8 @@ impl Render for GitPanel { .on_action(cx.listener(Self::stage_range)) .on_action(cx.listener(GitPanel::commit)) .on_action(cx.listener(GitPanel::amend)) - .on_action(cx.listener(GitPanel::cancel)) + .on_action(cx.listener(GitPanel::toggle_amend_pending)) + .on_action(cx.listener(GitPanel::toggle_signoff_enabled)) .on_action(cx.listener(Self::stage_all)) .on_action(cx.listener(Self::unstage_all)) .on_action(cx.listener(Self::stage_selected)) diff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rs index 9ff3823e0f..5f07bafe5b 100644 --- a/crates/project/src/git_store.rs +++ b/crates/project/src/git_store.rs @@ -1738,6 +1738,7 @@ impl GitStore { name.zip(email), CommitOptions { amend: options.amend, + signoff: options.signoff, }, cx, ) @@ -3488,6 +3489,7 @@ impl Repository { email: email.map(String::from), options: Some(proto::commit::CommitOptions { amend: options.amend, + signoff: options.signoff, }), }) .await diff --git a/crates/proto/proto/git.proto b/crates/proto/proto/git.proto index 6593062ed2..1d544b15ff 100644 --- a/crates/proto/proto/git.proto +++ b/crates/proto/proto/git.proto @@ -298,6 +298,7 @@ message Commit { message CommitOptions { bool amend = 1; + bool signoff = 2; } } From ad2bfa3edd0991d9c15f349dab0e416a08210e9f Mon Sep 17 00:00:00 2001 From: Finn Evers Date: Thu, 17 Jul 2025 11:22:04 +0200 Subject: [PATCH 0014/1052] Disable minimap in the inspector (#34607) This disables the minimap in the inspector UI as it doesn't bring any value to it and just takes up unnecessary space. Release Notes: - N/A --- crates/inspector_ui/src/div_inspector.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/crates/inspector_ui/src/div_inspector.rs b/crates/inspector_ui/src/div_inspector.rs index 7d162bcc35..bd395aa01b 100644 --- a/crates/inspector_ui/src/div_inspector.rs +++ b/crates/inspector_ui/src/div_inspector.rs @@ -1,5 +1,8 @@ use anyhow::{Result, anyhow}; -use editor::{Bias, CompletionProvider, Editor, EditorEvent, EditorMode, ExcerptId, MultiBuffer}; +use editor::{ + Bias, CompletionProvider, Editor, EditorEvent, EditorMode, ExcerptId, MinimapVisibility, + MultiBuffer, +}; use fuzzy::StringMatch; use gpui::{ AsyncWindowContext, DivInspectorState, Entity, InspectorElementId, IntoElement, @@ -499,6 +502,7 @@ impl DivInspector { editor.set_show_git_diff_gutter(false, cx); editor.set_show_runnables(false, cx); editor.set_show_edit_predictions(Some(false), window, cx); + editor.set_minimap_visibility(MinimapVisibility::Disabled, window, cx); editor }) } From acb3ecef0c494fa8dbc346c08f722491182a192d Mon Sep 17 00:00:00 2001 From: Oleksiy Syvokon Date: Thu, 17 Jul 2025 13:08:20 +0300 Subject: [PATCH 0015/1052] Do not send project notifications when agent creates a file (#34610) Release Notes: - N/A --- crates/assistant_tool/src/action_log.rs | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/crates/assistant_tool/src/action_log.rs b/crates/assistant_tool/src/action_log.rs index dce1b0cdc1..ecbbcc785e 100644 --- a/crates/assistant_tool/src/action_log.rs +++ b/crates/assistant_tool/src/action_log.rs @@ -331,16 +331,17 @@ impl ActionLog { .get_mut(buffer) .context("buffer not tracked")?; - if let ChangeAuthor::User = author { - tracked_buffer.has_unnotified_user_edits = true; - } - let rebase = cx.background_spawn({ let mut base_text = tracked_buffer.diff_base.clone(); let old_snapshot = tracked_buffer.snapshot.clone(); let new_snapshot = buffer_snapshot.clone(); let unreviewed_edits = tracked_buffer.unreviewed_edits.clone(); let edits = diff_snapshots(&old_snapshot, &new_snapshot); + if let ChangeAuthor::User = author + && !edits.is_empty() + { + tracked_buffer.has_unnotified_user_edits = true; + } async move { if let ChangeAuthor::User = author { apply_non_conflicting_edits( From 758c5fb9551fb7a520da1b76b0d6357ea462fcb1 Mon Sep 17 00:00:00 2001 From: Arseny Kapoulkine Date: Thu, 17 Jul 2025 03:52:26 -0700 Subject: [PATCH 0016/1052] Allow disabling snippet completion by setting `snippet_sort_order` to `none` (#34565) This mirrors VSCode setting that inspired `snippet_sort_order` to begin with; VSCode supports inline/top/bottom/none, with none completely disabling snippet completion. See https://code.visualstudio.com/docs/editing/intellisense#_snippets-in-suggestions This is helpful for LSPs that do not allow configuring snippets via configuration such as clangd. Release Notes: - Added `none` as one of the values for `snippet_sort_order` to completely disable snippet completion. --- assets/settings/default.json | 2 ++ crates/editor/src/code_context_menus.rs | 15 +++++++++++++++ crates/editor/src/editor_settings.rs | 2 ++ docs/src/configuring-zed.md | 6 ++++++ docs/src/visual-customization.md | 2 +- 5 files changed, 26 insertions(+), 1 deletion(-) diff --git a/assets/settings/default.json b/assets/settings/default.json index 32d4c496c1..2c980603bf 100644 --- a/assets/settings/default.json +++ b/assets/settings/default.json @@ -197,6 +197,8 @@ // "inline" // 3. Place snippets at the bottom of the completion list: // "bottom" + // 4. Do not show snippets in the completion list: + // "none" "snippet_sort_order": "inline", // How to highlight the current line in the editor. // diff --git a/crates/editor/src/code_context_menus.rs b/crates/editor/src/code_context_menus.rs index 8fbae8d605..c7477837dd 100644 --- a/crates/editor/src/code_context_menus.rs +++ b/crates/editor/src/code_context_menus.rs @@ -1074,6 +1074,20 @@ impl CompletionsMenu { .and_then(|q| q.chars().next()) .and_then(|c| c.to_lowercase().next()); + if snippet_sort_order == SnippetSortOrder::None { + matches.retain(|string_match| { + let completion = &completions[string_match.candidate_id]; + + let is_snippet = matches!( + &completion.source, + CompletionSource::Lsp { lsp_completion, .. } + if lsp_completion.kind == Some(CompletionItemKind::SNIPPET) + ); + + !is_snippet + }); + } + matches.sort_unstable_by_key(|string_match| { let completion = &completions[string_match.candidate_id]; @@ -1112,6 +1126,7 @@ impl CompletionsMenu { SnippetSortOrder::Top => Reverse(if is_snippet { 1 } else { 0 }), SnippetSortOrder::Bottom => Reverse(if is_snippet { 0 } else { 1 }), SnippetSortOrder::Inline => Reverse(0), + SnippetSortOrder::None => Reverse(0), }; let sort_positions = string_match.positions.clone(); let sort_exact = Reverse(if Some(completion.label.filter_text()) == query { diff --git a/crates/editor/src/editor_settings.rs b/crates/editor/src/editor_settings.rs index 5d8379ddfb..14f46c0e60 100644 --- a/crates/editor/src/editor_settings.rs +++ b/crates/editor/src/editor_settings.rs @@ -395,6 +395,8 @@ pub enum SnippetSortOrder { Inline, /// Place snippets at the bottom of the completion list Bottom, + /// Do not show snippets in the completion list + None, } #[derive(Clone, Default, Serialize, Deserialize, JsonSchema)] diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md index eec9da60dd..91a39d1ccd 100644 --- a/docs/src/configuring-zed.md +++ b/docs/src/configuring-zed.md @@ -639,6 +639,12 @@ List of `string` values "snippet_sort_order": "bottom" ``` +4. Do not show snippets in the completion list at all: + +```json +"snippet_sort_order": "none" +``` + ## Editor Scrollbar - Description: Whether or not to show the editor scrollbar and various elements in it. diff --git a/docs/src/visual-customization.md b/docs/src/visual-customization.md index 636e0f9c4e..ad38b86406 100644 --- a/docs/src/visual-customization.md +++ b/docs/src/visual-customization.md @@ -317,7 +317,7 @@ TBD: Centered layout related settings ### Editor Completions, Snippets, Actions, Diagnostics {#editor-lsp} ```json - "snippet_sort_order": "inline", // Snippets completions: top, inline, bottom + "snippet_sort_order": "inline", // Snippets completions: top, inline, bottom, none "show_completions_on_input": true, // Show completions while typing "show_completion_documentation": true, // Show documentation in completions "auto_signature_help": false, // Show method signatures inside parentheses From 1e67e30034ca2b54bb3910825b045d038bfaa310 Mon Sep 17 00:00:00 2001 From: Oleksiy Syvokon Date: Thu, 17 Jul 2025 14:21:20 +0300 Subject: [PATCH 0017/1052] Fix shortcuts with `Shift` (#34614) Closes #34605, #34606, #34609 Release Notes: - Fixed shortcuts involving Shift --- crates/gpui/src/platform/linux/platform.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/gpui/src/platform/linux/platform.rs b/crates/gpui/src/platform/linux/platform.rs index a24838339e..c4b90ccf08 100644 --- a/crates/gpui/src/platform/linux/platform.rs +++ b/crates/gpui/src/platform/linux/platform.rs @@ -837,7 +837,7 @@ impl crate::Keystroke { && key.is_ascii() { if key.is_ascii_graphic() { - key_utf8.clone() + key_utf8.to_lowercase() // map ctrl-a to a } else if key_utf32 <= 0x1f { ((key_utf32 as u8 + 0x60) as char).to_string() From 4df7f52bf3aa2e94dfbb4002a8881b08ee1ae8e1 Mon Sep 17 00:00:00 2001 From: Oleksiy Syvokon Date: Thu, 17 Jul 2025 14:55:38 +0300 Subject: [PATCH 0018/1052] agent: Disable `project_notifications` by default (#34615) This tool needs more polishing before being generally available. Release Notes: - agent: Disabled `project_notifications` tool by default for the time being --- assets/settings/default.json | 4 ++-- crates/agent/src/thread.rs | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/assets/settings/default.json b/assets/settings/default.json index 2c980603bf..358871650b 100644 --- a/assets/settings/default.json +++ b/assets/settings/default.json @@ -819,7 +819,7 @@ "edit_file": true, "fetch": true, "list_directory": true, - "project_notifications": true, + "project_notifications": false, "move_path": true, "now": true, "find_path": true, @@ -839,7 +839,7 @@ "diagnostics": true, "fetch": true, "list_directory": true, - "project_notifications": true, + "project_notifications": false, "now": true, "find_path": true, "read_file": true, diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs index d46dada270..dca0f5a430 100644 --- a/crates/agent/src/thread.rs +++ b/crates/agent/src/thread.rs @@ -3583,6 +3583,7 @@ fn main() {{ } #[gpui::test] + #[ignore] // turn this test on when project_notifications tool is re-enabled async fn test_stale_buffer_notification(cx: &mut TestAppContext) { init_test_settings(cx); From ceab139f54717aff87f2fc9175423303c61944bf Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Thu, 17 Jul 2025 15:20:47 +0300 Subject: [PATCH 0019/1052] Rework extension-related errors (#34620) Before: before After: after Makes clear which path is causing the FS error and removes backtraces from logging. Release Notes: - N/A --- crates/extension_host/src/extension_host.rs | 38 ++++++++++++++------- crates/extension_host/src/headless_host.rs | 5 ++- crates/extension_host/src/wasm_host.rs | 2 +- 3 files changed, 28 insertions(+), 17 deletions(-) diff --git a/crates/extension_host/src/extension_host.rs b/crates/extension_host/src/extension_host.rs index 075c68d51a..fd64d3fa59 100644 --- a/crates/extension_host/src/extension_host.rs +++ b/crates/extension_host/src/extension_host.rs @@ -1313,10 +1313,17 @@ impl ExtensionStore { } for snippets_path in &snippets_to_add { - if let Some(snippets_contents) = fs.load(snippets_path).await.log_err() { - proxy - .register_snippet(snippets_path, &snippets_contents) - .log_err(); + match fs + .load(snippets_path) + .await + .with_context(|| format!("Loading snippets from {snippets_path:?}")) + { + Ok(snippets_contents) => { + proxy + .register_snippet(snippets_path, &snippets_contents) + .log_err(); + } + Err(e) => log::error!("Cannot load snippets: {e:#}"), } } } @@ -1331,20 +1338,25 @@ impl ExtensionStore { let extension_path = root_dir.join(extension.manifest.id.as_ref()); let wasm_extension = WasmExtension::load( - extension_path, + &extension_path, &extension.manifest, wasm_host.clone(), &cx, ) - .await; + .await + .with_context(|| format!("Loading extension from {extension_path:?}")); - if let Some(wasm_extension) = wasm_extension.log_err() { - wasm_extensions.push((extension.manifest.clone(), wasm_extension)); - } else { - this.update(cx, |_, cx| { - cx.emit(Event::ExtensionFailedToLoad(extension.manifest.id.clone())) - }) - .ok(); + match wasm_extension { + Ok(wasm_extension) => { + wasm_extensions.push((extension.manifest.clone(), wasm_extension)) + } + Err(e) => { + log::error!("Failed to load extension: {e:#}"); + this.update(cx, |_, cx| { + cx.emit(Event::ExtensionFailedToLoad(extension.manifest.id.clone())) + }) + .ok(); + } } } diff --git a/crates/extension_host/src/headless_host.rs b/crates/extension_host/src/headless_host.rs index dbc9bbfe13..adc9638c29 100644 --- a/crates/extension_host/src/headless_host.rs +++ b/crates/extension_host/src/headless_host.rs @@ -173,9 +173,8 @@ impl HeadlessExtensionStore { return Ok(()); } - let wasm_extension: Arc = Arc::new( - WasmExtension::load(extension_dir.clone(), &manifest, wasm_host.clone(), &cx).await?, - ); + let wasm_extension: Arc = + Arc::new(WasmExtension::load(&extension_dir, &manifest, wasm_host.clone(), &cx).await?); for (language_server_id, language_server_config) in &manifest.language_servers { for language in language_server_config.languages() { diff --git a/crates/extension_host/src/wasm_host.rs b/crates/extension_host/src/wasm_host.rs index 3971fa4263..3e0f06fa38 100644 --- a/crates/extension_host/src/wasm_host.rs +++ b/crates/extension_host/src/wasm_host.rs @@ -715,7 +715,7 @@ fn parse_wasm_extension_version_custom_section(data: &[u8]) -> Option, wasm_host: Arc, cx: &AsyncApp, From 5b97cd190002c798512fd18f92f26f96e13dbdbf Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Thu, 17 Jul 2025 15:39:41 +0300 Subject: [PATCH 0020/1052] Better serialize the git panel (#34622) Follow-up of https://github.com/zed-industries/zed/pull/29874 Closes https://github.com/zed-industries/zed/issues/34618 Closes https://github.com/zed-industries/zed/issues/34611 Release Notes: - N/A --- crates/git_ui/src/git_panel.rs | 65 ++++++++++++++++++++-------------- 1 file changed, 38 insertions(+), 27 deletions(-) diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index 2397f51f82..e998586af4 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -65,6 +65,7 @@ use ui::{ ScrollbarState, SplitButton, Tooltip, prelude::*, }; use util::{ResultExt, TryFutureExt, maybe}; +use workspace::SERIALIZATION_THROTTLE_TIME; use workspace::{ Workspace, @@ -342,7 +343,7 @@ pub struct GitPanel { pending_commit: Option>, amend_pending: bool, signoff_enabled: bool, - pending_serialization: Task>, + pending_serialization: Task<()>, pub(crate) project: Entity, scroll_handle: UniformListScrollHandle, max_width_item_index: Option, @@ -518,7 +519,7 @@ impl GitPanel { pending_commit: None, amend_pending: false, signoff_enabled: false, - pending_serialization: Task::ready(None), + pending_serialization: Task::ready(()), single_staged_entry: None, single_tracked_entry: None, project, @@ -709,31 +710,41 @@ impl GitPanel { let amend_pending = self.amend_pending; let signoff_enabled = self.signoff_enabled; - let Some(serialization_key) = self - .workspace - .read_with(cx, |workspace, _| Self::serialization_key(workspace)) - .ok() - .flatten() - else { - return; - }; - - self.pending_serialization = cx.background_spawn( - async move { - KEY_VALUE_STORE - .write_kvp( - serialization_key, - serde_json::to_string(&SerializedGitPanel { - width, - amend_pending, - signoff_enabled, - })?, - ) - .await?; - anyhow::Ok(()) - } - .log_err(), - ); + self.pending_serialization = cx.spawn(async move |git_panel, cx| { + cx.background_executor() + .timer(SERIALIZATION_THROTTLE_TIME) + .await; + let Some(serialization_key) = git_panel + .update(cx, |git_panel, cx| { + git_panel + .workspace + .read_with(cx, |workspace, _| Self::serialization_key(workspace)) + .ok() + .flatten() + }) + .ok() + .flatten() + else { + return; + }; + cx.background_spawn( + async move { + KEY_VALUE_STORE + .write_kvp( + serialization_key, + serde_json::to_string(&SerializedGitPanel { + width, + amend_pending, + signoff_enabled, + })?, + ) + .await?; + anyhow::Ok(()) + } + .log_err(), + ) + .await; + }); } pub(crate) fn set_modal_open(&mut self, open: bool, cx: &mut Context) { From 8e4555455c6469b33803c8c653e38b2755ad9aad Mon Sep 17 00:00:00 2001 From: Agus Zubiaga Date: Thu, 17 Jul 2025 11:25:55 -0300 Subject: [PATCH 0021/1052] Claude experiment (#34577) Release Notes: - N/A --------- Co-authored-by: Conrad Irwin Co-authored-by: Anthony Eid Co-authored-by: Ben Brandt Co-authored-by: Nathan Sobo Co-authored-by: Oleksiy Syvokon --- Cargo.lock | 33 +- Cargo.toml | 8 +- assets/icons/ai_claude.svg | 3 + assets/keymaps/default-linux.json | 4 +- assets/keymaps/default-macos.json | 4 +- crates/{acp => acp_thread}/Cargo.toml | 9 +- crates/{acp => acp_thread}/LICENSE-GPL | 0 .../acp.rs => acp_thread/src/acp_thread.rs} | 670 +++++------------ crates/acp_thread/src/connection.rs | 20 + crates/agent_servers/Cargo.toml | 21 + crates/agent_servers/src/agent_servers.rs | 213 +----- crates/agent_servers/src/claude.rs | 680 +++++++++++++++++ crates/agent_servers/src/claude/mcp_server.rs | 303 ++++++++ crates/agent_servers/src/claude/tools.rs | 670 +++++++++++++++++ crates/agent_servers/src/gemini.rs | 501 +++++++++++++ crates/agent_servers/src/settings.rs | 41 + .../agent_servers/src/stdio_agent_server.rs | 169 +++++ crates/agent_ui/Cargo.toml | 2 +- crates/agent_ui/src/acp/thread_view.rs | 704 +++++++----------- crates/agent_ui/src/agent_diff.rs | 4 +- crates/agent_ui/src/agent_panel.rs | 152 ++-- crates/agent_ui/src/agent_ui.rs | 31 +- crates/context_server/Cargo.toml | 2 + crates/context_server/src/client.rs | 29 +- crates/context_server/src/context_server.rs | 1 + crates/context_server/src/listener.rs | 236 ++++++ crates/context_server/src/types.rs | 2 +- crates/icons/src/icons.rs | 1 + crates/nc/Cargo.toml | 20 + crates/nc/LICENSE-GPL | 1 + crates/nc/src/nc.rs | 56 ++ crates/zed/Cargo.toml | 1 + crates/zed/src/main.rs | 16 + 33 files changed, 3437 insertions(+), 1170 deletions(-) create mode 100644 assets/icons/ai_claude.svg rename crates/{acp => acp_thread}/Cargo.toml (92%) rename crates/{acp => acp_thread}/LICENSE-GPL (100%) rename crates/{acp/src/acp.rs => acp_thread/src/acp_thread.rs} (75%) create mode 100644 crates/acp_thread/src/connection.rs create mode 100644 crates/agent_servers/src/claude.rs create mode 100644 crates/agent_servers/src/claude/mcp_server.rs create mode 100644 crates/agent_servers/src/claude/tools.rs create mode 100644 crates/agent_servers/src/gemini.rs create mode 100644 crates/agent_servers/src/settings.rs create mode 100644 crates/agent_servers/src/stdio_agent_server.rs create mode 100644 crates/context_server/src/listener.rs create mode 100644 crates/nc/Cargo.toml create mode 120000 crates/nc/LICENSE-GPL create mode 100644 crates/nc/src/nc.rs diff --git a/Cargo.lock b/Cargo.lock index 59e444f1f8..540e3039ef 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3,10 +3,9 @@ version = 4 [[package]] -name = "acp" +name = "acp_thread" version = "0.1.0" dependencies = [ - "agent_servers", "agentic-coding-protocol", "anyhow", "assistant_tool", @@ -21,6 +20,7 @@ dependencies = [ "language", "markdown", "project", + "serde", "serde_json", "settings", "smol", @@ -139,16 +139,29 @@ dependencies = [ name = "agent_servers" version = "0.1.0" dependencies = [ + "acp_thread", + "agentic-coding-protocol", "anyhow", "collections", + "context_server", + "env_logger 0.11.8", "futures 0.3.31", "gpui", + "indoc", + "itertools 0.14.0", + "language", + "log", "paths", "project", "schemars", "serde", + "serde_json", "settings", + "smol", + "tempfile", + "ui", "util", + "watch", "which 6.0.3", "workspace-hack", ] @@ -176,7 +189,7 @@ dependencies = [ name = "agent_ui" version = "0.1.0" dependencies = [ - "acp", + "acp_thread", "agent", "agent_servers", "agent_settings", @@ -3411,12 +3424,14 @@ dependencies = [ "futures 0.3.31", "gpui", "log", + "net", "parking_lot", "postage", "schemars", "serde", "serde_json", "smol", + "tempfile", "url", "util", "workspace-hack", @@ -10288,6 +10303,17 @@ dependencies = [ "uuid", ] +[[package]] +name = "nc" +version = "0.1.0" +dependencies = [ + "anyhow", + "futures 0.3.31", + "net", + "smol", + "workspace-hack", +] + [[package]] name = "ndk" version = "0.8.0" @@ -20171,6 +20197,7 @@ dependencies = [ "menu", "migrator", "mimalloc", + "nc", "nix 0.29.0", "node_runtime", "notifications", diff --git a/Cargo.toml b/Cargo.toml index afb47c006e..1c79f4c1c8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,7 +2,7 @@ resolver = "2" members = [ "crates/activity_indicator", - "crates/acp", + "crates/acp_thread", "crates/agent_ui", "crates/agent", "crates/agent_settings", @@ -102,6 +102,7 @@ members = [ "crates/migrator", "crates/mistral", "crates/multi_buffer", + "crates/nc", "crates/net", "crates/node_runtime", "crates/notifications", @@ -219,7 +220,7 @@ edition = "2024" # Workspace member crates # -acp = { path = "crates/acp" } +acp_thread = { path = "crates/acp_thread" } agent = { path = "crates/agent" } activity_indicator = { path = "crates/activity_indicator" } agent_ui = { path = "crates/agent_ui" } @@ -317,6 +318,7 @@ menu = { path = "crates/menu" } migrator = { path = "crates/migrator" } mistral = { path = "crates/mistral" } multi_buffer = { path = "crates/multi_buffer" } +nc = { path = "crates/nc" } net = { path = "crates/net" } node_runtime = { path = "crates/node_runtime" } notifications = { path = "crates/notifications" } @@ -406,7 +408,7 @@ zlog_settings = { path = "crates/zlog_settings" } # External crates # -agentic-coding-protocol = { version = "0.0.9" } +agentic-coding-protocol = "0.0.9" aho-corasick = "1.1" alacritty_terminal = { git = "https://github.com/zed-industries/alacritty.git", branch = "add-hush-login-flag" } any_vec = "0.14" diff --git a/assets/icons/ai_claude.svg b/assets/icons/ai_claude.svg new file mode 100644 index 0000000000..423a963eba --- /dev/null +++ b/assets/icons/ai_claude.svg @@ -0,0 +1,3 @@ + + + diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index da4d79eca1..b52b6c614d 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -269,10 +269,10 @@ } }, { - "context": "AgentPanel && acp_thread", + "context": "AgentPanel && external_agent_thread", "use_key_equivalents": true, "bindings": { - "ctrl-n": "agent::NewAcpThread", + "ctrl-n": "agent::NewExternalAgentThread", "ctrl-alt-t": "agent::NewThread" } }, diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index 962760098b..240b42fd1f 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -310,10 +310,10 @@ } }, { - "context": "AgentPanel && acp_thread", + "context": "AgentPanel && external_agent_thread", "use_key_equivalents": true, "bindings": { - "cmd-n": "agent::NewAcpThread", + "cmd-n": "agent::NewExternalAgentThread", "cmd-alt-t": "agent::NewThread" } }, diff --git a/crates/acp/Cargo.toml b/crates/acp_thread/Cargo.toml similarity index 92% rename from crates/acp/Cargo.toml rename to crates/acp_thread/Cargo.toml index 1570aeaef0..b44c25ccc9 100644 --- a/crates/acp/Cargo.toml +++ b/crates/acp_thread/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "acp" +name = "acp_thread" version = "0.1.0" edition.workspace = true publish.workspace = true @@ -9,15 +9,13 @@ license = "GPL-3.0-or-later" workspace = true [lib] -path = "src/acp.rs" +path = "src/acp_thread.rs" doctest = false [features] test-support = ["gpui/test-support", "project/test-support"] -gemini = [] [dependencies] -agent_servers.workspace = true agentic-coding-protocol.workspace = true anyhow.workspace = true assistant_tool.workspace = true @@ -29,6 +27,8 @@ itertools.workspace = true language.workspace = true markdown.workspace = true project.workspace = true +serde.workspace = true +serde_json.workspace = true settings.workspace = true smol.workspace = true ui.workspace = true @@ -41,7 +41,6 @@ env_logger.workspace = true gpui = { workspace = true, "features" = ["test-support"] } indoc.workspace = true project = { workspace = true, "features" = ["test-support"] } -serde_json.workspace = true tempfile.workspace = true util.workspace = true settings.workspace = true diff --git a/crates/acp/LICENSE-GPL b/crates/acp_thread/LICENSE-GPL similarity index 100% rename from crates/acp/LICENSE-GPL rename to crates/acp_thread/LICENSE-GPL diff --git a/crates/acp/src/acp.rs b/crates/acp_thread/src/acp_thread.rs similarity index 75% rename from crates/acp/src/acp.rs rename to crates/acp_thread/src/acp_thread.rs index a7e72b0c2d..1e3947351a 100644 --- a/crates/acp/src/acp.rs +++ b/crates/acp_thread/src/acp_thread.rs @@ -1,7 +1,12 @@ +mod connection; +pub use connection::*; + pub use acp::ToolCallId; -use agent_servers::AgentServer; -use agentic_coding_protocol::{self as acp, ToolCallLocation, UserMessageChunk}; -use anyhow::{Context as _, Result, anyhow}; +use agentic_coding_protocol::{ + self as acp, AgentRequest, ProtocolVersion, ToolCallConfirmationOutcome, ToolCallLocation, + UserMessageChunk, +}; +use anyhow::{Context as _, Result}; use assistant_tool::ActionLog; use buffer_diff::BufferDiff; use editor::{Bias, MultiBuffer, PathKey}; @@ -97,7 +102,7 @@ pub struct AssistantMessage { } impl AssistantMessage { - fn to_markdown(&self, cx: &App) -> String { + pub fn to_markdown(&self, cx: &App) -> String { format!( "## Assistant\n\n{}\n\n", self.chunks @@ -455,9 +460,8 @@ pub struct AcpThread { action_log: Entity, shared_buffers: HashMap, BufferSnapshot>, send_task: Option>, - connection: Arc, + connection: Arc, child_status: Option>>, - _io_task: Task<()>, } pub enum AcpThreadEvent { @@ -476,7 +480,11 @@ pub enum ThreadStatus { #[derive(Debug, Clone)] pub enum LoadError { - Unsupported { current_version: SharedString }, + Unsupported { + error_message: SharedString, + upgrade_message: SharedString, + upgrade_command: String, + }, Exited(i32), Other(SharedString), } @@ -484,13 +492,7 @@ pub enum LoadError { impl Display for LoadError { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { match self { - LoadError::Unsupported { current_version } => { - write!( - f, - "Your installed version of Gemini {} doesn't support the Agentic Coding Protocol (ACP).", - current_version - ) - } + LoadError::Unsupported { error_message, .. } => write!(f, "{}", error_message), LoadError::Exited(status) => write!(f, "Server exited with status {}", status), LoadError::Other(msg) => write!(f, "{}", msg), } @@ -500,75 +502,38 @@ impl Display for LoadError { impl Error for LoadError {} impl AcpThread { - pub async fn spawn( - server: impl AgentServer + 'static, - root_dir: &Path, + pub fn new( + connection: impl AgentConnection + 'static, + title: SharedString, + child_status: Option>>, project: Entity, - cx: &mut AsyncApp, - ) -> Result> { - let command = match server.command(&project, cx).await { - Ok(command) => command, - Err(e) => return Err(anyhow!(LoadError::Other(format!("{e}").into()))), - }; + cx: &mut Context, + ) -> Self { + let action_log = cx.new(|_| ActionLog::new(project.clone())); - let mut child = util::command::new_smol_command(&command.path) - .args(command.args.iter()) - .current_dir(root_dir) - .stdin(std::process::Stdio::piped()) - .stdout(std::process::Stdio::piped()) - .stderr(std::process::Stdio::inherit()) - .kill_on_drop(true) - .spawn()?; + Self { + action_log, + shared_buffers: Default::default(), + entries: Default::default(), + title, + project, + send_task: None, + connection: Arc::new(connection), + child_status, + } + } - let stdin = child.stdin.take().unwrap(); - let stdout = child.stdout.take().unwrap(); - - cx.new(|cx| { - let foreground_executor = cx.foreground_executor().clone(); - - let (connection, io_fut) = acp::AgentConnection::connect_to_agent( - AcpClientDelegate::new(cx.entity().downgrade(), cx.to_async()), - stdin, - stdout, - move |fut| foreground_executor.spawn(fut).detach(), - ); - - let io_task = cx.background_spawn(async move { - io_fut.await.log_err(); - }); - - let child_status = cx.background_spawn(async move { - match child.status().await { - Err(e) => Err(anyhow!(e)), - Ok(result) if result.success() => Ok(()), - Ok(result) => { - if let Some(version) = server.version(&command).await.log_err() - && !version.supported - { - Err(anyhow!(LoadError::Unsupported { - current_version: version.current_version - })) - } else { - Err(anyhow!(LoadError::Exited(result.code().unwrap_or(-127)))) - } - } - } - }); - - let action_log = cx.new(|_| ActionLog::new(project.clone())); - - Self { - action_log, - shared_buffers: Default::default(), - entries: Default::default(), - title: "ACP Thread".into(), - project, - send_task: None, - connection: Arc::new(connection), - child_status: Some(child_status), - _io_task: io_task, - } - }) + /// Send a request to the agent and wait for a response. + pub fn request( + &self, + params: R, + ) -> impl use + Future> { + let params = params.into_any(); + let result = self.connection.request_any(params); + async move { + let result = result.await?; + Ok(R::response_from_any(result)?) + } } pub fn action_log(&self) -> &Entity { @@ -579,45 +544,6 @@ impl AcpThread { &self.project } - #[cfg(test)] - pub fn fake( - stdin: async_pipe::PipeWriter, - stdout: async_pipe::PipeReader, - project: Entity, - cx: &mut Context, - ) -> Self { - let foreground_executor = cx.foreground_executor().clone(); - - let (connection, io_fut) = acp::AgentConnection::connect_to_agent( - AcpClientDelegate::new(cx.entity().downgrade(), cx.to_async()), - stdin, - stdout, - move |fut| { - foreground_executor.spawn(fut).detach(); - }, - ); - - let io_task = cx.background_spawn({ - async move { - io_fut.await.log_err(); - } - }); - - let action_log = cx.new(|_| ActionLog::new(project.clone())); - - Self { - action_log, - shared_buffers: Default::default(), - entries: Default::default(), - title: "ACP Thread".into(), - project, - send_task: None, - connection: Arc::new(connection), - child_status: None, - _io_task: io_task, - } - } - pub fn title(&self) -> SharedString { self.title.clone() } @@ -711,7 +637,7 @@ impl AcpThread { } } - pub fn request_tool_call( + pub fn request_new_tool_call( &mut self, tool_call: acp::RequestToolCallConfirmationParams, cx: &mut Context, @@ -731,6 +657,30 @@ impl AcpThread { ToolCallRequest { id, outcome: rx } } + pub fn request_tool_call_confirmation( + &mut self, + tool_call_id: ToolCallId, + confirmation: acp::ToolCallConfirmation, + cx: &mut Context, + ) -> Result { + let project = self.project.read(cx).languages().clone(); + let Some((_, call)) = self.tool_call_mut(tool_call_id) else { + anyhow::bail!("Tool call not found"); + }; + + let (tx, rx) = oneshot::channel(); + + call.status = ToolCallStatus::WaitingForConfirmation { + confirmation: ToolCallConfirmation::from_acp(confirmation, project, cx), + respond_tx: tx, + }; + + Ok(ToolCallRequest { + id: tool_call_id, + outcome: rx, + }) + } + pub fn push_tool_call( &mut self, request: acp::PushToolCallParams, @@ -912,19 +862,17 @@ impl AcpThread { false } - pub fn initialize( - &self, - ) -> impl use<> + Future> { - let connection = self.connection.clone(); - async move { connection.initialize().await } + pub fn initialize(&self) -> impl use<> + Future> { + self.request(acp::InitializeParams { + protocol_version: ProtocolVersion::latest(), + }) } - pub fn authenticate(&self) -> impl use<> + Future> { - let connection = self.connection.clone(); - async move { connection.request(acp::AuthenticateParams).await } + pub fn authenticate(&self) -> impl use<> + Future> { + self.request(acp::AuthenticateParams) } - #[cfg(test)] + #[cfg(any(test, feature = "test-support"))] pub fn send_raw( &mut self, message: &str, @@ -945,7 +893,6 @@ impl AcpThread { message: acp::SendUserMessageParams, cx: &mut Context, ) -> BoxFuture<'static, Result<(), acp::Error>> { - let agent = self.connection.clone(); self.push_entry( AgentThreadEntry::UserMessage(UserMessage::from_acp( &message, @@ -959,11 +906,16 @@ impl AcpThread { let cancel = self.cancel(cx); self.send_task = Some(cx.spawn(async move |this, cx| { - cancel.await.log_err(); + async { + cancel.await.log_err(); - let result = agent.request(message).await; - tx.send(result).log_err(); - this.update(cx, |this, _cx| this.send_task.take()).log_err(); + let result = this.update(cx, |this, _| this.request(message))?.await; + tx.send(result).log_err(); + this.update(cx, |this, _cx| this.send_task.take())?; + anyhow::Ok(()) + } + .await + .log_err(); })); async move { @@ -976,12 +928,10 @@ impl AcpThread { } pub fn cancel(&mut self, cx: &mut Context) -> Task> { - let agent = self.connection.clone(); - if self.send_task.take().is_some() { + let request = self.request(acp::CancelSendMessageParams); cx.spawn(async move |this, cx| { - agent.request(acp::CancelSendMessageParams).await?; - + request.await?; this.update(cx, |this, _cx| { for entry in this.entries.iter_mut() { if let AgentThreadEntry::ToolCall(call) = entry { @@ -1019,6 +969,7 @@ impl AcpThread { pub fn read_text_file( &self, request: acp::ReadTextFileParams, + reuse_shared_snapshot: bool, cx: &mut Context, ) -> Task> { let project = self.project.clone(); @@ -1032,28 +983,60 @@ impl AcpThread { }); let buffer = load??.await?; - action_log.update(cx, |action_log, cx| { - action_log.buffer_read(buffer.clone(), cx); - })?; - project.update(cx, |project, cx| { - let position = buffer - .read(cx) - .snapshot() - .anchor_before(Point::new(request.line.unwrap_or_default(), 0)); - project.set_agent_location( - Some(AgentLocation { - buffer: buffer.downgrade(), - position, - }), - cx, - ); - })?; - let snapshot = buffer.update(cx, |buffer, _| buffer.snapshot())?; + let snapshot = if reuse_shared_snapshot { + this.read_with(cx, |this, _| { + this.shared_buffers.get(&buffer.clone()).cloned() + }) + .log_err() + .flatten() + } else { + None + }; + + let snapshot = if let Some(snapshot) = snapshot { + snapshot + } else { + action_log.update(cx, |action_log, cx| { + action_log.buffer_read(buffer.clone(), cx); + })?; + project.update(cx, |project, cx| { + let position = buffer + .read(cx) + .snapshot() + .anchor_before(Point::new(request.line.unwrap_or_default(), 0)); + project.set_agent_location( + Some(AgentLocation { + buffer: buffer.downgrade(), + position, + }), + cx, + ); + })?; + + buffer.update(cx, |buffer, _| buffer.snapshot())? + }; + this.update(cx, |this, _| { let text = snapshot.text(); this.shared_buffers.insert(buffer.clone(), snapshot); - text - }) + if request.line.is_none() && request.limit.is_none() { + return Ok(text); + } + let limit = request.limit.unwrap_or(u32::MAX) as usize; + let Some(line) = request.line else { + return Ok(text.lines().take(limit).collect::()); + }; + + let count = text.lines().count(); + if count < line as usize { + anyhow::bail!("There are only {} lines", count); + } + Ok(text + .lines() + .skip(line as usize + 1) + .take(limit) + .collect::()) + })? }) } @@ -1134,16 +1117,49 @@ impl AcpThread { } } -struct AcpClientDelegate { +#[derive(Clone)] +pub struct AcpClientDelegate { thread: WeakEntity, cx: AsyncApp, // sent_buffer_versions: HashMap, HashMap>, } impl AcpClientDelegate { - fn new(thread: WeakEntity, cx: AsyncApp) -> Self { + pub fn new(thread: WeakEntity, cx: AsyncApp) -> Self { Self { thread, cx } } + + pub async fn request_existing_tool_call_confirmation( + &self, + tool_call_id: ToolCallId, + confirmation: acp::ToolCallConfirmation, + ) -> Result { + let cx = &mut self.cx.clone(); + let ToolCallRequest { outcome, .. } = cx + .update(|cx| { + self.thread.update(cx, |thread, cx| { + thread.request_tool_call_confirmation(tool_call_id, confirmation, cx) + }) + })? + .context("Failed to update thread")??; + + Ok(outcome.await?) + } + + pub async fn read_text_file_reusing_snapshot( + &self, + request: acp::ReadTextFileParams, + ) -> Result { + let content = self + .cx + .update(|cx| { + self.thread + .update(cx, |thread, cx| thread.read_text_file(request, true, cx)) + })? + .context("Failed to update thread")? + .await?; + Ok(acp::ReadTextFileResponse { content }) + } } impl acp::Client for AcpClientDelegate { @@ -1172,7 +1188,7 @@ impl acp::Client for AcpClientDelegate { let ToolCallRequest { id, outcome } = cx .update(|cx| { self.thread - .update(cx, |thread, cx| thread.request_tool_call(request, cx)) + .update(cx, |thread, cx| thread.request_new_tool_call(request, cx)) })? .context("Failed to update thread")?; @@ -1218,7 +1234,7 @@ impl acp::Client for AcpClientDelegate { .cx .update(|cx| { self.thread - .update(cx, |thread, cx| thread.read_text_file(request, cx)) + .update(cx, |thread, cx| thread.read_text_file(request, false, cx)) })? .context("Failed to update thread")? .await?; @@ -1260,7 +1276,7 @@ pub struct ToolCallRequest { #[cfg(test)] mod tests { use super::*; - use agent_servers::{AgentServerCommand, AgentServerVersion}; + use anyhow::anyhow; use async_pipe::{PipeReader, PipeWriter}; use futures::{channel::mpsc, future::LocalBoxFuture, select}; use gpui::{AsyncApp, TestAppContext}; @@ -1269,7 +1285,7 @@ mod tests { use serde_json::json; use settings::SettingsStore; use smol::{future::BoxedLocal, stream::StreamExt as _}; - use std::{cell::RefCell, env, path::Path, rc::Rc, time::Duration}; + use std::{cell::RefCell, rc::Rc, time::Duration}; use util::path; fn init_test(cx: &mut TestAppContext) { @@ -1515,265 +1531,6 @@ mod tests { }); } - #[gpui::test] - #[cfg_attr(not(feature = "gemini"), ignore)] - async fn test_gemini_basic(cx: &mut TestAppContext) { - init_test(cx); - - cx.executor().allow_parking(); - - let fs = FakeFs::new(cx.executor()); - let project = Project::test(fs, [], cx).await; - let thread = gemini_acp_thread(project.clone(), "/private/tmp", cx).await; - thread - .update(cx, |thread, cx| thread.send_raw("Hello from Zed!", cx)) - .await - .unwrap(); - - thread.read_with(cx, |thread, _| { - assert_eq!(thread.entries.len(), 2); - assert!(matches!( - thread.entries[0], - AgentThreadEntry::UserMessage(_) - )); - assert!(matches!( - thread.entries[1], - AgentThreadEntry::AssistantMessage(_) - )); - }); - } - - #[gpui::test] - #[cfg_attr(not(feature = "gemini"), ignore)] - async fn test_gemini_path_mentions(cx: &mut TestAppContext) { - init_test(cx); - - cx.executor().allow_parking(); - let tempdir = tempfile::tempdir().unwrap(); - std::fs::write( - tempdir.path().join("foo.rs"), - indoc! {" - fn main() { - println!(\"Hello, world!\"); - } - "}, - ) - .expect("failed to write file"); - let project = Project::example([tempdir.path()], &mut cx.to_async()).await; - let thread = gemini_acp_thread(project.clone(), tempdir.path(), cx).await; - thread - .update(cx, |thread, cx| { - thread.send( - acp::SendUserMessageParams { - chunks: vec![ - acp::UserMessageChunk::Text { - text: "Read the file ".into(), - }, - acp::UserMessageChunk::Path { - path: Path::new("foo.rs").into(), - }, - acp::UserMessageChunk::Text { - text: " and tell me what the content of the println! is".into(), - }, - ], - }, - cx, - ) - }) - .await - .unwrap(); - - thread.read_with(cx, |thread, cx| { - assert_eq!(thread.entries.len(), 3); - assert!(matches!( - thread.entries[0], - AgentThreadEntry::UserMessage(_) - )); - assert!(matches!(thread.entries[1], AgentThreadEntry::ToolCall(_))); - let AgentThreadEntry::AssistantMessage(assistant_message) = &thread.entries[2] else { - panic!("Expected AssistantMessage") - }; - assert!( - assistant_message.to_markdown(cx).contains("Hello, world!"), - "unexpected assistant message: {:?}", - assistant_message.to_markdown(cx) - ); - }); - } - - #[gpui::test] - #[cfg_attr(not(feature = "gemini"), ignore)] - async fn test_gemini_tool_call(cx: &mut TestAppContext) { - init_test(cx); - - cx.executor().allow_parking(); - - let fs = FakeFs::new(cx.executor()); - fs.insert_tree( - path!("/private/tmp"), - json!({"foo": "Lorem ipsum dolor", "bar": "bar", "baz": "baz"}), - ) - .await; - let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await; - let thread = gemini_acp_thread(project.clone(), "/private/tmp", cx).await; - thread - .update(cx, |thread, cx| { - thread.send_raw( - "Read the '/private/tmp/foo' file and tell me what you see.", - cx, - ) - }) - .await - .unwrap(); - thread.read_with(cx, |thread, _cx| { - assert!(matches!( - &thread.entries()[2], - AgentThreadEntry::ToolCall(ToolCall { - status: ToolCallStatus::Allowed { .. }, - .. - }) - )); - - assert!(matches!( - thread.entries[3], - AgentThreadEntry::AssistantMessage(_) - )); - }); - } - - #[gpui::test] - #[cfg_attr(not(feature = "gemini"), ignore)] - async fn test_gemini_tool_call_with_confirmation(cx: &mut TestAppContext) { - init_test(cx); - - cx.executor().allow_parking(); - - let fs = FakeFs::new(cx.executor()); - let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await; - let thread = gemini_acp_thread(project.clone(), "/private/tmp", cx).await; - let full_turn = thread.update(cx, |thread, cx| { - thread.send_raw(r#"Run `echo "Hello, world!"`"#, cx) - }); - - run_until_first_tool_call(&thread, cx).await; - - let tool_call_id = thread.read_with(cx, |thread, _cx| { - let AgentThreadEntry::ToolCall(ToolCall { - id, - status: - ToolCallStatus::WaitingForConfirmation { - confirmation: ToolCallConfirmation::Execute { root_command, .. }, - .. - }, - .. - }) = &thread.entries()[2] - else { - panic!(); - }; - - assert_eq!(root_command, "echo"); - - *id - }); - - thread.update(cx, |thread, cx| { - thread.authorize_tool_call(tool_call_id, acp::ToolCallConfirmationOutcome::Allow, cx); - - assert!(matches!( - &thread.entries()[2], - AgentThreadEntry::ToolCall(ToolCall { - status: ToolCallStatus::Allowed { .. }, - .. - }) - )); - }); - - full_turn.await.unwrap(); - - thread.read_with(cx, |thread, cx| { - let AgentThreadEntry::ToolCall(ToolCall { - content: Some(ToolCallContent::Markdown { markdown }), - status: ToolCallStatus::Allowed { .. }, - .. - }) = &thread.entries()[2] - else { - panic!(); - }; - - markdown.read_with(cx, |md, _cx| { - assert!( - md.source().contains("Hello, world!"), - r#"Expected '{}' to contain "Hello, world!""#, - md.source() - ); - }); - }); - } - - #[gpui::test] - #[cfg_attr(not(feature = "gemini"), ignore)] - async fn test_gemini_cancel(cx: &mut TestAppContext) { - init_test(cx); - - cx.executor().allow_parking(); - - let fs = FakeFs::new(cx.executor()); - let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await; - let thread = gemini_acp_thread(project.clone(), "/private/tmp", cx).await; - let full_turn = thread.update(cx, |thread, cx| { - thread.send_raw(r#"Run `echo "Hello, world!"`"#, cx) - }); - - let first_tool_call_ix = run_until_first_tool_call(&thread, cx).await; - - thread.read_with(cx, |thread, _cx| { - let AgentThreadEntry::ToolCall(ToolCall { - id, - status: - ToolCallStatus::WaitingForConfirmation { - confirmation: ToolCallConfirmation::Execute { root_command, .. }, - .. - }, - .. - }) = &thread.entries()[first_tool_call_ix] - else { - panic!("{:?}", thread.entries()[1]); - }; - - assert_eq!(root_command, "echo"); - - *id - }); - - thread - .update(cx, |thread, cx| thread.cancel(cx)) - .await - .unwrap(); - full_turn.await.unwrap(); - thread.read_with(cx, |thread, _| { - let AgentThreadEntry::ToolCall(ToolCall { - status: ToolCallStatus::Canceled, - .. - }) = &thread.entries()[first_tool_call_ix] - else { - panic!(); - }; - }); - - thread - .update(cx, |thread, cx| { - thread.send_raw(r#"Stop running and say goodbye to me."#, cx) - }) - .await - .unwrap(); - thread.read_with(cx, |thread, _| { - assert!(matches!( - &thread.entries().last().unwrap(), - AgentThreadEntry::AssistantMessage(..), - )) - }); - } - async fn run_until_first_tool_call( thread: &Entity, cx: &mut TestAppContext, @@ -1801,66 +1558,39 @@ mod tests { } } - pub async fn gemini_acp_thread( - project: Entity, - current_dir: impl AsRef, - cx: &mut TestAppContext, - ) -> Entity { - struct DevGemini; - - impl agent_servers::AgentServer for DevGemini { - async fn command( - &self, - _project: &Entity, - _cx: &mut AsyncApp, - ) -> Result { - let cli_path = Path::new(env!("CARGO_MANIFEST_DIR")) - .join("../../../gemini-cli/packages/cli") - .to_string_lossy() - .to_string(); - - Ok(AgentServerCommand { - path: "node".into(), - args: vec![cli_path, "--experimental-acp".into()], - env: None, - }) - } - - async fn version( - &self, - _command: &agent_servers::AgentServerCommand, - ) -> Result { - Ok(AgentServerVersion { - current_version: "0.1.0".into(), - supported: true, - }) - } - } - - let thread = AcpThread::spawn(DevGemini, current_dir.as_ref(), project, &mut cx.to_async()) - .await - .unwrap(); - - thread - .update(cx, |thread, _| thread.initialize()) - .await - .unwrap(); - thread - } - pub fn fake_acp_thread( project: Entity, cx: &mut TestAppContext, ) -> (Entity, Entity) { let (stdin_tx, stdin_rx) = async_pipe::pipe(); let (stdout_tx, stdout_rx) = async_pipe::pipe(); - let thread = cx.update(|cx| cx.new(|cx| AcpThread::fake(stdin_tx, stdout_rx, project, cx))); + + let thread = cx.new(|cx| { + let foreground_executor = cx.foreground_executor().clone(); + let (connection, io_fut) = acp::AgentConnection::connect_to_agent( + AcpClientDelegate::new(cx.entity().downgrade(), cx.to_async()), + stdin_tx, + stdout_rx, + move |fut| { + foreground_executor.spawn(fut).detach(); + }, + ); + + let io_task = cx.background_spawn({ + async move { + io_fut.await.log_err(); + Ok(()) + } + }); + AcpThread::new(connection, "Test".into(), Some(io_task), project, cx) + }); let agent = cx.update(|cx| cx.new(|cx| FakeAcpServer::new(stdin_rx, stdout_tx, cx))); (thread, agent) } pub struct FakeAcpServer { connection: acp::ClientConnection, + _io_task: Task<()>, on_user_message: Option< Rc< diff --git a/crates/acp_thread/src/connection.rs b/crates/acp_thread/src/connection.rs new file mode 100644 index 0000000000..7c0ba4f41c --- /dev/null +++ b/crates/acp_thread/src/connection.rs @@ -0,0 +1,20 @@ +use agentic_coding_protocol as acp; +use anyhow::Result; +use futures::future::{FutureExt as _, LocalBoxFuture}; + +pub trait AgentConnection { + fn request_any( + &self, + params: acp::AnyAgentRequest, + ) -> LocalBoxFuture<'static, Result>; +} + +impl AgentConnection for acp::AgentConnection { + fn request_any( + &self, + params: acp::AnyAgentRequest, + ) -> LocalBoxFuture<'static, Result> { + let task = self.request_any(params); + async move { Ok(task.await?) }.boxed_local() + } +} diff --git a/crates/agent_servers/Cargo.toml b/crates/agent_servers/Cargo.toml index 549162c5dd..d65235aee3 100644 --- a/crates/agent_servers/Cargo.toml +++ b/crates/agent_servers/Cargo.toml @@ -5,6 +5,10 @@ edition.workspace = true publish.workspace = true license = "GPL-3.0-or-later" +[features] +test-support = ["acp_thread/test-support", "gpui/test-support", "project/test-support"] +gemini = [] + [lints] workspace = true @@ -13,15 +17,32 @@ path = "src/agent_servers.rs" doctest = false [dependencies] +acp_thread.workspace = true +agentic-coding-protocol.workspace = true anyhow.workspace = true collections.workspace = true +context_server.workspace = true futures.workspace = true gpui.workspace = true +itertools.workspace = true +log.workspace = true paths.workspace = true project.workspace = true schemars.workspace = true serde.workspace = true +serde_json.workspace = true settings.workspace = true +smol.workspace = true +tempfile.workspace = true +ui.workspace = true util.workspace = true +watch.workspace = true which.workspace = true workspace-hack.workspace = true + +[dev-dependencies] +env_logger.workspace = true +language.workspace = true +indoc.workspace = true +acp_thread = { workspace = true, features = ["test-support"] } +gpui = { workspace = true, features = ["test-support"] } diff --git a/crates/agent_servers/src/agent_servers.rs b/crates/agent_servers/src/agent_servers.rs index ba43122570..ebebeca511 100644 --- a/crates/agent_servers/src/agent_servers.rs +++ b/crates/agent_servers/src/agent_servers.rs @@ -1,30 +1,24 @@ -use std::{ - path::{Path, PathBuf}, - sync::Arc, -}; +mod claude; +mod gemini; +mod settings; +mod stdio_agent_server; -use anyhow::{Context as _, Result}; +pub use claude::*; +pub use gemini::*; +pub use settings::*; +pub use stdio_agent_server::*; + +use acp_thread::AcpThread; +use anyhow::Result; use collections::HashMap; -use gpui::{App, AsyncApp, Entity, SharedString}; +use gpui::{App, Entity, SharedString, Task}; use project::Project; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; -use settings::{Settings, SettingsSources, SettingsStore}; -use util::{ResultExt, paths}; +use std::path::{Path, PathBuf}; pub fn init(cx: &mut App) { - AllAgentServersSettings::register(cx); -} - -#[derive(Default, Deserialize, Serialize, Clone, JsonSchema, Debug)] -pub struct AllAgentServersSettings { - gemini: Option, -} - -#[derive(Deserialize, Serialize, Clone, JsonSchema, Debug)] -pub struct AgentServerSettings { - #[serde(flatten)] - command: AgentServerCommand, + settings::init(cx); } #[derive(Deserialize, Serialize, Clone, PartialEq, Eq, JsonSchema)] @@ -36,153 +30,28 @@ pub struct AgentServerCommand { pub env: Option>, } -pub struct Gemini; - -pub struct AgentServerVersion { - pub current_version: SharedString, - pub supported: bool, +pub enum AgentServerVersion { + Supported, + Unsupported { + error_message: SharedString, + upgrade_message: SharedString, + upgrade_command: String, + }, } pub trait AgentServer: Send { - fn command( + fn logo(&self) -> ui::IconName; + fn name(&self) -> &'static str; + fn empty_state_headline(&self) -> &'static str; + fn empty_state_message(&self) -> &'static str; + fn supports_always_allow(&self) -> bool; + + fn new_thread( &self, + root_dir: &Path, project: &Entity, - cx: &mut AsyncApp, - ) -> impl Future>; - - fn version( - &self, - command: &AgentServerCommand, - ) -> impl Future> + Send; -} - -const GEMINI_ACP_ARG: &str = "--experimental-acp"; - -impl AgentServer for Gemini { - async fn command( - &self, - project: &Entity, - cx: &mut AsyncApp, - ) -> Result { - let custom_command = cx.read_global(|settings: &SettingsStore, _| { - let settings = settings.get::(None); - settings - .gemini - .as_ref() - .map(|gemini_settings| AgentServerCommand { - path: gemini_settings.command.path.clone(), - args: gemini_settings - .command - .args - .iter() - .cloned() - .chain(std::iter::once(GEMINI_ACP_ARG.into())) - .collect(), - env: gemini_settings.command.env.clone(), - }) - })?; - - if let Some(custom_command) = custom_command { - return Ok(custom_command); - } - - if let Some(path) = find_bin_in_path("gemini", project, cx).await { - return Ok(AgentServerCommand { - path, - args: vec![GEMINI_ACP_ARG.into()], - env: None, - }); - } - - let (fs, node_runtime) = project.update(cx, |project, _| { - (project.fs().clone(), project.node_runtime().cloned()) - })?; - let node_runtime = node_runtime.context("gemini not found on path")?; - - let directory = ::paths::agent_servers_dir().join("gemini"); - fs.create_dir(&directory).await?; - node_runtime - .npm_install_packages(&directory, &[("@google/gemini-cli", "latest")]) - .await?; - let path = directory.join("node_modules/.bin/gemini"); - - Ok(AgentServerCommand { - path, - args: vec![GEMINI_ACP_ARG.into()], - env: None, - }) - } - - async fn version(&self, command: &AgentServerCommand) -> Result { - let version_fut = util::command::new_smol_command(&command.path) - .args(command.args.iter()) - .arg("--version") - .kill_on_drop(true) - .output(); - - let help_fut = util::command::new_smol_command(&command.path) - .args(command.args.iter()) - .arg("--help") - .kill_on_drop(true) - .output(); - - let (version_output, help_output) = futures::future::join(version_fut, help_fut).await; - - let current_version = String::from_utf8(version_output?.stdout)?.into(); - let supported = String::from_utf8(help_output?.stdout)?.contains(GEMINI_ACP_ARG); - - Ok(AgentServerVersion { - current_version, - supported, - }) - } -} - -async fn find_bin_in_path( - bin_name: &'static str, - project: &Entity, - cx: &mut AsyncApp, -) -> Option { - let (env_task, root_dir) = project - .update(cx, |project, cx| { - let worktree = project.visible_worktrees(cx).next(); - match worktree { - Some(worktree) => { - let env_task = project.environment().update(cx, |env, cx| { - env.get_worktree_environment(worktree.clone(), cx) - }); - - let path = worktree.read(cx).abs_path(); - (env_task, path) - } - None => { - let path: Arc = paths::home_dir().as_path().into(); - let env_task = project.environment().update(cx, |env, cx| { - env.get_directory_environment(path.clone(), cx) - }); - (env_task, path) - } - } - }) - .log_err()?; - - cx.background_executor() - .spawn(async move { - let which_result = if cfg!(windows) { - which::which(bin_name) - } else { - let env = env_task.await.unwrap_or_default(); - let shell_path = env.get("PATH").cloned(); - which::which_in(bin_name, shell_path.as_ref(), root_dir.as_ref()) - }; - - if let Err(which::Error::CannotFindBinaryPath) = which_result { - return None; - } - - which_result.log_err() - }) - .await + cx: &mut App, + ) -> Task>>; } impl std::fmt::Debug for AgentServerCommand { @@ -209,23 +78,3 @@ impl std::fmt::Debug for AgentServerCommand { .finish() } } - -impl settings::Settings for AllAgentServersSettings { - const KEY: Option<&'static str> = Some("agent_servers"); - - type FileContent = Self; - - fn load(sources: SettingsSources, _: &mut App) -> Result { - let mut settings = AllAgentServersSettings::default(); - - for value in sources.defaults_and_customizations() { - if value.gemini.is_some() { - settings.gemini = value.gemini.clone(); - } - } - - Ok(settings) - } - - fn import_from_vscode(_vscode: &settings::VsCodeSettings, _current: &mut Self::FileContent) {} -} diff --git a/crates/agent_servers/src/claude.rs b/crates/agent_servers/src/claude.rs new file mode 100644 index 0000000000..897158dc57 --- /dev/null +++ b/crates/agent_servers/src/claude.rs @@ -0,0 +1,680 @@ +mod mcp_server; +mod tools; + +use collections::HashMap; +use project::Project; +use std::cell::RefCell; +use std::fmt::Display; +use std::path::Path; +use std::rc::Rc; + +use agentic_coding_protocol::{ + self as acp, AnyAgentRequest, AnyAgentResult, Client, ProtocolVersion, + StreamAssistantMessageChunkParams, ToolCallContent, UpdateToolCallParams, +}; +use anyhow::{Context as _, Result, anyhow}; +use futures::channel::oneshot; +use futures::future::LocalBoxFuture; +use futures::{AsyncBufReadExt, AsyncWriteExt}; +use futures::{ + AsyncRead, AsyncWrite, FutureExt, StreamExt, + channel::mpsc::{self, UnboundedReceiver, UnboundedSender}, + io::BufReader, + select_biased, +}; +use gpui::{App, AppContext, Entity, Task}; +use serde::{Deserialize, Serialize}; +use util::ResultExt; + +use crate::claude::mcp_server::ClaudeMcpServer; +use crate::claude::tools::ClaudeTool; +use crate::{AgentServer, find_bin_in_path}; +use acp_thread::{AcpClientDelegate, AcpThread, AgentConnection}; + +#[derive(Clone)] +pub struct ClaudeCode; + +impl AgentServer for ClaudeCode { + fn name(&self) -> &'static str { + "Claude Code" + } + + fn empty_state_headline(&self) -> &'static str { + self.name() + } + + fn empty_state_message(&self) -> &'static str { + "" + } + + fn logo(&self) -> ui::IconName { + ui::IconName::AiClaude + } + + fn supports_always_allow(&self) -> bool { + false + } + + fn new_thread( + &self, + root_dir: &Path, + project: &Entity, + cx: &mut App, + ) -> Task>> { + let project = project.clone(); + let root_dir = root_dir.to_path_buf(); + let title = self.name().into(); + cx.spawn(async move |cx| { + let (mut delegate_tx, delegate_rx) = watch::channel(None); + let tool_id_map = Rc::new(RefCell::new(HashMap::default())); + + let permission_mcp_server = + ClaudeMcpServer::new(delegate_rx, tool_id_map.clone(), cx).await?; + + let mut mcp_servers = HashMap::default(); + mcp_servers.insert( + mcp_server::SERVER_NAME.to_string(), + permission_mcp_server.server_config()?, + ); + let mcp_config = McpConfig { mcp_servers }; + + let mcp_config_file = tempfile::NamedTempFile::new()?; + let (mcp_config_file, mcp_config_path) = mcp_config_file.into_parts(); + + let mut mcp_config_file = smol::fs::File::from(mcp_config_file); + mcp_config_file + .write_all(serde_json::to_string(&mcp_config)?.as_bytes()) + .await?; + mcp_config_file.flush().await?; + + let command = find_bin_in_path("claude", &project, cx) + .await + .context("Failed to find claude binary")?; + + let mut child = util::command::new_smol_command(&command) + .args([ + "--input-format", + "stream-json", + "--output-format", + "stream-json", + "--print", + "--verbose", + "--mcp-config", + mcp_config_path.to_string_lossy().as_ref(), + "--permission-prompt-tool", + &format!( + "mcp__{}__{}", + mcp_server::SERVER_NAME, + mcp_server::PERMISSION_TOOL + ), + "--allowedTools", + "mcp__zed__Read,mcp__zed__Edit", + "--disallowedTools", + "Read,Edit", + ]) + .current_dir(root_dir) + .stdin(std::process::Stdio::piped()) + .stdout(std::process::Stdio::piped()) + .stderr(std::process::Stdio::inherit()) + .kill_on_drop(true) + .spawn()?; + + let stdin = child.stdin.take().unwrap(); + let stdout = child.stdout.take().unwrap(); + + let (incoming_message_tx, mut incoming_message_rx) = mpsc::unbounded(); + let (outgoing_tx, outgoing_rx) = mpsc::unbounded(); + + let io_task = + ClaudeAgentConnection::handle_io(outgoing_rx, incoming_message_tx, stdin, stdout); + cx.background_spawn(async move { + io_task.await.log_err(); + drop(mcp_config_path); + drop(child); + }) + .detach(); + + cx.new(|cx| { + let end_turn_tx = Rc::new(RefCell::new(None)); + let delegate = AcpClientDelegate::new(cx.entity().downgrade(), cx.to_async()); + delegate_tx.send(Some(delegate.clone())).log_err(); + + let handler_task = cx.foreground_executor().spawn({ + let end_turn_tx = end_turn_tx.clone(); + let tool_id_map = tool_id_map.clone(); + async move { + while let Some(message) = incoming_message_rx.next().await { + ClaudeAgentConnection::handle_message( + delegate.clone(), + message, + end_turn_tx.clone(), + tool_id_map.clone(), + ) + .await + } + } + }); + + let mut connection = ClaudeAgentConnection { + outgoing_tx, + end_turn_tx, + _handler_task: handler_task, + _mcp_server: None, + }; + + connection._mcp_server = Some(permission_mcp_server); + acp_thread::AcpThread::new(connection, title, None, project.clone(), cx) + }) + }) + } +} + +impl AgentConnection for ClaudeAgentConnection { + /// Send a request to the agent and wait for a response. + fn request_any( + &self, + params: AnyAgentRequest, + ) -> LocalBoxFuture<'static, Result> { + let end_turn_tx = self.end_turn_tx.clone(); + let outgoing_tx = self.outgoing_tx.clone(); + async move { + match params { + // todo: consider sending an empty request so we get the init response? + AnyAgentRequest::InitializeParams(_) => Ok(AnyAgentResult::InitializeResponse( + acp::InitializeResponse { + is_authenticated: true, + protocol_version: ProtocolVersion::latest(), + }, + )), + AnyAgentRequest::AuthenticateParams(_) => { + Err(anyhow!("Authentication not supported")) + } + AnyAgentRequest::SendUserMessageParams(message) => { + let (tx, rx) = oneshot::channel(); + end_turn_tx.borrow_mut().replace(tx); + let mut content = String::new(); + for chunk in message.chunks { + match chunk { + agentic_coding_protocol::UserMessageChunk::Text { text } => { + content.push_str(&text) + } + agentic_coding_protocol::UserMessageChunk::Path { path } => { + content.push_str(&format!("@{path:?}")) + } + } + } + outgoing_tx.unbounded_send(SdkMessage::User { + message: Message { + role: Role::User, + content: Content::UntaggedText(content), + id: None, + model: None, + stop_reason: None, + stop_sequence: None, + usage: None, + }, + session_id: None, + })?; + rx.await??; + Ok(AnyAgentResult::SendUserMessageResponse( + acp::SendUserMessageResponse, + )) + } + AnyAgentRequest::CancelSendMessageParams(_) => Ok( + AnyAgentResult::CancelSendMessageResponse(acp::CancelSendMessageResponse), + ), + } + } + .boxed_local() + } +} + +struct ClaudeAgentConnection { + outgoing_tx: UnboundedSender, + end_turn_tx: Rc>>>>, + _mcp_server: Option, + _handler_task: Task<()>, +} + +impl ClaudeAgentConnection { + async fn handle_message( + delegate: AcpClientDelegate, + message: SdkMessage, + end_turn_tx: Rc>>>>, + tool_id_map: Rc>>, + ) { + match message { + SdkMessage::Assistant { message, .. } | SdkMessage::User { message, .. } => { + for chunk in message.content.chunks() { + match chunk { + ContentChunk::Text { text } | ContentChunk::UntaggedText(text) => { + delegate + .stream_assistant_message_chunk(StreamAssistantMessageChunkParams { + chunk: acp::AssistantMessageChunk::Text { text }, + }) + .await + .log_err(); + } + ContentChunk::ToolUse { id, name, input } => { + if let Some(resp) = delegate + .push_tool_call(ClaudeTool::infer(&name, input).as_acp()) + .await + .log_err() + { + tool_id_map.borrow_mut().insert(id, resp.id); + } + } + ContentChunk::ToolResult { + content, + tool_use_id, + } => { + let id = tool_id_map.borrow_mut().remove(&tool_use_id); + if let Some(id) = id { + delegate + .update_tool_call(UpdateToolCallParams { + tool_call_id: id, + status: acp::ToolCallStatus::Finished, + content: Some(ToolCallContent::Markdown { + // For now we only include text content + markdown: content.to_string(), + }), + }) + .await + .log_err(); + } + } + ContentChunk::Image + | ContentChunk::Document + | ContentChunk::Thinking + | ContentChunk::RedactedThinking + | ContentChunk::WebSearchToolResult => { + delegate + .stream_assistant_message_chunk(StreamAssistantMessageChunkParams { + chunk: acp::AssistantMessageChunk::Text { + text: format!("Unsupported content: {:?}", chunk), + }, + }) + .await + .log_err(); + } + } + } + } + SdkMessage::Result { + is_error, subtype, .. + } => { + if let Some(end_turn_tx) = end_turn_tx.borrow_mut().take() { + if is_error { + end_turn_tx.send(Err(anyhow!("Error: {subtype}"))).ok(); + } else { + end_turn_tx.send(Ok(())).ok(); + } + } + } + SdkMessage::System { .. } => {} + } + } + + async fn handle_io( + mut outgoing_rx: UnboundedReceiver, + incoming_tx: UnboundedSender, + mut outgoing_bytes: impl Unpin + AsyncWrite, + incoming_bytes: impl Unpin + AsyncRead, + ) -> Result<()> { + let mut output_reader = BufReader::new(incoming_bytes); + let mut outgoing_line = Vec::new(); + let mut incoming_line = String::new(); + loop { + select_biased! { + message = outgoing_rx.next() => { + if let Some(message) = message { + outgoing_line.clear(); + serde_json::to_writer(&mut outgoing_line, &message)?; + log::trace!("send: {}", String::from_utf8_lossy(&outgoing_line)); + outgoing_line.push(b'\n'); + outgoing_bytes.write_all(&outgoing_line).await.ok(); + } else { + break; + } + } + bytes_read = output_reader.read_line(&mut incoming_line).fuse() => { + if bytes_read? == 0 { + break + } + log::trace!("recv: {}", &incoming_line); + match serde_json::from_str::(&incoming_line) { + Ok(message) => { + incoming_tx.unbounded_send(message).log_err(); + } + Err(error) => { + log::error!("failed to parse incoming message: {error}. Raw: {incoming_line}"); + } + } + incoming_line.clear(); + } + } + } + Ok(()) + } +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +struct Message { + role: Role, + content: Content, + #[serde(skip_serializing_if = "Option::is_none")] + id: Option, + #[serde(skip_serializing_if = "Option::is_none")] + model: Option, + #[serde(skip_serializing_if = "Option::is_none")] + stop_reason: Option, + #[serde(skip_serializing_if = "Option::is_none")] + stop_sequence: Option, + #[serde(skip_serializing_if = "Option::is_none")] + usage: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +enum Content { + UntaggedText(String), + Chunks(Vec), +} + +impl Content { + pub fn chunks(self) -> impl Iterator { + match self { + Self::Chunks(chunks) => chunks.into_iter(), + Self::UntaggedText(text) => vec![ContentChunk::Text { text: text.clone() }].into_iter(), + } + } +} + +impl Display for Content { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Content::UntaggedText(txt) => write!(f, "{}", txt), + Content::Chunks(chunks) => { + for chunk in chunks { + write!(f, "{}", chunk)?; + } + Ok(()) + } + } + } +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "type", rename_all = "snake_case")] +enum ContentChunk { + Text { + text: String, + }, + ToolUse { + id: String, + name: String, + input: serde_json::Value, + }, + ToolResult { + content: Content, + tool_use_id: String, + }, + // TODO + Image, + Document, + Thinking, + RedactedThinking, + WebSearchToolResult, + #[serde(untagged)] + UntaggedText(String), +} + +impl Display for ContentChunk { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + ContentChunk::Text { text } => write!(f, "{}", text), + ContentChunk::UntaggedText(text) => write!(f, "{}", text), + ContentChunk::ToolResult { content, .. } => write!(f, "{}", content), + ContentChunk::Image + | ContentChunk::Document + | ContentChunk::Thinking + | ContentChunk::RedactedThinking + | ContentChunk::ToolUse { .. } + | ContentChunk::WebSearchToolResult => { + write!(f, "\n{:?}\n", &self) + } + } + } +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +struct Usage { + input_tokens: u32, + cache_creation_input_tokens: u32, + cache_read_input_tokens: u32, + output_tokens: u32, + service_tier: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +enum Role { + System, + Assistant, + User, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +struct MessageParam { + role: Role, + content: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "type", rename_all = "snake_case")] +enum SdkMessage { + // An assistant message + Assistant { + message: Message, // from Anthropic SDK + #[serde(skip_serializing_if = "Option::is_none")] + session_id: Option, + }, + + // A user message + User { + message: Message, // from Anthropic SDK + #[serde(skip_serializing_if = "Option::is_none")] + session_id: Option, + }, + + // Emitted as the last message in a conversation + Result { + subtype: ResultErrorType, + duration_ms: f64, + duration_api_ms: f64, + is_error: bool, + num_turns: i32, + #[serde(skip_serializing_if = "Option::is_none")] + result: Option, + session_id: String, + total_cost_usd: f64, + }, + // Emitted as the first message at the start of a conversation + System { + cwd: String, + session_id: String, + tools: Vec, + model: String, + mcp_servers: Vec, + #[serde(rename = "apiKeySource")] + api_key_source: String, + #[serde(rename = "permissionMode")] + permission_mode: PermissionMode, + }, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +enum ResultErrorType { + Success, + ErrorMaxTurns, + ErrorDuringExecution, +} + +impl Display for ResultErrorType { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + ResultErrorType::Success => write!(f, "success"), + ResultErrorType::ErrorMaxTurns => write!(f, "error_max_turns"), + ResultErrorType::ErrorDuringExecution => write!(f, "error_during_execution"), + } + } +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +struct McpServer { + name: String, + status: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +enum PermissionMode { + Default, + AcceptEdits, + BypassPermissions, + Plan, +} + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +struct McpConfig { + mcp_servers: HashMap, +} + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +struct McpServerConfig { + command: String, + args: Vec, + #[serde(skip_serializing_if = "Option::is_none")] + env: Option>, +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + #[test] + fn test_deserialize_content_untagged_text() { + let json = json!("Hello, world!"); + let content: Content = serde_json::from_value(json).unwrap(); + match content { + Content::UntaggedText(text) => assert_eq!(text, "Hello, world!"), + _ => panic!("Expected UntaggedText variant"), + } + } + + #[test] + fn test_deserialize_content_chunks() { + let json = json!([ + { + "type": "text", + "text": "Hello" + }, + { + "type": "tool_use", + "id": "tool_123", + "name": "calculator", + "input": {"operation": "add", "a": 1, "b": 2} + } + ]); + let content: Content = serde_json::from_value(json).unwrap(); + match content { + Content::Chunks(chunks) => { + assert_eq!(chunks.len(), 2); + match &chunks[0] { + ContentChunk::Text { text } => assert_eq!(text, "Hello"), + _ => panic!("Expected Text chunk"), + } + match &chunks[1] { + ContentChunk::ToolUse { id, name, input } => { + assert_eq!(id, "tool_123"); + assert_eq!(name, "calculator"); + assert_eq!(input["operation"], "add"); + assert_eq!(input["a"], 1); + assert_eq!(input["b"], 2); + } + _ => panic!("Expected ToolUse chunk"), + } + } + _ => panic!("Expected Chunks variant"), + } + } + + #[test] + fn test_deserialize_tool_result_untagged_text() { + let json = json!({ + "type": "tool_result", + "content": "Result content", + "tool_use_id": "tool_456" + }); + let chunk: ContentChunk = serde_json::from_value(json).unwrap(); + match chunk { + ContentChunk::ToolResult { + content, + tool_use_id, + } => { + match content { + Content::UntaggedText(text) => assert_eq!(text, "Result content"), + _ => panic!("Expected UntaggedText content"), + } + assert_eq!(tool_use_id, "tool_456"); + } + _ => panic!("Expected ToolResult variant"), + } + } + + #[test] + fn test_deserialize_tool_result_chunks() { + let json = json!({ + "type": "tool_result", + "content": [ + { + "type": "text", + "text": "Processing complete" + }, + { + "type": "text", + "text": "Result: 42" + } + ], + "tool_use_id": "tool_789" + }); + let chunk: ContentChunk = serde_json::from_value(json).unwrap(); + match chunk { + ContentChunk::ToolResult { + content, + tool_use_id, + } => { + match content { + Content::Chunks(chunks) => { + assert_eq!(chunks.len(), 2); + match &chunks[0] { + ContentChunk::Text { text } => assert_eq!(text, "Processing complete"), + _ => panic!("Expected Text chunk"), + } + match &chunks[1] { + ContentChunk::Text { text } => assert_eq!(text, "Result: 42"), + _ => panic!("Expected Text chunk"), + } + } + _ => panic!("Expected Chunks content"), + } + assert_eq!(tool_use_id, "tool_789"); + } + _ => panic!("Expected ToolResult variant"), + } + } +} diff --git a/crates/agent_servers/src/claude/mcp_server.rs b/crates/agent_servers/src/claude/mcp_server.rs new file mode 100644 index 0000000000..fa61e67112 --- /dev/null +++ b/crates/agent_servers/src/claude/mcp_server.rs @@ -0,0 +1,303 @@ +use std::{cell::RefCell, rc::Rc}; + +use acp_thread::AcpClientDelegate; +use agentic_coding_protocol::{self as acp, Client, ReadTextFileParams, WriteTextFileParams}; +use anyhow::{Context, Result}; +use collections::HashMap; +use context_server::{ + listener::McpServer, + types::{ + CallToolParams, CallToolResponse, Implementation, InitializeParams, InitializeResponse, + ListToolsResponse, ProtocolVersion, ServerCapabilities, Tool, ToolAnnotations, + ToolResponseContent, ToolsCapabilities, requests, + }, +}; +use gpui::{App, AsyncApp, Task}; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use util::debug_panic; + +use crate::claude::{ + McpServerConfig, + tools::{ClaudeTool, EditToolParams, EditToolResponse, ReadToolParams, ReadToolResponse}, +}; + +pub struct ClaudeMcpServer { + server: McpServer, +} + +pub const SERVER_NAME: &str = "zed"; +pub const READ_TOOL: &str = "Read"; +pub const EDIT_TOOL: &str = "Edit"; +pub const PERMISSION_TOOL: &str = "Confirmation"; + +#[derive(Deserialize, JsonSchema, Debug)] +struct PermissionToolParams { + tool_name: String, + input: serde_json::Value, + tool_use_id: Option, +} + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +struct PermissionToolResponse { + behavior: PermissionToolBehavior, + updated_input: serde_json::Value, +} + +#[derive(Serialize)] +#[serde(rename_all = "snake_case")] +enum PermissionToolBehavior { + Allow, + Deny, +} + +impl ClaudeMcpServer { + pub async fn new( + delegate: watch::Receiver>, + tool_id_map: Rc>>, + cx: &AsyncApp, + ) -> Result { + let mut mcp_server = McpServer::new(cx).await?; + mcp_server.handle_request::(Self::handle_initialize); + mcp_server.handle_request::(Self::handle_list_tools); + mcp_server.handle_request::(move |request, cx| { + Self::handle_call_tool(request, delegate.clone(), tool_id_map.clone(), cx) + }); + + Ok(Self { server: mcp_server }) + } + + pub fn server_config(&self) -> Result { + #[cfg(not(target_os = "windows"))] + let zed_path = util::get_shell_safe_zed_path()?; + #[cfg(target_os = "windows")] + let zed_path = std::env::current_exe() + .context("finding current executable path for use in mcp_server")? + .to_string_lossy() + .to_string(); + + Ok(McpServerConfig { + command: zed_path, + args: vec![ + "--nc".into(), + self.server.socket_path().display().to_string(), + ], + env: None, + }) + } + + fn handle_initialize(_: InitializeParams, cx: &App) -> Task> { + cx.foreground_executor().spawn(async move { + Ok(InitializeResponse { + protocol_version: ProtocolVersion("2025-06-18".into()), + capabilities: ServerCapabilities { + experimental: None, + logging: None, + completions: None, + prompts: None, + resources: None, + tools: Some(ToolsCapabilities { + list_changed: Some(false), + }), + }, + server_info: Implementation { + name: SERVER_NAME.into(), + version: "0.1.0".into(), + }, + meta: None, + }) + }) + } + + fn handle_list_tools(_: (), cx: &App) -> Task> { + cx.foreground_executor().spawn(async move { + Ok(ListToolsResponse { + tools: vec![ + Tool { + name: PERMISSION_TOOL.into(), + input_schema: schemars::schema_for!(PermissionToolParams).into(), + description: None, + annotations: None, + }, + Tool { + name: READ_TOOL.into(), + input_schema: schemars::schema_for!(ReadToolParams).into(), + description: Some("Read the contents of a file. In sessions with mcp__zed__Read always use it instead of Read as it contains the most up-to-date contents.".to_string()), + annotations: Some(ToolAnnotations { + title: Some("Read file".to_string()), + read_only_hint: Some(true), + destructive_hint: Some(false), + open_world_hint: Some(false), + // if time passes the contents might change, but it's not going to do anything different + // true or false seem too strong, let's try a none. + idempotent_hint: None, + }), + }, + Tool { + name: EDIT_TOOL.into(), + input_schema: schemars::schema_for!(EditToolParams).into(), + description: Some("Edits a file. In sessions with mcp__zed__Edit always use it instead of Edit as it will show the diff to the user better.".to_string()), + annotations: Some(ToolAnnotations { + title: Some("Edit file".to_string()), + read_only_hint: Some(false), + destructive_hint: Some(false), + open_world_hint: Some(false), + idempotent_hint: Some(false), + }), + }, + ], + next_cursor: None, + meta: None, + }) + }) + } + + fn handle_call_tool( + request: CallToolParams, + mut delegate_watch: watch::Receiver>, + tool_id_map: Rc>>, + cx: &App, + ) -> Task> { + cx.spawn(async move |cx| { + let Some(delegate) = delegate_watch.recv().await? else { + debug_panic!("Sent None delegate"); + anyhow::bail!("Server not available"); + }; + + if request.name.as_str() == PERMISSION_TOOL { + let input = + serde_json::from_value(request.arguments.context("Arguments required")?)?; + + let result = + Self::handle_permissions_tool_call(input, delegate, tool_id_map, cx).await?; + Ok(CallToolResponse { + content: vec![ToolResponseContent::Text { + text: serde_json::to_string(&result)?, + }], + is_error: None, + meta: None, + }) + } else if request.name.as_str() == READ_TOOL { + let input = + serde_json::from_value(request.arguments.context("Arguments required")?)?; + + let result = Self::handle_read_tool_call(input, delegate, cx).await?; + Ok(CallToolResponse { + content: vec![ToolResponseContent::Text { + text: serde_json::to_string(&result)?, + }], + is_error: None, + meta: None, + }) + } else if request.name.as_str() == EDIT_TOOL { + let input = + serde_json::from_value(request.arguments.context("Arguments required")?)?; + + let result = Self::handle_edit_tool_call(input, delegate, cx).await?; + Ok(CallToolResponse { + content: vec![ToolResponseContent::Text { + text: serde_json::to_string(&result)?, + }], + is_error: None, + meta: None, + }) + } else { + anyhow::bail!("Unsupported tool"); + } + }) + } + + fn handle_read_tool_call( + params: ReadToolParams, + delegate: AcpClientDelegate, + cx: &AsyncApp, + ) -> Task> { + cx.foreground_executor().spawn(async move { + let response = delegate + .read_text_file(ReadTextFileParams { + path: params.abs_path, + line: params.offset, + limit: params.limit, + }) + .await?; + + Ok(ReadToolResponse { + content: response.content, + }) + }) + } + + fn handle_edit_tool_call( + params: EditToolParams, + delegate: AcpClientDelegate, + cx: &AsyncApp, + ) -> Task> { + cx.foreground_executor().spawn(async move { + let response = delegate + .read_text_file_reusing_snapshot(ReadTextFileParams { + path: params.abs_path.clone(), + line: None, + limit: None, + }) + .await?; + + let new_content = response.content.replace(¶ms.old_text, ¶ms.new_text); + if new_content == response.content { + return Err(anyhow::anyhow!("The old_text was not found in the content")); + } + + delegate + .write_text_file(WriteTextFileParams { + path: params.abs_path, + content: new_content, + }) + .await?; + + Ok(EditToolResponse) + }) + } + + fn handle_permissions_tool_call( + params: PermissionToolParams, + delegate: AcpClientDelegate, + tool_id_map: Rc>>, + cx: &AsyncApp, + ) -> Task> { + cx.foreground_executor().spawn(async move { + let claude_tool = ClaudeTool::infer(¶ms.tool_name, params.input.clone()); + + let tool_call_id = match params.tool_use_id { + Some(tool_use_id) => tool_id_map + .borrow() + .get(&tool_use_id) + .cloned() + .context("Tool call ID not found")?, + + None => delegate.push_tool_call(claude_tool.as_acp()).await?.id, + }; + + let outcome = delegate + .request_existing_tool_call_confirmation( + tool_call_id, + claude_tool.confirmation(None), + ) + .await?; + + match outcome { + acp::ToolCallConfirmationOutcome::Allow + | acp::ToolCallConfirmationOutcome::AlwaysAllow + | acp::ToolCallConfirmationOutcome::AlwaysAllowMcpServer + | acp::ToolCallConfirmationOutcome::AlwaysAllowTool => Ok(PermissionToolResponse { + behavior: PermissionToolBehavior::Allow, + updated_input: params.input, + }), + acp::ToolCallConfirmationOutcome::Reject + | acp::ToolCallConfirmationOutcome::Cancel => Ok(PermissionToolResponse { + behavior: PermissionToolBehavior::Deny, + updated_input: params.input, + }), + } + }) + } +} diff --git a/crates/agent_servers/src/claude/tools.rs b/crates/agent_servers/src/claude/tools.rs new file mode 100644 index 0000000000..89d42c0daa --- /dev/null +++ b/crates/agent_servers/src/claude/tools.rs @@ -0,0 +1,670 @@ +use std::path::PathBuf; + +use agentic_coding_protocol::{self as acp, PushToolCallParams, ToolCallLocation}; +use itertools::Itertools; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use util::ResultExt; + +pub enum ClaudeTool { + Task(Option), + NotebookRead(Option), + NotebookEdit(Option), + Edit(Option), + MultiEdit(Option), + ReadFile(Option), + Write(Option), + Ls(Option), + Glob(Option), + Grep(Option), + Terminal(Option), + WebFetch(Option), + WebSearch(Option), + TodoWrite(Option), + ExitPlanMode(Option), + Other { + name: String, + input: serde_json::Value, + }, +} + +impl ClaudeTool { + pub fn infer(tool_name: &str, input: serde_json::Value) -> Self { + match tool_name { + // Known tools + "mcp__zed__Read" => Self::ReadFile(serde_json::from_value(input).log_err()), + "mcp__zed__Edit" => Self::Edit(serde_json::from_value(input).log_err()), + "MultiEdit" => Self::MultiEdit(serde_json::from_value(input).log_err()), + "Write" => Self::Write(serde_json::from_value(input).log_err()), + "LS" => Self::Ls(serde_json::from_value(input).log_err()), + "Glob" => Self::Glob(serde_json::from_value(input).log_err()), + "Grep" => Self::Grep(serde_json::from_value(input).log_err()), + "Bash" => Self::Terminal(serde_json::from_value(input).log_err()), + "WebFetch" => Self::WebFetch(serde_json::from_value(input).log_err()), + "WebSearch" => Self::WebSearch(serde_json::from_value(input).log_err()), + "TodoWrite" => Self::TodoWrite(serde_json::from_value(input).log_err()), + "exit_plan_mode" => Self::ExitPlanMode(serde_json::from_value(input).log_err()), + "Task" => Self::Task(serde_json::from_value(input).log_err()), + "NotebookRead" => Self::NotebookRead(serde_json::from_value(input).log_err()), + "NotebookEdit" => Self::NotebookEdit(serde_json::from_value(input).log_err()), + // Inferred from name + _ => { + let tool_name = tool_name.to_lowercase(); + + if tool_name.contains("edit") || tool_name.contains("write") { + Self::Edit(None) + } else if tool_name.contains("terminal") { + Self::Terminal(None) + } else { + Self::Other { + name: tool_name.to_string(), + input, + } + } + } + } + } + + pub fn label(&self) -> String { + match &self { + Self::Task(Some(params)) => params.description.clone(), + Self::Task(None) => "Task".into(), + Self::NotebookRead(Some(params)) => { + format!("Read Notebook {}", params.notebook_path.display()) + } + Self::NotebookRead(None) => "Read Notebook".into(), + Self::NotebookEdit(Some(params)) => { + format!("Edit Notebook {}", params.notebook_path.display()) + } + Self::NotebookEdit(None) => "Edit Notebook".into(), + Self::Terminal(Some(params)) => format!("`{}`", params.command), + Self::Terminal(None) => "Terminal".into(), + Self::ReadFile(_) => "Read File".into(), + Self::Ls(Some(params)) => { + format!("List Directory {}", params.path.display()) + } + Self::Ls(None) => "List Directory".into(), + Self::Edit(Some(params)) => { + format!("Edit {}", params.abs_path.display()) + } + Self::Edit(None) => "Edit".into(), + Self::MultiEdit(Some(params)) => { + format!("Multi Edit {}", params.file_path.display()) + } + Self::MultiEdit(None) => "Multi Edit".into(), + Self::Write(Some(params)) => { + format!("Write {}", params.file_path.display()) + } + Self::Write(None) => "Write".into(), + Self::Glob(Some(params)) => { + format!("Glob {params}") + } + Self::Glob(None) => "Glob".into(), + Self::Grep(Some(params)) => params.to_string(), + Self::Grep(None) => "Grep".into(), + Self::WebFetch(Some(params)) => format!("Fetch {}", params.url), + Self::WebFetch(None) => "Fetch".into(), + Self::WebSearch(Some(params)) => format!("Web Search: {}", params), + Self::WebSearch(None) => "Web Search".into(), + Self::TodoWrite(Some(params)) => format!( + "Update TODOs: {}", + params.todos.iter().map(|todo| &todo.content).join(", ") + ), + Self::TodoWrite(None) => "Update TODOs".into(), + Self::ExitPlanMode(_) => "Exit Plan Mode".into(), + Self::Other { name, .. } => name.clone(), + } + } + + pub fn content(&self) -> Option { + match &self { + ClaudeTool::Other { input, .. } => Some(acp::ToolCallContent::Markdown { + markdown: format!( + "```json\n{}```", + serde_json::to_string_pretty(&input).unwrap_or("{}".to_string()) + ), + }), + _ => None, + } + } + + pub fn icon(&self) -> acp::Icon { + match self { + Self::Task(_) => acp::Icon::Hammer, + Self::NotebookRead(_) => acp::Icon::FileSearch, + Self::NotebookEdit(_) => acp::Icon::Pencil, + Self::Edit(_) => acp::Icon::Pencil, + Self::MultiEdit(_) => acp::Icon::Pencil, + Self::Write(_) => acp::Icon::Pencil, + Self::ReadFile(_) => acp::Icon::FileSearch, + Self::Ls(_) => acp::Icon::Folder, + Self::Glob(_) => acp::Icon::FileSearch, + Self::Grep(_) => acp::Icon::Regex, + Self::Terminal(_) => acp::Icon::Terminal, + Self::WebSearch(_) => acp::Icon::Globe, + Self::WebFetch(_) => acp::Icon::Globe, + Self::TodoWrite(_) => acp::Icon::LightBulb, + Self::ExitPlanMode(_) => acp::Icon::Hammer, + Self::Other { .. } => acp::Icon::Hammer, + } + } + + pub fn confirmation(&self, description: Option) -> acp::ToolCallConfirmation { + match &self { + Self::Edit(_) | Self::Write(_) | Self::NotebookEdit(_) | Self::MultiEdit(_) => { + acp::ToolCallConfirmation::Edit { description } + } + Self::WebFetch(params) => acp::ToolCallConfirmation::Fetch { + urls: params + .as_ref() + .map(|p| vec![p.url.clone()]) + .unwrap_or_default(), + description, + }, + Self::Terminal(Some(BashToolParams { + description, + command, + .. + })) => acp::ToolCallConfirmation::Execute { + command: command.clone(), + root_command: command.clone(), + description: description.clone(), + }, + Self::ExitPlanMode(Some(params)) => acp::ToolCallConfirmation::Other { + description: if let Some(description) = description { + format!("{description} {}", params.plan) + } else { + params.plan.clone() + }, + }, + Self::Task(Some(params)) => acp::ToolCallConfirmation::Other { + description: if let Some(description) = description { + format!("{description} {}", params.description) + } else { + params.description.clone() + }, + }, + Self::Ls(Some(LsToolParams { path, .. })) + | Self::ReadFile(Some(ReadToolParams { abs_path: path, .. })) => { + let path = path.display(); + acp::ToolCallConfirmation::Other { + description: if let Some(description) = description { + format!("{description} {path}") + } else { + path.to_string() + }, + } + } + Self::NotebookRead(Some(NotebookReadToolParams { notebook_path, .. })) => { + let path = notebook_path.display(); + acp::ToolCallConfirmation::Other { + description: if let Some(description) = description { + format!("{description} {path}") + } else { + path.to_string() + }, + } + } + Self::Glob(Some(params)) => acp::ToolCallConfirmation::Other { + description: if let Some(description) = description { + format!("{description} {params}") + } else { + params.to_string() + }, + }, + Self::Grep(Some(params)) => acp::ToolCallConfirmation::Other { + description: if let Some(description) = description { + format!("{description} {params}") + } else { + params.to_string() + }, + }, + Self::WebSearch(Some(params)) => acp::ToolCallConfirmation::Other { + description: if let Some(description) = description { + format!("{description} {params}") + } else { + params.to_string() + }, + }, + Self::TodoWrite(Some(params)) => { + let params = params.todos.iter().map(|todo| &todo.content).join(", "); + acp::ToolCallConfirmation::Other { + description: if let Some(description) = description { + format!("{description} {params}") + } else { + params + }, + } + } + Self::Terminal(None) + | Self::Task(None) + | Self::NotebookRead(None) + | Self::ExitPlanMode(None) + | Self::Ls(None) + | Self::Glob(None) + | Self::Grep(None) + | Self::ReadFile(None) + | Self::WebSearch(None) + | Self::TodoWrite(None) + | Self::Other { .. } => acp::ToolCallConfirmation::Other { + description: description.unwrap_or("".to_string()), + }, + } + } + + pub fn locations(&self) -> Vec { + match &self { + Self::Edit(Some(EditToolParams { abs_path, .. })) => vec![ToolCallLocation { + path: abs_path.clone(), + line: None, + }], + Self::MultiEdit(Some(MultiEditToolParams { file_path, .. })) => { + vec![ToolCallLocation { + path: file_path.clone(), + line: None, + }] + } + Self::Write(Some(WriteToolParams { file_path, .. })) => vec![ToolCallLocation { + path: file_path.clone(), + line: None, + }], + Self::ReadFile(Some(ReadToolParams { + abs_path, offset, .. + })) => vec![ToolCallLocation { + path: abs_path.clone(), + line: *offset, + }], + Self::NotebookRead(Some(NotebookReadToolParams { notebook_path, .. })) => { + vec![ToolCallLocation { + path: notebook_path.clone(), + line: None, + }] + } + Self::NotebookEdit(Some(NotebookEditToolParams { notebook_path, .. })) => { + vec![ToolCallLocation { + path: notebook_path.clone(), + line: None, + }] + } + Self::Glob(Some(GlobToolParams { + path: Some(path), .. + })) => vec![ToolCallLocation { + path: path.clone(), + line: None, + }], + Self::Ls(Some(LsToolParams { path, .. })) => vec![ToolCallLocation { + path: path.clone(), + line: None, + }], + Self::Grep(Some(GrepToolParams { + path: Some(path), .. + })) => vec![ToolCallLocation { + path: PathBuf::from(path), + line: None, + }], + Self::Task(_) + | Self::NotebookRead(None) + | Self::NotebookEdit(None) + | Self::Edit(None) + | Self::MultiEdit(None) + | Self::Write(None) + | Self::ReadFile(None) + | Self::Ls(None) + | Self::Glob(_) + | Self::Grep(_) + | Self::Terminal(_) + | Self::WebFetch(_) + | Self::WebSearch(_) + | Self::TodoWrite(_) + | Self::ExitPlanMode(_) + | Self::Other { .. } => vec![], + } + } + + pub fn as_acp(&self) -> PushToolCallParams { + PushToolCallParams { + label: self.label(), + content: self.content(), + icon: self.icon(), + locations: self.locations(), + } + } +} + +#[derive(Deserialize, JsonSchema, Debug)] +pub struct EditToolParams { + /// The absolute path to the file to read. + pub abs_path: PathBuf, + /// The old text to replace (must be unique in the file) + pub old_text: String, + /// The new text. + pub new_text: String, +} + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub struct EditToolResponse; + +#[derive(Deserialize, JsonSchema, Debug)] +pub struct ReadToolParams { + /// The absolute path to the file to read. + pub abs_path: PathBuf, + /// Which line to start reading from. Omit to start from the beginning. + #[serde(skip_serializing_if = "Option::is_none")] + pub offset: Option, + /// How many lines to read. Omit for the whole file. + #[serde(skip_serializing_if = "Option::is_none")] + pub limit: Option, +} + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub struct ReadToolResponse { + pub content: String, +} + +#[derive(Deserialize, JsonSchema, Debug)] +pub struct WriteToolParams { + /// Absolute path for new file + pub file_path: PathBuf, + /// File content + pub content: String, +} + +#[derive(Deserialize, JsonSchema, Debug)] +pub struct BashToolParams { + /// Shell command to execute + pub command: String, + /// 5-10 word description of what command does + #[serde(skip_serializing_if = "Option::is_none")] + pub description: Option, + /// Timeout in ms (max 600000ms/10min, default 120000ms) + #[serde(skip_serializing_if = "Option::is_none")] + pub timeout: Option, +} + +#[derive(Deserialize, JsonSchema, Debug)] +pub struct GlobToolParams { + /// Glob pattern like **/*.js or src/**/*.ts + pub pattern: String, + /// Directory to search in (omit for current directory) + #[serde(skip_serializing_if = "Option::is_none")] + pub path: Option, +} + +impl std::fmt::Display for GlobToolParams { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + if let Some(path) = &self.path { + write!(f, "{}", path.display())?; + } + write!(f, "{}", self.pattern) + } +} + +#[derive(Deserialize, JsonSchema, Debug)] +pub struct LsToolParams { + /// Absolute path to directory + pub path: PathBuf, + /// Array of glob patterns to ignore + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub ignore: Vec, +} + +#[derive(Deserialize, JsonSchema, Debug)] +pub struct GrepToolParams { + /// Regex pattern to search for + pub pattern: String, + /// File/directory to search (defaults to current directory) + #[serde(skip_serializing_if = "Option::is_none")] + pub path: Option, + /// "content" (shows lines), "files_with_matches" (default), "count" + #[serde(skip_serializing_if = "Option::is_none")] + pub output_mode: Option, + /// Filter files with glob pattern like "*.js" + #[serde(skip_serializing_if = "Option::is_none")] + pub glob: Option, + /// File type filter like "js", "py", "rust" + #[serde(rename = "type", skip_serializing_if = "Option::is_none")] + pub file_type: Option, + /// Case insensitive search + #[serde(rename = "-i", default, skip_serializing_if = "is_false")] + pub case_insensitive: bool, + /// Show line numbers (content mode only) + #[serde(rename = "-n", default, skip_serializing_if = "is_false")] + pub line_numbers: bool, + /// Lines after match (content mode only) + #[serde(rename = "-A", skip_serializing_if = "Option::is_none")] + pub after_context: Option, + /// Lines before match (content mode only) + #[serde(rename = "-B", skip_serializing_if = "Option::is_none")] + pub before_context: Option, + /// Lines before and after match (content mode only) + #[serde(rename = "-C", skip_serializing_if = "Option::is_none")] + pub context: Option, + /// Enable multiline/cross-line matching + #[serde(default, skip_serializing_if = "is_false")] + pub multiline: bool, + /// Limit output to first N results + #[serde(skip_serializing_if = "Option::is_none")] + pub head_limit: Option, +} + +impl std::fmt::Display for GrepToolParams { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "grep")?; + + // Boolean flags + if self.case_insensitive { + write!(f, " -i")?; + } + if self.line_numbers { + write!(f, " -n")?; + } + + // Context options + if let Some(after) = self.after_context { + write!(f, " -A {}", after)?; + } + if let Some(before) = self.before_context { + write!(f, " -B {}", before)?; + } + if let Some(context) = self.context { + write!(f, " -C {}", context)?; + } + + // Output mode + if let Some(mode) = &self.output_mode { + match mode { + GrepOutputMode::FilesWithMatches => write!(f, " -l")?, + GrepOutputMode::Count => write!(f, " -c")?, + GrepOutputMode::Content => {} // Default mode + } + } + + // Head limit + if let Some(limit) = self.head_limit { + write!(f, " | head -{}", limit)?; + } + + // Glob pattern + if let Some(glob) = &self.glob { + write!(f, " --include=\"{}\"", glob)?; + } + + // File type + if let Some(file_type) = &self.file_type { + write!(f, " --type={}", file_type)?; + } + + // Multiline + if self.multiline { + write!(f, " -P")?; // Perl-compatible regex for multiline + } + + // Pattern (escaped if contains special characters) + write!(f, " \"{}\"", self.pattern)?; + + // Path + if let Some(path) = &self.path { + write!(f, " {}", path)?; + } + + Ok(()) + } +} + +#[derive(Deserialize, Serialize, JsonSchema, Debug)] +#[serde(rename_all = "snake_case")] +pub enum TodoPriority { + High, + Medium, + Low, +} + +#[derive(Deserialize, Serialize, JsonSchema, Debug)] +#[serde(rename_all = "snake_case")] +pub enum TodoStatus { + Pending, + InProgress, + Completed, +} + +#[derive(Deserialize, Serialize, JsonSchema, Debug)] +pub struct Todo { + /// Unique identifier + pub id: String, + /// Task description + pub content: String, + /// Priority level of the todo + pub priority: TodoPriority, + /// Current status of the todo + pub status: TodoStatus, +} + +#[derive(Deserialize, JsonSchema, Debug)] +pub struct TodoWriteToolParams { + pub todos: Vec, +} + +#[derive(Deserialize, JsonSchema, Debug)] +pub struct ExitPlanModeToolParams { + /// Implementation plan in markdown format + pub plan: String, +} + +#[derive(Deserialize, JsonSchema, Debug)] +pub struct TaskToolParams { + /// Short 3-5 word description of task + pub description: String, + /// Detailed task for agent to perform + pub prompt: String, +} + +#[derive(Deserialize, JsonSchema, Debug)] +pub struct NotebookReadToolParams { + /// Absolute path to .ipynb file + pub notebook_path: PathBuf, + /// Specific cell ID to read + #[serde(skip_serializing_if = "Option::is_none")] + pub cell_id: Option, +} + +#[derive(Deserialize, Serialize, JsonSchema, Debug)] +#[serde(rename_all = "snake_case")] +pub enum CellType { + Code, + Markdown, +} + +#[derive(Deserialize, Serialize, JsonSchema, Debug)] +#[serde(rename_all = "snake_case")] +pub enum EditMode { + Replace, + Insert, + Delete, +} + +#[derive(Deserialize, JsonSchema, Debug)] +pub struct NotebookEditToolParams { + /// Absolute path to .ipynb file + pub notebook_path: PathBuf, + /// New cell content + pub new_source: String, + /// Cell ID to edit + #[serde(skip_serializing_if = "Option::is_none")] + pub cell_id: Option, + /// Type of cell (code or markdown) + #[serde(skip_serializing_if = "Option::is_none")] + pub cell_type: Option, + /// Edit operation mode + #[serde(skip_serializing_if = "Option::is_none")] + pub edit_mode: Option, +} + +#[derive(Deserialize, Serialize, JsonSchema, Debug)] +pub struct MultiEditItem { + /// The text to search for and replace + pub old_string: String, + /// The replacement text + pub new_string: String, + /// Whether to replace all occurrences or just the first + #[serde(default, skip_serializing_if = "is_false")] + pub replace_all: bool, +} + +#[derive(Deserialize, JsonSchema, Debug)] +pub struct MultiEditToolParams { + /// Absolute path to file + pub file_path: PathBuf, + /// List of edits to apply + pub edits: Vec, +} + +fn is_false(v: &bool) -> bool { + !*v +} + +#[derive(Deserialize, JsonSchema, Debug)] +#[serde(rename_all = "snake_case")] +pub enum GrepOutputMode { + Content, + FilesWithMatches, + Count, +} + +#[derive(Deserialize, JsonSchema, Debug)] +pub struct WebFetchToolParams { + /// Valid URL to fetch + #[serde(rename = "url")] + pub url: String, + /// What to extract from content + pub prompt: String, +} + +#[derive(Deserialize, JsonSchema, Debug)] +pub struct WebSearchToolParams { + /// Search query (min 2 chars) + pub query: String, + /// Only include these domains + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub allowed_domains: Vec, + /// Exclude these domains + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub blocked_domains: Vec, +} + +impl std::fmt::Display for WebSearchToolParams { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "\"{}\"", self.query)?; + + if !self.allowed_domains.is_empty() { + write!(f, " (allowed: {})", self.allowed_domains.join(", "))?; + } + + if !self.blocked_domains.is_empty() { + write!(f, " (blocked: {})", self.blocked_domains.join(", "))?; + } + + Ok(()) + } +} diff --git a/crates/agent_servers/src/gemini.rs b/crates/agent_servers/src/gemini.rs new file mode 100644 index 0000000000..bf1d13429e --- /dev/null +++ b/crates/agent_servers/src/gemini.rs @@ -0,0 +1,501 @@ +use crate::stdio_agent_server::{StdioAgentServer, find_bin_in_path}; +use crate::{AgentServerCommand, AgentServerVersion}; +use anyhow::{Context as _, Result}; +use gpui::{AsyncApp, Entity}; +use project::Project; +use settings::SettingsStore; + +use crate::AllAgentServersSettings; + +#[derive(Clone)] +pub struct Gemini; + +const ACP_ARG: &str = "--experimental-acp"; + +impl StdioAgentServer for Gemini { + fn name(&self) -> &'static str { + "Gemini" + } + + fn empty_state_headline(&self) -> &'static str { + "Welcome to Gemini" + } + + fn empty_state_message(&self) -> &'static str { + "Ask questions, edit files, run commands.\nBe specific for the best results." + } + + fn supports_always_allow(&self) -> bool { + true + } + + fn logo(&self) -> ui::IconName { + ui::IconName::AiGemini + } + + async fn command( + &self, + project: &Entity, + cx: &mut AsyncApp, + ) -> Result { + let custom_command = cx.read_global(|settings: &SettingsStore, _| { + let settings = settings.get::(None); + settings + .gemini + .as_ref() + .map(|gemini_settings| AgentServerCommand { + path: gemini_settings.command.path.clone(), + args: gemini_settings + .command + .args + .iter() + .cloned() + .chain(std::iter::once(ACP_ARG.into())) + .collect(), + env: gemini_settings.command.env.clone(), + }) + })?; + + if let Some(custom_command) = custom_command { + return Ok(custom_command); + } + + if let Some(path) = find_bin_in_path("gemini", project, cx).await { + return Ok(AgentServerCommand { + path, + args: vec![ACP_ARG.into()], + env: None, + }); + } + + let (fs, node_runtime) = project.update(cx, |project, _| { + (project.fs().clone(), project.node_runtime().cloned()) + })?; + let node_runtime = node_runtime.context("gemini not found on path")?; + + let directory = ::paths::agent_servers_dir().join("gemini"); + fs.create_dir(&directory).await?; + node_runtime + .npm_install_packages(&directory, &[("@google/gemini-cli", "latest")]) + .await?; + let path = directory.join("node_modules/.bin/gemini"); + + Ok(AgentServerCommand { + path, + args: vec![ACP_ARG.into()], + env: None, + }) + } + + async fn version(&self, command: &AgentServerCommand) -> Result { + let version_fut = util::command::new_smol_command(&command.path) + .args(command.args.iter()) + .arg("--version") + .kill_on_drop(true) + .output(); + + let help_fut = util::command::new_smol_command(&command.path) + .args(command.args.iter()) + .arg("--help") + .kill_on_drop(true) + .output(); + + let (version_output, help_output) = futures::future::join(version_fut, help_fut).await; + + let current_version = String::from_utf8(version_output?.stdout)?; + let supported = String::from_utf8(help_output?.stdout)?.contains(ACP_ARG); + + if supported { + Ok(AgentServerVersion::Supported) + } else { + Ok(AgentServerVersion::Unsupported { + error_message: format!( + "Your installed version of Gemini {} doesn't support the Agentic Coding Protocol (ACP).", + current_version + ).into(), + upgrade_message: "Upgrade Gemini to Latest".into(), + upgrade_command: "npm install -g @google/gemini-cli@latest".into(), + }) + } + } +} + +#[cfg(test)] +mod test { + use std::{path::Path, time::Duration}; + + use acp_thread::{ + AcpThread, AgentThreadEntry, ToolCall, ToolCallConfirmation, ToolCallContent, + ToolCallStatus, + }; + use agentic_coding_protocol as acp; + use anyhow::Result; + use futures::{FutureExt, StreamExt, channel::mpsc, select}; + use gpui::{AsyncApp, Entity, TestAppContext}; + use indoc::indoc; + use project::{FakeFs, Project}; + use serde_json::json; + use settings::SettingsStore; + use util::path; + + use crate::{AgentServer, AgentServerCommand, AgentServerVersion, StdioAgentServer}; + + pub async fn gemini_acp_thread( + project: Entity, + current_dir: impl AsRef, + cx: &mut TestAppContext, + ) -> Entity { + #[derive(Clone)] + struct DevGemini; + + impl StdioAgentServer for DevGemini { + async fn command( + &self, + _project: &Entity, + _cx: &mut AsyncApp, + ) -> Result { + let cli_path = Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../gemini-cli/packages/cli") + .to_string_lossy() + .to_string(); + + Ok(AgentServerCommand { + path: "node".into(), + args: vec![cli_path, "--experimental-acp".into()], + env: None, + }) + } + + async fn version(&self, _command: &AgentServerCommand) -> Result { + Ok(AgentServerVersion::Supported) + } + + fn logo(&self) -> ui::IconName { + ui::IconName::AiGemini + } + + fn name(&self) -> &'static str { + "test" + } + + fn empty_state_headline(&self) -> &'static str { + "test" + } + + fn empty_state_message(&self) -> &'static str { + "test" + } + + fn supports_always_allow(&self) -> bool { + true + } + } + + let thread = cx + .update(|cx| AgentServer::new_thread(&DevGemini, current_dir.as_ref(), &project, cx)) + .await + .unwrap(); + + thread + .update(cx, |thread, _| thread.initialize()) + .await + .unwrap(); + thread + } + + fn init_test(cx: &mut TestAppContext) { + env_logger::try_init().ok(); + cx.update(|cx| { + let settings_store = SettingsStore::test(cx); + cx.set_global(settings_store); + Project::init_settings(cx); + language::init(cx); + }); + } + + #[gpui::test] + #[cfg_attr(not(feature = "gemini"), ignore)] + async fn test_gemini_basic(cx: &mut TestAppContext) { + init_test(cx); + + cx.executor().allow_parking(); + + let fs = FakeFs::new(cx.executor()); + let project = Project::test(fs, [], cx).await; + let thread = gemini_acp_thread(project.clone(), "/private/tmp", cx).await; + thread + .update(cx, |thread, cx| thread.send_raw("Hello from Zed!", cx)) + .await + .unwrap(); + + thread.read_with(cx, |thread, _| { + assert_eq!(thread.entries().len(), 2); + assert!(matches!( + thread.entries()[0], + AgentThreadEntry::UserMessage(_) + )); + assert!(matches!( + thread.entries()[1], + AgentThreadEntry::AssistantMessage(_) + )); + }); + } + + #[gpui::test] + #[cfg_attr(not(feature = "gemini"), ignore)] + async fn test_gemini_path_mentions(cx: &mut TestAppContext) { + init_test(cx); + + cx.executor().allow_parking(); + let tempdir = tempfile::tempdir().unwrap(); + std::fs::write( + tempdir.path().join("foo.rs"), + indoc! {" + fn main() { + println!(\"Hello, world!\"); + } + "}, + ) + .expect("failed to write file"); + let project = Project::example([tempdir.path()], &mut cx.to_async()).await; + let thread = gemini_acp_thread(project.clone(), tempdir.path(), cx).await; + thread + .update(cx, |thread, cx| { + thread.send( + acp::SendUserMessageParams { + chunks: vec![ + acp::UserMessageChunk::Text { + text: "Read the file ".into(), + }, + acp::UserMessageChunk::Path { + path: Path::new("foo.rs").into(), + }, + acp::UserMessageChunk::Text { + text: " and tell me what the content of the println! is".into(), + }, + ], + }, + cx, + ) + }) + .await + .unwrap(); + + thread.read_with(cx, |thread, cx| { + assert_eq!(thread.entries().len(), 3); + assert!(matches!( + thread.entries()[0], + AgentThreadEntry::UserMessage(_) + )); + assert!(matches!(thread.entries()[1], AgentThreadEntry::ToolCall(_))); + let AgentThreadEntry::AssistantMessage(assistant_message) = &thread.entries()[2] else { + panic!("Expected AssistantMessage") + }; + assert!( + assistant_message.to_markdown(cx).contains("Hello, world!"), + "unexpected assistant message: {:?}", + assistant_message.to_markdown(cx) + ); + }); + } + + #[gpui::test] + #[cfg_attr(not(feature = "gemini"), ignore)] + async fn test_gemini_tool_call(cx: &mut TestAppContext) { + init_test(cx); + + cx.executor().allow_parking(); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree( + path!("/private/tmp"), + json!({"foo": "Lorem ipsum dolor", "bar": "bar", "baz": "baz"}), + ) + .await; + let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await; + let thread = gemini_acp_thread(project.clone(), "/private/tmp", cx).await; + thread + .update(cx, |thread, cx| { + thread.send_raw( + "Read the '/private/tmp/foo' file and tell me what you see.", + cx, + ) + }) + .await + .unwrap(); + thread.read_with(cx, |thread, _cx| { + assert!(matches!( + &thread.entries()[2], + AgentThreadEntry::ToolCall(ToolCall { + status: ToolCallStatus::Allowed { .. }, + .. + }) + )); + + assert!(matches!( + thread.entries()[3], + AgentThreadEntry::AssistantMessage(_) + )); + }); + } + + #[gpui::test] + #[cfg_attr(not(feature = "gemini"), ignore)] + async fn test_gemini_tool_call_with_confirmation(cx: &mut TestAppContext) { + init_test(cx); + + cx.executor().allow_parking(); + + let fs = FakeFs::new(cx.executor()); + let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await; + let thread = gemini_acp_thread(project.clone(), "/private/tmp", cx).await; + let full_turn = thread.update(cx, |thread, cx| { + thread.send_raw(r#"Run `echo "Hello, world!"`"#, cx) + }); + + run_until_first_tool_call(&thread, cx).await; + + let tool_call_id = thread.read_with(cx, |thread, _cx| { + let AgentThreadEntry::ToolCall(ToolCall { + id, + status: + ToolCallStatus::WaitingForConfirmation { + confirmation: ToolCallConfirmation::Execute { root_command, .. }, + .. + }, + .. + }) = &thread.entries()[2] + else { + panic!(); + }; + + assert_eq!(root_command, "echo"); + + *id + }); + + thread.update(cx, |thread, cx| { + thread.authorize_tool_call(tool_call_id, acp::ToolCallConfirmationOutcome::Allow, cx); + + assert!(matches!( + &thread.entries()[2], + AgentThreadEntry::ToolCall(ToolCall { + status: ToolCallStatus::Allowed { .. }, + .. + }) + )); + }); + + full_turn.await.unwrap(); + + thread.read_with(cx, |thread, cx| { + let AgentThreadEntry::ToolCall(ToolCall { + content: Some(ToolCallContent::Markdown { markdown }), + status: ToolCallStatus::Allowed { .. }, + .. + }) = &thread.entries()[2] + else { + panic!(); + }; + + markdown.read_with(cx, |md, _cx| { + assert!( + md.source().contains("Hello, world!"), + r#"Expected '{}' to contain "Hello, world!""#, + md.source() + ); + }); + }); + } + + #[gpui::test] + #[cfg_attr(not(feature = "gemini"), ignore)] + async fn test_gemini_cancel(cx: &mut TestAppContext) { + init_test(cx); + + cx.executor().allow_parking(); + + let fs = FakeFs::new(cx.executor()); + let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await; + let thread = gemini_acp_thread(project.clone(), "/private/tmp", cx).await; + let full_turn = thread.update(cx, |thread, cx| { + thread.send_raw(r#"Run `echo "Hello, world!"`"#, cx) + }); + + let first_tool_call_ix = run_until_first_tool_call(&thread, cx).await; + + thread.read_with(cx, |thread, _cx| { + let AgentThreadEntry::ToolCall(ToolCall { + id, + status: + ToolCallStatus::WaitingForConfirmation { + confirmation: ToolCallConfirmation::Execute { root_command, .. }, + .. + }, + .. + }) = &thread.entries()[first_tool_call_ix] + else { + panic!("{:?}", thread.entries()[1]); + }; + + assert_eq!(root_command, "echo"); + + *id + }); + + thread + .update(cx, |thread, cx| thread.cancel(cx)) + .await + .unwrap(); + full_turn.await.unwrap(); + thread.read_with(cx, |thread, _| { + let AgentThreadEntry::ToolCall(ToolCall { + status: ToolCallStatus::Canceled, + .. + }) = &thread.entries()[first_tool_call_ix] + else { + panic!(); + }; + }); + + thread + .update(cx, |thread, cx| { + thread.send_raw(r#"Stop running and say goodbye to me."#, cx) + }) + .await + .unwrap(); + thread.read_with(cx, |thread, _| { + assert!(matches!( + &thread.entries().last().unwrap(), + AgentThreadEntry::AssistantMessage(..), + )) + }); + } + + async fn run_until_first_tool_call( + thread: &Entity, + cx: &mut TestAppContext, + ) -> usize { + let (mut tx, mut rx) = mpsc::channel::(1); + + let subscription = cx.update(|cx| { + cx.subscribe(thread, move |thread, _, cx| { + for (ix, entry) in thread.read(cx).entries().iter().enumerate() { + if matches!(entry, AgentThreadEntry::ToolCall(_)) { + return tx.try_send(ix).unwrap(); + } + } + }) + }); + + select! { + _ = cx.executor().timer(Duration::from_secs(10)).fuse() => { + panic!("Timeout waiting for tool call") + } + ix = rx.next().fuse() => { + drop(subscription); + ix.unwrap() + } + } + } +} diff --git a/crates/agent_servers/src/settings.rs b/crates/agent_servers/src/settings.rs new file mode 100644 index 0000000000..8e6914352b --- /dev/null +++ b/crates/agent_servers/src/settings.rs @@ -0,0 +1,41 @@ +use crate::AgentServerCommand; +use anyhow::Result; +use gpui::App; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use settings::{Settings, SettingsSources}; + +pub fn init(cx: &mut App) { + AllAgentServersSettings::register(cx); +} + +#[derive(Default, Deserialize, Serialize, Clone, JsonSchema, Debug)] +pub struct AllAgentServersSettings { + pub gemini: Option, +} + +#[derive(Deserialize, Serialize, Clone, JsonSchema, Debug)] +pub struct AgentServerSettings { + #[serde(flatten)] + pub command: AgentServerCommand, +} + +impl settings::Settings for AllAgentServersSettings { + const KEY: Option<&'static str> = Some("agent_servers"); + + type FileContent = Self; + + fn load(sources: SettingsSources, _: &mut App) -> Result { + let mut settings = AllAgentServersSettings::default(); + + for value in sources.defaults_and_customizations() { + if value.gemini.is_some() { + settings.gemini = value.gemini.clone(); + } + } + + Ok(settings) + } + + fn import_from_vscode(_vscode: &settings::VsCodeSettings, _current: &mut Self::FileContent) {} +} diff --git a/crates/agent_servers/src/stdio_agent_server.rs b/crates/agent_servers/src/stdio_agent_server.rs new file mode 100644 index 0000000000..d78506022d --- /dev/null +++ b/crates/agent_servers/src/stdio_agent_server.rs @@ -0,0 +1,169 @@ +use crate::{AgentServer, AgentServerCommand, AgentServerVersion}; +use acp_thread::{AcpClientDelegate, AcpThread, LoadError}; +use agentic_coding_protocol as acp; +use anyhow::{Result, anyhow}; +use gpui::{App, AsyncApp, Entity, Task, prelude::*}; +use project::Project; +use std::{ + path::{Path, PathBuf}, + sync::Arc, +}; +use util::{ResultExt, paths}; + +pub trait StdioAgentServer: Send + Clone { + fn logo(&self) -> ui::IconName; + fn name(&self) -> &'static str; + fn empty_state_headline(&self) -> &'static str; + fn empty_state_message(&self) -> &'static str; + fn supports_always_allow(&self) -> bool; + + fn command( + &self, + project: &Entity, + cx: &mut AsyncApp, + ) -> impl Future>; + + fn version( + &self, + command: &AgentServerCommand, + ) -> impl Future> + Send; +} + +impl AgentServer for T { + fn name(&self) -> &'static str { + self.name() + } + + fn empty_state_headline(&self) -> &'static str { + self.empty_state_headline() + } + + fn empty_state_message(&self) -> &'static str { + self.empty_state_message() + } + + fn logo(&self) -> ui::IconName { + self.logo() + } + + fn supports_always_allow(&self) -> bool { + self.supports_always_allow() + } + + fn new_thread( + &self, + root_dir: &Path, + project: &Entity, + cx: &mut App, + ) -> Task>> { + let root_dir = root_dir.to_path_buf(); + let project = project.clone(); + let this = self.clone(); + let title = self.name().into(); + + cx.spawn(async move |cx| { + let command = this.command(&project, cx).await?; + + let mut child = util::command::new_smol_command(&command.path) + .args(command.args.iter()) + .current_dir(root_dir) + .stdin(std::process::Stdio::piped()) + .stdout(std::process::Stdio::piped()) + .stderr(std::process::Stdio::inherit()) + .kill_on_drop(true) + .spawn()?; + + let stdin = child.stdin.take().unwrap(); + let stdout = child.stdout.take().unwrap(); + + cx.new(|cx| { + let foreground_executor = cx.foreground_executor().clone(); + + let (connection, io_fut) = acp::AgentConnection::connect_to_agent( + AcpClientDelegate::new(cx.entity().downgrade(), cx.to_async()), + stdin, + stdout, + move |fut| foreground_executor.spawn(fut).detach(), + ); + + let io_task = cx.background_spawn(async move { + io_fut.await.log_err(); + }); + + let child_status = cx.background_spawn(async move { + let result = match child.status().await { + Err(e) => Err(anyhow!(e)), + Ok(result) if result.success() => Ok(()), + Ok(result) => { + if let Some(AgentServerVersion::Unsupported { + error_message, + upgrade_message, + upgrade_command, + }) = this.version(&command).await.log_err() + { + Err(anyhow!(LoadError::Unsupported { + error_message, + upgrade_message, + upgrade_command + })) + } else { + Err(anyhow!(LoadError::Exited(result.code().unwrap_or(-127)))) + } + } + }; + drop(io_task); + result + }); + + AcpThread::new(connection, title, Some(child_status), project.clone(), cx) + }) + }) + } +} + +pub async fn find_bin_in_path( + bin_name: &'static str, + project: &Entity, + cx: &mut AsyncApp, +) -> Option { + let (env_task, root_dir) = project + .update(cx, |project, cx| { + let worktree = project.visible_worktrees(cx).next(); + match worktree { + Some(worktree) => { + let env_task = project.environment().update(cx, |env, cx| { + env.get_worktree_environment(worktree.clone(), cx) + }); + + let path = worktree.read(cx).abs_path(); + (env_task, path) + } + None => { + let path: Arc = paths::home_dir().as_path().into(); + let env_task = project.environment().update(cx, |env, cx| { + env.get_directory_environment(path.clone(), cx) + }); + (env_task, path) + } + } + }) + .log_err()?; + + cx.background_executor() + .spawn(async move { + let which_result = if cfg!(windows) { + which::which(bin_name) + } else { + let env = env_task.await.unwrap_or_default(); + let shell_path = env.get("PATH").cloned(); + which::which_in(bin_name, shell_path.as_ref(), root_dir.as_ref()) + }; + + if let Err(which::Error::CannotFindBinaryPath) = which_result { + return None; + } + + which_result.log_err() + }) + .await +} diff --git a/crates/agent_ui/Cargo.toml b/crates/agent_ui/Cargo.toml index 72466fe8e7..d4feceb0b6 100644 --- a/crates/agent_ui/Cargo.toml +++ b/crates/agent_ui/Cargo.toml @@ -16,7 +16,7 @@ doctest = false test-support = ["gpui/test-support", "language/test-support"] [dependencies] -acp.workspace = true +acp_thread.workspace = true agent.workspace = true agentic-coding-protocol.workspace = true agent_settings.workspace = true diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index 7ab395815f..765f4fe6c0 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -1,3 +1,4 @@ +use agent_servers::AgentServer; use std::cell::RefCell; use std::collections::BTreeMap; use std::path::Path; @@ -35,7 +36,7 @@ use util::ResultExt; use workspace::{CollaboratorId, Workspace}; use zed_actions::agent::{Chat, NextHistoryMessage, PreviousHistoryMessage}; -use ::acp::{ +use ::acp_thread::{ AcpThread, AcpThreadEvent, AgentThreadEntry, AssistantMessage, AssistantMessageChunk, Diff, LoadError, MentionPath, ThreadStatus, ToolCall, ToolCallConfirmation, ToolCallContent, ToolCallId, ToolCallStatus, @@ -49,6 +50,7 @@ use crate::{AgentDiffPane, Follow, KeepAll, OpenAgentDiff, RejectAll}; const RESPONSE_PADDING_X: Pixels = px(19.); pub struct AcpThreadView { + agent: Rc, workspace: WeakEntity, project: Entity, thread_state: ThreadState, @@ -80,8 +82,15 @@ enum ThreadState { }, } +struct AlwaysAllowOption { + id: &'static str, + label: SharedString, + outcome: acp::ToolCallConfirmationOutcome, +} + impl AcpThreadView { pub fn new( + agent: Rc, workspace: WeakEntity, project: Entity, message_history: Rc>>, @@ -158,9 +167,10 @@ impl AcpThreadView { ); Self { + agent: agent.clone(), workspace: workspace.clone(), project: project.clone(), - thread_state: Self::initial_state(workspace, project, window, cx), + thread_state: Self::initial_state(agent, workspace, project, window, cx), message_editor, message_set_from_history: false, _message_editor_subscription: message_editor_subscription, @@ -177,6 +187,7 @@ impl AcpThreadView { } fn initial_state( + agent: Rc, workspace: WeakEntity, project: Entity, window: &mut Window, @@ -189,9 +200,9 @@ impl AcpThreadView { .map(|worktree| worktree.read(cx).abs_path()) .unwrap_or_else(|| paths::home_dir().as_path().into()); + let task = agent.new_thread(&root_dir, &project, cx); let load_task = cx.spawn_in(window, async move |this, cx| { - let thread = match AcpThread::spawn(agent_servers::Gemini, &root_dir, project, cx).await - { + let thread = match task.await { Ok(thread) => thread, Err(err) => { this.update(cx, |this, cx| { @@ -410,6 +421,33 @@ impl AcpThreadView { ); } + fn open_agent_diff(&mut self, _: &OpenAgentDiff, window: &mut Window, cx: &mut Context) { + if let Some(thread) = self.thread() { + AgentDiffPane::deploy(thread.clone(), self.workspace.clone(), window, cx).log_err(); + } + } + + fn open_edited_buffer( + &mut self, + buffer: &Entity, + window: &mut Window, + cx: &mut Context, + ) { + let Some(thread) = self.thread() else { + return; + }; + + let Some(diff) = + AgentDiffPane::deploy(thread.clone(), self.workspace.clone(), window, cx).log_err() + else { + return; + }; + + diff.update(cx, |diff, cx| { + diff.move_to_path(PathKey::for_buffer(&buffer, cx), window, cx) + }) + } + fn set_draft_message( message_editor: Entity, mention_set: Arc>, @@ -485,33 +523,6 @@ impl AcpThreadView { true } - fn open_agent_diff(&mut self, _: &OpenAgentDiff, window: &mut Window, cx: &mut Context) { - if let Some(thread) = self.thread() { - AgentDiffPane::deploy(thread.clone(), self.workspace.clone(), window, cx).log_err(); - } - } - - fn open_edited_buffer( - &mut self, - buffer: &Entity, - window: &mut Window, - cx: &mut Context, - ) { - let Some(thread) = self.thread() else { - return; - }; - - let Some(diff) = - AgentDiffPane::deploy(thread.clone(), self.workspace.clone(), window, cx).log_err() - else { - return; - }; - - diff.update(cx, |diff, cx| { - diff.move_to_path(PathKey::for_buffer(&buffer, cx), window, cx) - }) - } - fn handle_thread_event( &mut self, thread: &Entity, @@ -608,6 +619,7 @@ impl AcpThreadView { let authenticate = thread.read(cx).authenticate(); self.auth_task = Some(cx.spawn_in(window, { let project = self.project.clone(); + let agent = self.agent.clone(); async move |this, cx| { let result = authenticate.await; @@ -617,8 +629,13 @@ impl AcpThreadView { Markdown::new(format!("Error: {err}").into(), None, None, cx) })) } else { - this.thread_state = - Self::initial_state(this.workspace.clone(), project.clone(), window, cx) + this.thread_state = Self::initial_state( + agent, + this.workspace.clone(), + project.clone(), + window, + cx, + ) } this.auth_task.take() }) @@ -1047,14 +1064,6 @@ impl AcpThreadView { ) -> AnyElement { let confirmation_container = v_flex().mt_1().py_1p5(); - let button_container = h_flex() - .pt_1p5() - .px_1p5() - .gap_1() - .justify_end() - .border_t_1() - .border_color(self.tool_card_border_color(cx)); - match confirmation { ToolCallConfirmation::Edit { description } => confirmation_container .child( @@ -1068,60 +1077,15 @@ impl AcpThreadView { })), ) .children(content.map(|content| self.render_tool_call_content(content, window, cx))) - .child( - button_container - .child( - Button::new(("always_allow", tool_call_id.0), "Always Allow Edits") - .icon(IconName::CheckDouble) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Success) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::AlwaysAllow, - cx, - ); - } - })), - ) - .child( - Button::new(("allow", tool_call_id.0), "Allow") - .icon(IconName::Check) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Success) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::Allow, - cx, - ); - } - })), - ) - .child( - Button::new(("reject", tool_call_id.0), "Reject") - .icon(IconName::X) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Error) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::Reject, - cx, - ); - } - })), - ), - ) + .child(self.render_confirmation_buttons( + &[AlwaysAllowOption { + id: "always_allow", + label: "Always Allow Edits".into(), + outcome: acp::ToolCallConfirmationOutcome::AlwaysAllow, + }], + tool_call_id, + cx, + )) .into_any(), ToolCallConfirmation::Execute { command, @@ -1140,66 +1104,15 @@ impl AcpThreadView { }), )) .children(content.map(|content| self.render_tool_call_content(content, window, cx))) - .child( - button_container - .child( - Button::new( - ("always_allow", tool_call_id.0), - format!("Always Allow {root_command}"), - ) - .icon(IconName::CheckDouble) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Success) - .label_size(LabelSize::Small) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::AlwaysAllow, - cx, - ); - } - })), - ) - .child( - Button::new(("allow", tool_call_id.0), "Allow") - .icon(IconName::Check) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Success) - .label_size(LabelSize::Small) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::Allow, - cx, - ); - } - })), - ) - .child( - Button::new(("reject", tool_call_id.0), "Reject") - .icon(IconName::X) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Error) - .label_size(LabelSize::Small) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::Reject, - cx, - ); - } - })), - ), - ) + .child(self.render_confirmation_buttons( + &[AlwaysAllowOption { + id: "always_allow", + label: format!("Always Allow {root_command}").into(), + outcome: acp::ToolCallConfirmationOutcome::AlwaysAllow, + }], + tool_call_id, + cx, + )) .into_any(), ToolCallConfirmation::Mcp { server_name, @@ -1220,87 +1133,22 @@ impl AcpThreadView { })), ) .children(content.map(|content| self.render_tool_call_content(content, window, cx))) - .child( - button_container - .child( - Button::new( - ("always_allow_server", tool_call_id.0), - format!("Always Allow {server_name}"), - ) - .icon(IconName::CheckDouble) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Success) - .label_size(LabelSize::Small) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::AlwaysAllowMcpServer, - cx, - ); - } - })), - ) - .child( - Button::new( - ("always_allow_tool", tool_call_id.0), - format!("Always Allow {tool_display_name}"), - ) - .icon(IconName::CheckDouble) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Success) - .label_size(LabelSize::Small) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::AlwaysAllowTool, - cx, - ); - } - })), - ) - .child( - Button::new(("allow", tool_call_id.0), "Allow") - .icon(IconName::Check) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Success) - .label_size(LabelSize::Small) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::Allow, - cx, - ); - } - })), - ) - .child( - Button::new(("reject", tool_call_id.0), "Reject") - .icon(IconName::X) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Error) - .label_size(LabelSize::Small) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::Reject, - cx, - ); - } - })), - ), - ) + .child(self.render_confirmation_buttons( + &[ + AlwaysAllowOption { + id: "always_allow_server", + label: format!("Always Allow {server_name}").into(), + outcome: acp::ToolCallConfirmationOutcome::AlwaysAllowMcpServer, + }, + AlwaysAllowOption { + id: "always_allow_tool", + label: format!("Always Allow {tool_display_name}").into(), + outcome: acp::ToolCallConfirmationOutcome::AlwaysAllowTool, + }, + ], + tool_call_id, + cx, + )) .into_any(), ToolCallConfirmation::Fetch { description, urls } => confirmation_container .child( @@ -1328,63 +1176,15 @@ impl AcpThreadView { })), ) .children(content.map(|content| self.render_tool_call_content(content, window, cx))) - .child( - button_container - .child( - Button::new(("always_allow", tool_call_id.0), "Always Allow") - .icon(IconName::CheckDouble) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Success) - .label_size(LabelSize::Small) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::AlwaysAllow, - cx, - ); - } - })), - ) - .child( - Button::new(("allow", tool_call_id.0), "Allow") - .icon(IconName::Check) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Success) - .label_size(LabelSize::Small) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::Allow, - cx, - ); - } - })), - ) - .child( - Button::new(("reject", tool_call_id.0), "Reject") - .icon(IconName::X) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Error) - .label_size(LabelSize::Small) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::Reject, - cx, - ); - } - })), - ), - ) + .child(self.render_confirmation_buttons( + &[AlwaysAllowOption { + id: "always_allow", + label: "Always Allow".into(), + outcome: acp::ToolCallConfirmationOutcome::AlwaysAllow, + }], + tool_call_id, + cx, + )) .into_any(), ToolCallConfirmation::Other { description } => confirmation_container .child(v_flex().px_2().pb_1p5().child(self.render_markdown( @@ -1392,67 +1192,87 @@ impl AcpThreadView { default_markdown_style(false, window, cx), ))) .children(content.map(|content| self.render_tool_call_content(content, window, cx))) - .child( - button_container - .child( - Button::new(("always_allow", tool_call_id.0), "Always Allow") - .icon(IconName::CheckDouble) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Success) - .label_size(LabelSize::Small) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::AlwaysAllow, - cx, - ); - } - })), - ) - .child( - Button::new(("allow", tool_call_id.0), "Allow") - .icon(IconName::Check) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Success) - .label_size(LabelSize::Small) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::Allow, - cx, - ); - } - })), - ) - .child( - Button::new(("reject", tool_call_id.0), "Reject") - .icon(IconName::X) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Error) - .label_size(LabelSize::Small) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::Reject, - cx, - ); - } - })), - ), - ) + .child(self.render_confirmation_buttons( + &[AlwaysAllowOption { + id: "always_allow", + label: "Always Allow".into(), + outcome: acp::ToolCallConfirmationOutcome::AlwaysAllow, + }], + tool_call_id, + cx, + )) .into_any(), } } + fn render_confirmation_buttons( + &self, + always_allow_options: &[AlwaysAllowOption], + tool_call_id: ToolCallId, + cx: &Context, + ) -> Div { + h_flex() + .pt_1p5() + .px_1p5() + .gap_1() + .justify_end() + .border_t_1() + .border_color(self.tool_card_border_color(cx)) + .when(self.agent.supports_always_allow(), |this| { + this.children(always_allow_options.into_iter().map(|always_allow_option| { + let outcome = always_allow_option.outcome; + Button::new( + (always_allow_option.id, tool_call_id.0), + always_allow_option.label.clone(), + ) + .icon(IconName::CheckDouble) + .icon_position(IconPosition::Start) + .icon_size(IconSize::XSmall) + .icon_color(Color::Success) + .on_click(cx.listener({ + let id = tool_call_id; + move |this, _, _, cx| { + this.authorize_tool_call(id, outcome, cx); + } + })) + })) + }) + .child( + Button::new(("allow", tool_call_id.0), "Allow") + .icon(IconName::Check) + .icon_position(IconPosition::Start) + .icon_size(IconSize::XSmall) + .icon_color(Color::Success) + .on_click(cx.listener({ + let id = tool_call_id; + move |this, _, _, cx| { + this.authorize_tool_call( + id, + acp::ToolCallConfirmationOutcome::Allow, + cx, + ); + } + })), + ) + .child( + Button::new(("reject", tool_call_id.0), "Reject") + .icon(IconName::X) + .icon_position(IconPosition::Start) + .icon_size(IconSize::XSmall) + .icon_color(Color::Error) + .on_click(cx.listener({ + let id = tool_call_id; + move |this, _, _, cx| { + this.authorize_tool_call( + id, + acp::ToolCallConfirmationOutcome::Reject, + cx, + ); + } + })), + ) + } + fn render_diff_editor(&self, multibuffer: &Entity) -> AnyElement { v_flex() .h_full() @@ -1466,15 +1286,15 @@ impl AcpThreadView { .into_any() } - fn render_gemini_logo(&self) -> AnyElement { - Icon::new(IconName::AiGemini) + fn render_agent_logo(&self) -> AnyElement { + Icon::new(self.agent.logo()) .color(Color::Muted) .size(IconSize::XLarge) .into_any_element() } - fn render_error_gemini_logo(&self) -> AnyElement { - let logo = Icon::new(IconName::AiGemini) + fn render_error_agent_logo(&self) -> AnyElement { + let logo = Icon::new(self.agent.logo()) .color(Color::Muted) .size(IconSize::XLarge) .into_any_element(); @@ -1493,49 +1313,50 @@ impl AcpThreadView { .into_any_element() } - fn render_empty_state(&self, loading: bool, cx: &App) -> AnyElement { + fn render_empty_state(&self, cx: &App) -> AnyElement { + let loading = matches!(&self.thread_state, ThreadState::Loading { .. }); + v_flex() .size_full() .items_center() .justify_center() - .child( - if loading { - h_flex() - .justify_center() - .child(self.render_gemini_logo()) - .with_animation( - "pulsating_icon", - Animation::new(Duration::from_secs(2)) - .repeat() - .with_easing(pulsating_between(0.4, 1.0)), - |icon, delta| icon.opacity(delta), - ).into_any() - } else { - self.render_gemini_logo().into_any_element() - } - ) - .child( + .child(if loading { h_flex() - .mt_4() - .mb_1() .justify_center() - .child(Headline::new(if loading { - "Connecting to Gemini…" - } else { - "Welcome to Gemini" - }).size(HeadlineSize::Medium)), - ) + .child(self.render_agent_logo()) + .with_animation( + "pulsating_icon", + Animation::new(Duration::from_secs(2)) + .repeat() + .with_easing(pulsating_between(0.4, 1.0)), + |icon, delta| icon.opacity(delta), + ) + .into_any() + } else { + self.render_agent_logo().into_any_element() + }) + .child(h_flex().mt_4().mb_1().justify_center().child(if loading { + div() + .child(LoadingLabel::new("").size(LabelSize::Large)) + .into_any_element() + } else { + Headline::new(self.agent.empty_state_headline()) + .size(HeadlineSize::Medium) + .into_any_element() + })) .child( div() .max_w_1_2() .text_sm() .text_center() - .map(|this| if loading { - this.invisible() - } else { - this.text_color(cx.theme().colors().text_muted) + .map(|this| { + if loading { + this.invisible() + } else { + this.text_color(cx.theme().colors().text_muted) + } }) - .child("Ask questions, edit files, run commands.\nBe specific for the best results.") + .child(self.agent.empty_state_message()), ) .into_any() } @@ -1544,7 +1365,7 @@ impl AcpThreadView { v_flex() .items_center() .justify_center() - .child(self.render_error_gemini_logo()) + .child(self.render_error_agent_logo()) .child( h_flex() .mt_4() @@ -1559,7 +1380,7 @@ impl AcpThreadView { let mut container = v_flex() .items_center() .justify_center() - .child(self.render_error_gemini_logo()) + .child(self.render_error_agent_logo()) .child( v_flex() .mt_4() @@ -1575,43 +1396,47 @@ impl AcpThreadView { ), ); - if matches!(e, LoadError::Unsupported { .. }) { - container = - container.child(Button::new("upgrade", "Upgrade Gemini to Latest").on_click( - cx.listener(|this, _, window, cx| { - this.workspace - .update(cx, |workspace, cx| { - let project = workspace.project().read(cx); - let cwd = project.first_project_directory(cx); - let shell = project.terminal_settings(&cwd, cx).shell.clone(); - let command = - "npm install -g @google/gemini-cli@latest".to_string(); - let spawn_in_terminal = task::SpawnInTerminal { - id: task::TaskId("install".to_string()), - full_label: command.clone(), - label: command.clone(), - command: Some(command.clone()), - args: Vec::new(), - command_label: command.clone(), - cwd, - env: Default::default(), - use_new_terminal: true, - allow_concurrent_runs: true, - reveal: Default::default(), - reveal_target: Default::default(), - hide: Default::default(), - shell, - show_summary: true, - show_command: true, - show_rerun: false, - }; - workspace - .spawn_in_terminal(spawn_in_terminal, window, cx) - .detach(); - }) - .ok(); - }), - )); + if let LoadError::Unsupported { + upgrade_message, + upgrade_command, + .. + } = &e + { + let upgrade_message = upgrade_message.clone(); + let upgrade_command = upgrade_command.clone(); + container = container.child(Button::new("upgrade", upgrade_message).on_click( + cx.listener(move |this, _, window, cx| { + this.workspace + .update(cx, |workspace, cx| { + let project = workspace.project().read(cx); + let cwd = project.first_project_directory(cx); + let shell = project.terminal_settings(&cwd, cx).shell.clone(); + let spawn_in_terminal = task::SpawnInTerminal { + id: task::TaskId("install".to_string()), + full_label: upgrade_command.clone(), + label: upgrade_command.clone(), + command: Some(upgrade_command.clone()), + args: Vec::new(), + command_label: upgrade_command.clone(), + cwd, + env: Default::default(), + use_new_terminal: true, + allow_concurrent_runs: true, + reveal: Default::default(), + reveal_target: Default::default(), + hide: Default::default(), + shell, + show_summary: true, + show_command: true, + show_rerun: false, + }; + workspace + .spawn_in_terminal(spawn_in_terminal, window, cx) + .detach(); + }) + .ok(); + }), + )); } container.into_any() @@ -2267,20 +2092,23 @@ impl Render for AcpThreadView { .on_action(cx.listener(Self::next_history_message)) .on_action(cx.listener(Self::open_agent_diff)) .child(match &self.thread_state { - ThreadState::Unauthenticated { .. } => v_flex() - .p_2() - .flex_1() - .items_center() - .justify_center() - .child(self.render_pending_auth_state()) - .child(h_flex().mt_1p5().justify_center().child( - Button::new("sign-in", "Sign in to Gemini").on_click( - cx.listener(|this, _, window, cx| this.authenticate(window, cx)), - ), - )), - ThreadState::Loading { .. } => { - v_flex().flex_1().child(self.render_empty_state(true, cx)) + ThreadState::Unauthenticated { .. } => { + v_flex() + .p_2() + .flex_1() + .items_center() + .justify_center() + .child(self.render_pending_auth_state()) + .child( + h_flex().mt_1p5().justify_center().child( + Button::new("sign-in", format!("Sign in to {}", self.agent.name())) + .on_click(cx.listener(|this, _, window, cx| { + this.authenticate(window, cx) + })), + ), + ) } + ThreadState::Loading { .. } => v_flex().flex_1().child(self.render_empty_state(cx)), ThreadState::LoadError(e) => v_flex() .p_2() .flex_1() @@ -2321,7 +2149,7 @@ impl Render for AcpThreadView { }) .children(self.render_edits_bar(&thread, window, cx)) } else { - this.child(self.render_empty_state(false, cx)) + this.child(self.render_empty_state(cx)) } }), }) diff --git a/crates/agent_ui/src/agent_diff.rs b/crates/agent_ui/src/agent_diff.rs index 000e270322..e69664ce88 100644 --- a/crates/agent_ui/src/agent_diff.rs +++ b/crates/agent_ui/src/agent_diff.rs @@ -1,5 +1,5 @@ use crate::{Keep, KeepAll, OpenAgentDiff, Reject, RejectAll}; -use acp::{AcpThread, AcpThreadEvent}; +use acp_thread::{AcpThread, AcpThreadEvent}; use agent::{Thread, ThreadEvent, ThreadSummary}; use agent_settings::AgentSettings; use anyhow::Result; @@ -81,7 +81,7 @@ impl AgentDiffThread { match self { AgentDiffThread::Native(thread) => thread.read(cx).is_generating(), AgentDiffThread::AcpThread(thread) => { - thread.read(cx).status() == acp::ThreadStatus::Generating + thread.read(cx).status() == acp_thread::ThreadStatus::Generating } } } diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 2caa9dab42..895a499502 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -5,10 +5,11 @@ use std::rc::Rc; use std::sync::Arc; use std::time::Duration; +use agent_servers::AgentServer; use db::kvp::{Dismissable, KEY_VALUE_STORE}; use serde::{Deserialize, Serialize}; -use crate::NewAcpThread; +use crate::NewExternalAgentThread; use crate::agent_diff::AgentDiffThread; use crate::language_model_selector::ToggleModelSelector; use crate::{ @@ -114,10 +115,12 @@ pub fn init(cx: &mut App) { panel.update(cx, |panel, cx| panel.new_prompt_editor(window, cx)); } }) - .register_action(|workspace, _: &NewAcpThread, window, cx| { + .register_action(|workspace, action: &NewExternalAgentThread, window, cx| { if let Some(panel) = workspace.panel::(cx) { workspace.focus_panel::(window, cx); - panel.update(cx, |panel, cx| panel.new_gemini_thread(window, cx)); + panel.update(cx, |panel, cx| { + panel.new_external_thread(action.agent, window, cx) + }); } }) .register_action(|workspace, action: &OpenRulesLibrary, window, cx| { @@ -136,7 +139,7 @@ pub fn init(cx: &mut App) { let thread = thread.read(cx).thread().clone(); AgentDiffPane::deploy_in_workspace(thread, workspace, window, cx); } - ActiveView::AcpThread { .. } + ActiveView::ExternalAgentThread { .. } | ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => {} @@ -200,7 +203,7 @@ enum ActiveView { message_editor: Entity, _subscriptions: Vec, }, - AcpThread { + ExternalAgentThread { thread_view: Entity, }, TextThread { @@ -222,9 +225,9 @@ enum WhichFontSize { impl ActiveView { pub fn which_font_size_used(&self) -> WhichFontSize { match self { - ActiveView::Thread { .. } | ActiveView::AcpThread { .. } | ActiveView::History => { - WhichFontSize::AgentFont - } + ActiveView::Thread { .. } + | ActiveView::ExternalAgentThread { .. } + | ActiveView::History => WhichFontSize::AgentFont, ActiveView::TextThread { .. } => WhichFontSize::BufferFont, ActiveView::Configuration => WhichFontSize::None, } @@ -255,7 +258,7 @@ impl ActiveView { thread.scroll_to_bottom(cx); }); } - ActiveView::AcpThread { .. } => {} + ActiveView::ExternalAgentThread { .. } => {} ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => {} @@ -674,7 +677,7 @@ impl AgentPanel { .clone() .update(cx, |thread, cx| thread.get_or_init_configured_model(cx)); } - ActiveView::AcpThread { .. } + ActiveView::ExternalAgentThread { .. } | ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => {} @@ -757,7 +760,7 @@ impl AgentPanel { ActiveView::Thread { thread, .. } => { thread.update(cx, |thread, cx| thread.cancel_last_completion(window, cx)); } - ActiveView::AcpThread { thread_view, .. } => { + ActiveView::ExternalAgentThread { thread_view, .. } => { thread_view.update(cx, |thread_element, cx| thread_element.cancel(cx)); } ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => {} @@ -767,7 +770,7 @@ impl AgentPanel { fn active_message_editor(&self) -> Option<&Entity> { match &self.active_view { ActiveView::Thread { message_editor, .. } => Some(message_editor), - ActiveView::AcpThread { .. } + ActiveView::ExternalAgentThread { .. } | ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => None, @@ -889,35 +892,77 @@ impl AgentPanel { context_editor.focus_handle(cx).focus(window); } - fn new_gemini_thread(&mut self, window: &mut Window, cx: &mut Context) { + fn new_external_thread( + &mut self, + agent_choice: Option, + window: &mut Window, + cx: &mut Context, + ) { let workspace = self.workspace.clone(); let project = self.project.clone(); let message_history = self.acp_message_history.clone(); + const LAST_USED_EXTERNAL_AGENT_KEY: &str = "agent_panel__last_used_external_agent"; + + #[derive(Default, Serialize, Deserialize)] + struct LastUsedExternalAgent { + agent: crate::ExternalAgent, + } + cx.spawn_in(window, async move |this, cx| { - let thread_view = cx.new_window_entity(|window, cx| { - crate::acp::AcpThreadView::new( - workspace.clone(), - project, - message_history, - window, - cx, - ) - })?; + let server: Rc = match agent_choice { + Some(agent) => { + cx.background_spawn(async move { + if let Some(serialized) = + serde_json::to_string(&LastUsedExternalAgent { agent }).log_err() + { + KEY_VALUE_STORE + .write_kvp(LAST_USED_EXTERNAL_AGENT_KEY.to_string(), serialized) + .await + .log_err(); + } + }) + .detach(); + + agent.server() + } + None => cx + .background_spawn(async move { + KEY_VALUE_STORE.read_kvp(LAST_USED_EXTERNAL_AGENT_KEY) + }) + .await + .log_err() + .flatten() + .and_then(|value| { + serde_json::from_str::(&value).log_err() + }) + .unwrap_or_default() + .agent + .server(), + }; + this.update_in(cx, |this, window, cx| { + let thread_view = cx.new(|cx| { + crate::acp::AcpThreadView::new( + server, + workspace.clone(), + project, + message_history, + window, + cx, + ) + }); + this.set_active_view( - ActiveView::AcpThread { + ActiveView::ExternalAgentThread { thread_view: thread_view.clone(), }, window, cx, ); }) - .log_err(); - - anyhow::Ok(()) }) - .detach(); + .detach_and_log_err(cx); } fn deploy_rules_library( @@ -1084,7 +1129,7 @@ impl AgentPanel { ActiveView::Thread { message_editor, .. } => { message_editor.focus_handle(cx).focus(window); } - ActiveView::AcpThread { thread_view } => { + ActiveView::ExternalAgentThread { thread_view } => { thread_view.focus_handle(cx).focus(window); } ActiveView::TextThread { context_editor, .. } => { @@ -1211,7 +1256,7 @@ impl AgentPanel { }) .log_err(); } - ActiveView::AcpThread { .. } + ActiveView::ExternalAgentThread { .. } | ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => {} @@ -1267,7 +1312,7 @@ impl AgentPanel { ) .detach_and_log_err(cx); } - ActiveView::AcpThread { thread_view } => { + ActiveView::ExternalAgentThread { thread_view } => { thread_view .update(cx, |thread_view, cx| { thread_view.open_thread_as_markdown(workspace, window, cx) @@ -1428,7 +1473,7 @@ impl AgentPanel { } }) } - ActiveView::AcpThread { .. } => {} + ActiveView::ExternalAgentThread { .. } => {} ActiveView::History | ActiveView::Configuration => {} } @@ -1517,7 +1562,7 @@ impl Focusable for AgentPanel { fn focus_handle(&self, cx: &App) -> FocusHandle { match &self.active_view { ActiveView::Thread { message_editor, .. } => message_editor.focus_handle(cx), - ActiveView::AcpThread { thread_view, .. } => thread_view.focus_handle(cx), + ActiveView::ExternalAgentThread { thread_view, .. } => thread_view.focus_handle(cx), ActiveView::History => self.history.focus_handle(cx), ActiveView::TextThread { context_editor, .. } => context_editor.focus_handle(cx), ActiveView::Configuration => { @@ -1674,9 +1719,11 @@ impl AgentPanel { .into_any_element(), } } - ActiveView::AcpThread { thread_view } => Label::new(thread_view.read(cx).title(cx)) - .truncate() - .into_any_element(), + ActiveView::ExternalAgentThread { thread_view } => { + Label::new(thread_view.read(cx).title(cx)) + .truncate() + .into_any_element() + } ActiveView::TextThread { title_editor, context_editor, @@ -1811,7 +1858,7 @@ impl AgentPanel { let active_thread = match &self.active_view { ActiveView::Thread { thread, .. } => Some(thread.read(cx).thread().clone()), - ActiveView::AcpThread { .. } + ActiveView::ExternalAgentThread { .. } | ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => None, @@ -1849,7 +1896,20 @@ impl AgentPanel { .when(cx.has_flag::(), |this| { this.separator() .header("External Agents") - .action("New Gemini Thread", NewAcpThread.boxed_clone()) + .action( + "New Gemini Thread", + NewExternalAgentThread { + agent: Some(crate::ExternalAgent::Gemini), + } + .boxed_clone(), + ) + .action( + "New Claude Code Thread", + NewExternalAgentThread { + agent: Some(crate::ExternalAgent::ClaudeCode), + } + .boxed_clone(), + ) }); menu })) @@ -2090,7 +2150,11 @@ impl AgentPanel { Some(element.into_any_element()) } - _ => None, + ActiveView::ExternalAgentThread { .. } + | ActiveView::History + | ActiveView::Configuration => { + return None; + } } } @@ -2119,7 +2183,7 @@ impl AgentPanel { return false; } } - ActiveView::AcpThread { .. } => { + ActiveView::ExternalAgentThread { .. } => { return false; } ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => { @@ -2706,7 +2770,7 @@ impl AgentPanel { ) -> Option { let active_thread = match &self.active_view { ActiveView::Thread { thread, .. } => thread, - ActiveView::AcpThread { .. } => { + ActiveView::ExternalAgentThread { .. } => { return None; } ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => { @@ -3055,7 +3119,7 @@ impl AgentPanel { .detach(); }); } - ActiveView::AcpThread { .. } => { + ActiveView::ExternalAgentThread { .. } => { unimplemented!() } ActiveView::TextThread { context_editor, .. } => { @@ -3077,7 +3141,7 @@ impl AgentPanel { let mut key_context = KeyContext::new_with_defaults(); key_context.add("AgentPanel"); match &self.active_view { - ActiveView::AcpThread { .. } => key_context.add("acp_thread"), + ActiveView::ExternalAgentThread { .. } => key_context.add("external_agent_thread"), ActiveView::TextThread { .. } => key_context.add("prompt_editor"), ActiveView::Thread { .. } | ActiveView::History | ActiveView::Configuration => {} } @@ -3133,7 +3197,7 @@ impl Render for AgentPanel { }); this.continue_conversation(window, cx); } - ActiveView::AcpThread { .. } => {} + ActiveView::ExternalAgentThread { .. } => {} ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => {} @@ -3175,7 +3239,7 @@ impl Render for AgentPanel { }) .child(h_flex().child(message_editor.clone())) .child(self.render_drag_target(cx)), - ActiveView::AcpThread { thread_view, .. } => parent + ActiveView::ExternalAgentThread { thread_view, .. } => parent .relative() .child(thread_view.clone()) .child(self.render_drag_target(cx)), diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rs index 3170ec4a26..7f69e8f66e 100644 --- a/crates/agent_ui/src/agent_ui.rs +++ b/crates/agent_ui/src/agent_ui.rs @@ -25,6 +25,7 @@ mod thread_history; mod tool_compatibility; mod ui; +use std::rc::Rc; use std::sync::Arc; use agent::{Thread, ThreadId}; @@ -40,7 +41,7 @@ use language_model::{ }; use prompt_store::PromptBuilder; use schemars::JsonSchema; -use serde::Deserialize; +use serde::{Deserialize, Serialize}; use settings::{Settings as _, SettingsStore}; pub use crate::active_thread::ActiveThread; @@ -57,8 +58,6 @@ actions!( [ /// Creates a new text-based conversation thread. NewTextThread, - /// Creates a new external agent conversation thread. - NewAcpThread, /// Toggles the context picker interface for adding files, symbols, or other context. ToggleContextPicker, /// Toggles the navigation menu for switching between threads and views. @@ -133,6 +132,32 @@ pub struct NewThread { from_thread_id: Option, } +/// Creates a new external agent conversation thread. +#[derive(Default, Clone, PartialEq, Deserialize, JsonSchema, Action)] +#[action(namespace = agent)] +#[serde(deny_unknown_fields)] +pub struct NewExternalAgentThread { + /// Which agent to use for the conversation. + agent: Option, +} + +#[derive(Default, Clone, Copy, PartialEq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "snake_case")] +enum ExternalAgent { + #[default] + Gemini, + ClaudeCode, +} + +impl ExternalAgent { + pub fn server(&self) -> Rc { + match self { + ExternalAgent::Gemini => Rc::new(agent_servers::Gemini), + ExternalAgent::ClaudeCode => Rc::new(agent_servers::ClaudeCode), + } + } +} + /// Opens the profile management interface for configuring agent tools and settings. #[derive(PartialEq, Clone, Default, Debug, Deserialize, JsonSchema, Action)] #[action(namespace = agent)] diff --git a/crates/context_server/Cargo.toml b/crates/context_server/Cargo.toml index 96bb9e071f..5e4f8369c4 100644 --- a/crates/context_server/Cargo.toml +++ b/crates/context_server/Cargo.toml @@ -21,12 +21,14 @@ collections.workspace = true futures.workspace = true gpui.workspace = true log.workspace = true +net.workspace = true parking_lot.workspace = true postage.workspace = true schemars.workspace = true serde.workspace = true serde_json.workspace = true smol.workspace = true +tempfile.workspace = true url = { workspace = true, features = ["serde"] } util.workspace = true workspace-hack.workspace = true diff --git a/crates/context_server/src/client.rs b/crates/context_server/src/client.rs index 83d815432d..6b24d9b136 100644 --- a/crates/context_server/src/client.rs +++ b/crates/context_server/src/client.rs @@ -70,12 +70,12 @@ fn is_null_value(value: &T) -> bool { } #[derive(Serialize, Deserialize)] -struct Request<'a, T> { - jsonrpc: &'static str, - id: RequestId, - method: &'a str, +pub struct Request<'a, T> { + pub jsonrpc: &'static str, + pub id: RequestId, + pub method: &'a str, #[serde(skip_serializing_if = "is_null_value")] - params: T, + pub params: T, } #[derive(Serialize, Deserialize)] @@ -88,18 +88,18 @@ struct AnyResponse<'a> { result: Option<&'a RawValue>, } -#[derive(Deserialize)] +#[derive(Serialize, Deserialize)] #[allow(dead_code)] -struct Response { - jsonrpc: &'static str, - id: RequestId, +pub(crate) struct Response { + pub jsonrpc: &'static str, + pub id: RequestId, #[serde(flatten)] - value: CspResult, + pub value: CspResult, } -#[derive(Deserialize)] +#[derive(Serialize, Deserialize)] #[serde(rename_all = "snake_case")] -enum CspResult { +pub(crate) enum CspResult { #[serde(rename = "result")] Ok(Option), #[allow(dead_code)] @@ -123,8 +123,9 @@ struct AnyNotification<'a> { } #[derive(Debug, Serialize, Deserialize)] -struct Error { - message: String, +pub(crate) struct Error { + pub message: String, + pub code: i32, } #[derive(Debug, Clone, Deserialize)] diff --git a/crates/context_server/src/context_server.rs b/crates/context_server/src/context_server.rs index 905435fcce..807b17f1ca 100644 --- a/crates/context_server/src/context_server.rs +++ b/crates/context_server/src/context_server.rs @@ -1,4 +1,5 @@ pub mod client; +pub mod listener; pub mod protocol; #[cfg(any(test, feature = "test-support"))] pub mod test; diff --git a/crates/context_server/src/listener.rs b/crates/context_server/src/listener.rs new file mode 100644 index 0000000000..9295ad979c --- /dev/null +++ b/crates/context_server/src/listener.rs @@ -0,0 +1,236 @@ +use ::serde::{Deserialize, Serialize}; +use anyhow::{Context as _, Result}; +use collections::HashMap; +use futures::{ + AsyncBufReadExt, AsyncRead, AsyncWrite, AsyncWriteExt, FutureExt, + channel::mpsc::{UnboundedReceiver, UnboundedSender, unbounded}, + io::BufReader, + select_biased, +}; +use gpui::{App, AppContext, AsyncApp, Task}; +use net::async_net::{UnixListener, UnixStream}; +use serde_json::{json, value::RawValue}; +use smol::stream::StreamExt; +use std::{ + cell::RefCell, + path::{Path, PathBuf}, + rc::Rc, +}; +use util::ResultExt; + +use crate::{ + client::{CspResult, RequestId, Response}, + types::Request, +}; + +pub struct McpServer { + socket_path: PathBuf, + handlers: Rc>>, + _server_task: Task<()>, +} + +type McpHandler = Box>, &App) -> Task>; + +impl McpServer { + pub fn new(cx: &AsyncApp) -> Task> { + let task = cx.background_spawn(async move { + let temp_dir = tempfile::Builder::new().prefix("zed-mcp").tempdir()?; + let socket_path = temp_dir.path().join("mcp.sock"); + let listener = UnixListener::bind(&socket_path).context("creating mcp socket")?; + + anyhow::Ok((temp_dir, socket_path, listener)) + }); + + cx.spawn(async move |cx| { + let (temp_dir, socket_path, listener) = task.await?; + let handlers = Rc::new(RefCell::new(HashMap::default())); + let server_task = cx.spawn({ + let handlers = handlers.clone(); + async move |cx| { + while let Ok((stream, _)) = listener.accept().await { + Self::serve_connection(stream, handlers.clone(), cx); + } + drop(temp_dir) + } + }); + Ok(Self { + socket_path, + _server_task: server_task, + handlers: handlers.clone(), + }) + }) + } + + pub fn handle_request( + &mut self, + f: impl Fn(R::Params, &App) -> Task> + 'static, + ) { + let f = Box::new(f); + self.handlers.borrow_mut().insert( + R::METHOD, + Box::new(move |req_id, opt_params, cx| { + let result = match opt_params { + Some(params) => serde_json::from_str(params.get()), + None => serde_json::from_value(serde_json::Value::Null), + }; + + let params: R::Params = match result { + Ok(params) => params, + Err(e) => { + return Task::ready( + serde_json::to_string(&Response:: { + jsonrpc: "2.0", + id: req_id, + value: CspResult::Error(Some(crate::client::Error { + message: format!("{e}"), + code: -32700, + })), + }) + .unwrap(), + ); + } + }; + let task = f(params, cx); + cx.background_spawn(async move { + match task.await { + Ok(result) => serde_json::to_string(&Response { + jsonrpc: "2.0", + id: req_id, + value: CspResult::Ok(Some(result)), + }) + .unwrap(), + Err(e) => serde_json::to_string(&Response { + jsonrpc: "2.0", + id: req_id, + value: CspResult::Error::(Some(crate::client::Error { + message: format!("{e}"), + code: -32603, + })), + }) + .unwrap(), + } + }) + }), + ); + } + + pub fn socket_path(&self) -> &Path { + &self.socket_path + } + + fn serve_connection( + stream: UnixStream, + handlers: Rc>>, + cx: &mut AsyncApp, + ) { + let (read, write) = smol::io::split(stream); + let (incoming_tx, mut incoming_rx) = unbounded(); + let (outgoing_tx, outgoing_rx) = unbounded(); + + cx.background_spawn(Self::handle_io(outgoing_rx, incoming_tx, write, read)) + .detach(); + + cx.spawn(async move |cx| { + while let Some(request) = incoming_rx.next().await { + let Some(request_id) = request.id.clone() else { + continue; + }; + if let Some(handler) = handlers.borrow().get(&request.method.as_ref()) { + let outgoing_tx = outgoing_tx.clone(); + + if let Some(task) = cx + .update(|cx| handler(request_id, request.params, cx)) + .log_err() + { + cx.spawn(async move |_| { + let response = task.await; + outgoing_tx.unbounded_send(response).ok(); + }) + .detach(); + } + } else { + outgoing_tx + .unbounded_send( + serde_json::to_string(&Response::<()> { + jsonrpc: "2.0", + id: request.id.unwrap(), + value: CspResult::Error(Some(crate::client::Error { + message: format!("unhandled method {}", request.method), + code: -32601, + })), + }) + .unwrap(), + ) + .ok(); + } + } + }) + .detach(); + } + + async fn handle_io( + mut outgoing_rx: UnboundedReceiver, + incoming_tx: UnboundedSender, + mut outgoing_bytes: impl Unpin + AsyncWrite, + incoming_bytes: impl Unpin + AsyncRead, + ) -> Result<()> { + let mut output_reader = BufReader::new(incoming_bytes); + let mut incoming_line = String::new(); + loop { + select_biased! { + message = outgoing_rx.next().fuse() => { + if let Some(message) = message { + log::trace!("send: {}", &message); + outgoing_bytes.write_all(message.as_bytes()).await?; + outgoing_bytes.write_all(&[b'\n']).await?; + } else { + break; + } + } + bytes_read = output_reader.read_line(&mut incoming_line).fuse() => { + if bytes_read? == 0 { + break + } + log::trace!("recv: {}", &incoming_line); + match serde_json::from_str(&incoming_line) { + Ok(message) => { + incoming_tx.unbounded_send(message).log_err(); + } + Err(error) => { + outgoing_bytes.write_all(serde_json::to_string(&json!({ + "jsonrpc": "2.0", + "error": json!({ + "code": -32603, + "message": format!("Failed to parse: {error}"), + }), + }))?.as_bytes()).await?; + outgoing_bytes.write_all(&[b'\n']).await?; + log::error!("failed to parse incoming message: {error}. Raw: {incoming_line}"); + } + } + incoming_line.clear(); + } + } + } + Ok(()) + } +} + +#[derive(Serialize, Deserialize)] +struct RawRequest { + #[serde(skip_serializing_if = "Option::is_none")] + id: Option, + method: String, + #[serde(skip_serializing_if = "Option::is_none")] + params: Option>, +} + +#[derive(Serialize, Deserialize)] +struct RawResponse { + jsonrpc: &'static str, + id: RequestId, + #[serde(skip_serializing_if = "Option::is_none")] + error: Option, + #[serde(skip_serializing_if = "Option::is_none")] + result: Option>, +} diff --git a/crates/context_server/src/types.rs b/crates/context_server/src/types.rs index 8e3daf9e22..4a6fdcabd3 100644 --- a/crates/context_server/src/types.rs +++ b/crates/context_server/src/types.rs @@ -153,7 +153,7 @@ pub struct InitializeParams { pub struct CallToolParams { pub name: String, #[serde(skip_serializing_if = "Option::is_none")] - pub arguments: Option>, + pub arguments: Option, #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")] pub meta: Option>, } diff --git a/crates/icons/src/icons.rs b/crates/icons/src/icons.rs index b29a8b78e6..6834d56215 100644 --- a/crates/icons/src/icons.rs +++ b/crates/icons/src/icons.rs @@ -11,6 +11,7 @@ pub enum IconName { Ai, AiAnthropic, AiBedrock, + AiClaude, AiDeepSeek, AiEdit, AiGemini, diff --git a/crates/nc/Cargo.toml b/crates/nc/Cargo.toml new file mode 100644 index 0000000000..46ef2d3c62 --- /dev/null +++ b/crates/nc/Cargo.toml @@ -0,0 +1,20 @@ +[package] +name = "nc" +version = "0.1.0" +edition.workspace = true +publish.workspace = true +license = "GPL-3.0-or-later" + +[lints] +workspace = true + +[lib] +path = "src/nc.rs" +doctest = false + +[dependencies] +anyhow.workspace = true +futures.workspace = true +net.workspace = true +smol.workspace = true +workspace-hack.workspace = true diff --git a/crates/nc/LICENSE-GPL b/crates/nc/LICENSE-GPL new file mode 120000 index 0000000000..89e542f750 --- /dev/null +++ b/crates/nc/LICENSE-GPL @@ -0,0 +1 @@ +../../LICENSE-GPL \ No newline at end of file diff --git a/crates/nc/src/nc.rs b/crates/nc/src/nc.rs new file mode 100644 index 0000000000..fccb4d726c --- /dev/null +++ b/crates/nc/src/nc.rs @@ -0,0 +1,56 @@ +use anyhow::Result; + +#[cfg(windows)] +pub fn main(_socket: &str) -> Result<()> { + // It looks like we can't get an async stdio stream on Windows from smol. + // + // We decided to merge this with a panic on Windows since this is only used + // by the experimental Claude Code Agent Server. + // + // We're tracking this internally, and we will address it before shipping the integration. + panic!("--nc isn't yet supported on Windows"); +} + +/// The main function for when Zed is running in netcat mode +#[cfg(not(windows))] +pub fn main(socket: &str) -> Result<()> { + use futures::{AsyncReadExt as _, AsyncWriteExt as _, FutureExt as _, io::BufReader, select}; + use net::async_net::UnixStream; + use smol::{Async, io::AsyncBufReadExt}; + + smol::block_on(async { + let socket_stream = UnixStream::connect(socket).await?; + let (socket_read, mut socket_write) = socket_stream.split(); + let mut socket_reader = BufReader::new(socket_read); + + let mut stdout = Async::new(std::io::stdout())?; + let stdin = Async::new(std::io::stdin())?; + let mut stdin_reader = BufReader::new(stdin); + + let mut socket_line = Vec::new(); + let mut stdin_line = Vec::new(); + + loop { + select! { + bytes_read = socket_reader.read_until(b'\n', &mut socket_line).fuse() => { + if bytes_read? == 0 { + break + } + stdout.write_all(&socket_line).await?; + stdout.flush().await?; + socket_line.clear(); + } + bytes_read = stdin_reader.read_until(b'\n', &mut stdin_line).fuse() => { + if bytes_read? == 0 { + break + } + socket_write.write_all(&stdin_line).await?; + socket_write.flush().await?; + stdin_line.clear(); + } + } + } + + anyhow::Ok(()) + }) +} diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml index ae96a48b53..bbceb3f101 100644 --- a/crates/zed/Cargo.toml +++ b/crates/zed/Cargo.toml @@ -95,6 +95,7 @@ svg_preview.workspace = true menu.workspace = true migrator.workspace = true mimalloc = { version = "0.1", optional = true } +nc.workspace = true nix = { workspace = true, features = ["pthread", "signal"] } node_runtime.workspace = true notifications.workspace = true diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs index 5eb96f21a4..89b9fad6bf 100644 --- a/crates/zed/src/main.rs +++ b/crates/zed/src/main.rs @@ -175,6 +175,17 @@ pub fn main() { return; } + // `zed --nc` Makes zed operate in nc/netcat mode for use with MCP + if let Some(socket) = &args.nc { + match nc::main(socket) { + Ok(()) => return, + Err(err) => { + eprintln!("Error: {}", err); + process::exit(1); + } + } + } + // `zed --printenv` Outputs environment variables as JSON to stdout if args.printenv { util::shell_env::print_env(); @@ -1168,6 +1179,11 @@ struct Args { #[arg(long, hide = true)] askpass: Option, + /// Used for the MCP Server, to remove the need for netcat as a dependency, + /// by having Zed act like netcat communicating over a Unix socket. + #[arg(long, hide = true)] + nc: Option, + /// Run zed in the foreground, only used on Windows, to match the behavior on macOS. #[arg(long)] #[cfg(target_os = "windows")] From b0eac4267d3f0d69657593dd04fa970e1128b00f Mon Sep 17 00:00:00 2001 From: Ben Brandt Date: Thu, 17 Jul 2025 17:01:02 +0200 Subject: [PATCH 0022/1052] Mark glob/grep as code blocks (#34628) Release Notes: - N/A --- crates/agent_servers/src/claude/tools.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/agent_servers/src/claude/tools.rs b/crates/agent_servers/src/claude/tools.rs index 89d42c0daa..e3ac6c14e2 100644 --- a/crates/agent_servers/src/claude/tools.rs +++ b/crates/agent_servers/src/claude/tools.rs @@ -97,10 +97,10 @@ impl ClaudeTool { } Self::Write(None) => "Write".into(), Self::Glob(Some(params)) => { - format!("Glob {params}") + format!("Glob `{params}`") } Self::Glob(None) => "Glob".into(), - Self::Grep(Some(params)) => params.to_string(), + Self::Grep(Some(params)) => format!("`{params}`"), Self::Grep(None) => "Grep".into(), Self::WebFetch(Some(params)) => format!("Fetch {}", params.url), Self::WebFetch(None) => "Fetch".into(), From 948c1f22bb67152306b137dd8c4b31c5bbad076b Mon Sep 17 00:00:00 2001 From: Ben Kunkle Date: Thu, 17 Jul 2025 10:10:07 -0500 Subject: [PATCH 0023/1052] keymap_ui: Improve keybind display in menus (#34587) Closes #ISSUE Defines keybindings for `keymap_editor::EditBinding` and `keymap_editor::CreateBinding`, making sure those actions are used in tooltips. Release Notes: - N/A *or* Added/Fixed/Improved ... --------- Co-authored-by: Finn --- assets/keymaps/default-linux.json | 4 +- assets/keymaps/default-macos.json | 4 +- crates/settings_ui/src/keybindings.rs | 118 +++++++++++++---------- crates/ui/src/components/context_menu.rs | 6 +- 4 files changed, 75 insertions(+), 57 deletions(-) diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index b52b6c614d..ebc88ec135 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -1118,7 +1118,9 @@ "ctrl-f": "search::FocusSearch", "alt-find": "keymap_editor::ToggleKeystrokeSearch", "alt-ctrl-f": "keymap_editor::ToggleKeystrokeSearch", - "alt-c": "keymap_editor::ToggleConflictFilter" + "alt-c": "keymap_editor::ToggleConflictFilter", + "enter": "keymap_editor::EditBinding", + "alt-enter": "keymap_editor::CreateBinding" } }, { diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index 240b42fd1f..cec485ce88 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -1217,7 +1217,9 @@ "use_key_equivalents": true, "bindings": { "cmd-alt-f": "keymap_editor::ToggleKeystrokeSearch", - "cmd-alt-c": "keymap_editor::ToggleConflictFilter" + "cmd-alt-c": "keymap_editor::ToggleConflictFilter", + "enter": "keymap_editor::EditBinding", + "alt-enter": "keymap_editor::CreateBinding" } }, { diff --git a/crates/settings_ui/src/keybindings.rs b/crates/settings_ui/src/keybindings.rs index 21eec538b3..6b438ede02 100644 --- a/crates/settings_ui/src/keybindings.rs +++ b/crates/settings_ui/src/keybindings.rs @@ -683,7 +683,7 @@ impl KeymapEditor { .detach_and_log_err(cx); } - fn dispatch_context(&self, _window: &Window, _cx: &Context) -> KeyContext { + fn key_context(&self) -> KeyContext { let mut dispatch_context = KeyContext::new_with_defaults(); dispatch_context.add("KeymapEditor"); dispatch_context.add("menu"); @@ -718,14 +718,19 @@ impl KeymapEditor { self.selected_index.take(); } - fn selected_keybind_idx(&self) -> Option { + fn selected_keybind_index(&self) -> Option { self.selected_index .and_then(|match_index| self.matches.get(match_index)) .map(|r#match| r#match.candidate_id) } + fn selected_keybind_and_index(&self) -> Option<(&ProcessedKeybinding, usize)> { + self.selected_keybind_index() + .map(|keybind_index| (&self.keybindings[keybind_index], keybind_index)) + } + fn selected_binding(&self) -> Option<&ProcessedKeybinding> { - self.selected_keybind_idx() + self.selected_keybind_index() .and_then(|keybind_index| self.keybindings.get(keybind_index)) } @@ -757,40 +762,41 @@ impl KeymapEditor { let selected_binding_is_unbound = selected_binding.keystrokes().is_none(); let context_menu = ContextMenu::build(window, cx, |menu, _window, _cx| { - menu.action_disabled_when( - selected_binding_is_unbound, - "Edit", - Box::new(EditBinding), - ) - .action("Create", Box::new(CreateBinding)) - .action_disabled_when( - selected_binding_is_unbound, - "Delete", - Box::new(DeleteBinding), - ) - .separator() - .action("Copy Action", Box::new(CopyAction)) - .action_disabled_when( - selected_binding_has_no_context, - "Copy Context", - Box::new(CopyContext), - ) - .entry("Show matching keybindings", None, { - let weak = weak.clone(); - let key_strokes = key_strokes.clone(); + menu.context(self.focus_handle.clone()) + .action_disabled_when( + selected_binding_is_unbound, + "Edit", + Box::new(EditBinding), + ) + .action("Create", Box::new(CreateBinding)) + .action_disabled_when( + selected_binding_is_unbound, + "Delete", + Box::new(DeleteBinding), + ) + .separator() + .action("Copy Action", Box::new(CopyAction)) + .action_disabled_when( + selected_binding_has_no_context, + "Copy Context", + Box::new(CopyContext), + ) + .entry("Show matching keybindings", None, { + let weak = weak.clone(); + let key_strokes = key_strokes.clone(); - move |_, cx| { - weak.update(cx, |this, cx| { - this.filter_state = FilterState::All; - this.search_mode = SearchMode::KeyStroke { exact_match: true }; + move |_, cx| { + weak.update(cx, |this, cx| { + this.filter_state = FilterState::All; + this.search_mode = SearchMode::KeyStroke { exact_match: true }; - this.keystroke_editor.update(cx, |editor, cx| { - editor.set_keystrokes(key_strokes.clone(), cx); - }); - }) - .ok(); - } - }) + this.keystroke_editor.update(cx, |editor, cx| { + editor.set_keystrokes(key_strokes.clone(), cx); + }); + }) + .ok(); + } + }) }); let context_menu_handle = context_menu.focus_handle(cx); @@ -880,22 +886,16 @@ impl KeymapEditor { } } - fn confirm(&mut self, _: &menu::Confirm, window: &mut Window, cx: &mut Context) { - self.open_edit_keybinding_modal(false, window, cx); - } - fn open_edit_keybinding_modal( &mut self, create: bool, window: &mut Window, cx: &mut Context, ) { - let Some((keybind_idx, keybind)) = self - .selected_keybind_idx() - .zip(self.selected_binding().cloned()) - else { + let Some((keybind, keybind_index)) = self.selected_keybind_and_index() else { return; }; + let keybind = keybind.clone(); let keymap_editor = cx.entity(); let arguments = keybind @@ -925,7 +925,7 @@ impl KeymapEditor { let modal = KeybindingEditorModal::new( create, keybind, - keybind_idx, + keybind_index, keymap_editor, workspace_weak, fs, @@ -1142,20 +1142,19 @@ impl Item for KeymapEditor { } impl Render for KeymapEditor { - fn render(&mut self, window: &mut Window, cx: &mut ui::Context) -> impl ui::IntoElement { + fn render(&mut self, _window: &mut Window, cx: &mut ui::Context) -> impl ui::IntoElement { let row_count = self.matches.len(); let theme = cx.theme(); v_flex() .id("keymap-editor") .track_focus(&self.focus_handle) - .key_context(self.dispatch_context(window, cx)) + .key_context(self.key_context()) .on_action(cx.listener(Self::select_next)) .on_action(cx.listener(Self::select_previous)) .on_action(cx.listener(Self::select_first)) .on_action(cx.listener(Self::select_last)) .on_action(cx.listener(Self::focus_search)) - .on_action(cx.listener(Self::confirm)) .on_action(cx.listener(Self::edit_binding)) .on_action(cx.listener(Self::create_binding)) .on_action(cx.listener(Self::delete_binding)) @@ -1269,6 +1268,18 @@ impl Render for KeymapEditor { "keystrokes-exact-match", IconName::Equal, ) + .tooltip(move |window, cx| { + Tooltip::for_action( + if exact_match { + "Partial match mode" + } else { + "Exact match mode" + }, + &ToggleExactKeystrokeMatching, + window, + cx, + ) + }) .shape(IconButtonShape::Square) .toggle_state(exact_match) .on_click( @@ -1316,9 +1327,9 @@ impl Render for KeymapEditor { .icon_color(Color::Warning) .tooltip(|window, cx| { Tooltip::with_meta( - "Edit Keybinding", - None, - "Use alt+click to show conflicts", + "View conflicts", + Some(&ToggleConflictFilter), + "Use alt+click to show all conflicts", window, cx, ) @@ -1343,7 +1354,10 @@ impl Render for KeymapEditor { .unwrap_or_else(|| { base_button_style(index, IconName::Pencil) .visible_on_hover(row_group_id(index)) - .tooltip(Tooltip::text("Edit Keybinding")) + .tooltip(Tooltip::for_action_title( + "Edit Keybinding", + &EditBinding, + )) .on_click(cx.listener(move |this, _, window, cx| { this.select_index(index, cx); this.open_edit_keybinding_modal(false, window, cx); @@ -2545,6 +2559,8 @@ impl KeystrokeInput { if self.keystrokes.len() < Self::KEYSTROKE_COUNT_MAX { self.keystrokes.push(Self::dummy(keystroke.modifiers)); } + } else if close_keystroke_result != CloseKeystrokeResult::Partial { + self.clear_keystrokes(&ClearKeystrokes, window, cx); } } self.keystrokes_changed(cx); diff --git a/crates/ui/src/components/context_menu.rs b/crates/ui/src/components/context_menu.rs index 3ba73f6dff..467dd226fb 100644 --- a/crates/ui/src/components/context_menu.rs +++ b/crates/ui/src/components/context_menu.rs @@ -972,12 +972,10 @@ impl ContextMenu { .children(action.as_ref().and_then(|action| { self.action_context .as_ref() - .map(|focus| { + .and_then(|focus| { KeyBinding::for_action_in(&**action, focus, window, cx) }) - .unwrap_or_else(|| { - KeyBinding::for_action(&**action, window, cx) - }) + .or_else(|| KeyBinding::for_action(&**action, window, cx)) .map(|binding| { div().ml_4().child(binding.disabled(*disabled)).when( *disabled && documentation_aside.is_some(), From b94649ce1eca2a524852eeda0d955468158f54f2 Mon Sep 17 00:00:00 2001 From: Ben Kunkle Date: Thu, 17 Jul 2025 10:34:34 -0500 Subject: [PATCH 0024/1052] keymap_ui: Show edit icon on hovered and selected row (#34630) Closes #ISSUE Improves the behavior of the edit icon in the far left column of the keymap UI table. It is now shown in both the selected and the hovered row as an indicator that the row is editable in this configuration. When hovered a row can be double clicked or the edit icon can be clicked, and when selected it can be edited via keyboard shortcuts. Additionally, the edit icon and all other hover tooltips will now disappear when the table is navigated via keyboard shortcuts.
Video https://github.com/user-attachments/assets/6584810f-4c6d-4e6f-bdca-25b16c920cfc
Release Notes: - N/A *or* Added/Fixed/Improved ... --- crates/settings_ui/src/keybindings.rs | 98 ++++++++++++++++++--------- 1 file changed, 65 insertions(+), 33 deletions(-) diff --git a/crates/settings_ui/src/keybindings.rs b/crates/settings_ui/src/keybindings.rs index 6b438ede02..af096f4ce1 100644 --- a/crates/settings_ui/src/keybindings.rs +++ b/crates/settings_ui/src/keybindings.rs @@ -268,6 +268,7 @@ struct KeymapEditor { context_menu: Option<(Entity, Point, Subscription)>, previous_edit: Option, humanized_action_names: HashMap<&'static str, SharedString>, + show_hover_menus: bool, } enum PreviousEdit { @@ -357,6 +358,7 @@ impl KeymapEditor { previous_edit: None, humanized_action_names, search_query_debounce: None, + show_hover_menus: true, }; this.on_keymap_changed(cx); @@ -825,6 +827,7 @@ impl KeymapEditor { } fn select_next(&mut self, _: &menu::SelectNext, window: &mut Window, cx: &mut Context) { + self.show_hover_menus = false; if let Some(selected) = self.selected_index { let selected = selected + 1; if selected >= self.matches.len() { @@ -845,6 +848,7 @@ impl KeymapEditor { window: &mut Window, cx: &mut Context, ) { + self.show_hover_menus = false; if let Some(selected) = self.selected_index { if selected == 0 { return; @@ -870,6 +874,7 @@ impl KeymapEditor { _window: &mut Window, cx: &mut Context, ) { + self.show_hover_menus = false; if self.matches.get(0).is_some() { self.selected_index = Some(0); self.scroll_to_item(0, ScrollStrategy::Center, cx); @@ -878,6 +883,7 @@ impl KeymapEditor { } fn select_last(&mut self, _: &menu::SelectLast, _window: &mut Window, cx: &mut Context) { + self.show_hover_menus = false; if self.matches.last().is_some() { let index = self.matches.len() - 1; self.selected_index = Some(index); @@ -892,6 +898,7 @@ impl KeymapEditor { window: &mut Window, cx: &mut Context, ) { + self.show_hover_menus = false; let Some((keybind, keybind_index)) = self.selected_keybind_and_index() else { return; }; @@ -1167,6 +1174,9 @@ impl Render for KeymapEditor { .p_2() .gap_1() .bg(theme.colors().editor_background) + .on_mouse_move(cx.listener(|this, _, _window, _cx| { + this.show_hover_menus = true; + })) .child( v_flex() .p_2() @@ -1320,9 +1330,9 @@ impl Render for KeymapEditor { let binding = &this.keybindings[candidate_id]; let action_name = binding.action_name; - let icon = (this.filter_state != FilterState::Conflicts - && this.has_conflict(index)) - .then(|| { + let icon = if this.filter_state != FilterState::Conflicts + && this.has_conflict(index) + { base_button_style(index, IconName::Warning) .icon_color(Color::Warning) .tooltip(|window, cx| { @@ -1350,21 +1360,34 @@ impl Render for KeymapEditor { } }, )) - }) - .unwrap_or_else(|| { + .into_any_element() + } else { base_button_style(index, IconName::Pencil) - .visible_on_hover(row_group_id(index)) - .tooltip(Tooltip::for_action_title( - "Edit Keybinding", - &EditBinding, - )) + .visible_on_hover( + if this.selected_index == Some(index) { + "".into() + } else if this.show_hover_menus { + row_group_id(index) + } else { + "never-show".into() + }, + ) + .when( + this.show_hover_menus && !context_menu_deployed, + |this| { + this.tooltip(Tooltip::for_action_title( + "Edit Keybinding", + &EditBinding, + )) + }, + ) .on_click(cx.listener(move |this, _, window, cx| { this.select_index(index, cx); this.open_edit_keybinding_modal(false, window, cx); cx.stop_propagation(); })) - }) - .into_any_element(); + .into_any_element() + }; let action = div() .id(("keymap action", index)) @@ -1382,20 +1405,24 @@ impl Render for KeymapEditor { .into_any_element() } }) - .when(!context_menu_deployed, |this| { - this.tooltip({ - let action_name = binding.action_name; - let action_docs = binding.action_docs; - move |_, cx| { - let action_tooltip = Tooltip::new(action_name); - let action_tooltip = match action_docs { - Some(docs) => action_tooltip.meta(docs), - None => action_tooltip, - }; - cx.new(|_| action_tooltip).into() - } - }) - }) + .when( + !context_menu_deployed && this.show_hover_menus, + |this| { + this.tooltip({ + let action_name = binding.action_name; + let action_docs = binding.action_docs; + move |_, cx| { + let action_tooltip = + Tooltip::new(action_name); + let action_tooltip = match action_docs { + Some(docs) => action_tooltip.meta(docs), + None => action_tooltip, + }; + cx.new(|_| action_tooltip).into() + } + }) + }, + ) .into_any_element(); let keystrokes = binding.ui_key_binding.clone().map_or( binding.keystroke_text.clone().into_any_element(), @@ -1420,13 +1447,18 @@ impl Render for KeymapEditor { div() .id(("keymap context", index)) .child(context.clone()) - .when(is_local && !context_menu_deployed, |this| { - this.tooltip(Tooltip::element({ - move |_, _| { - context.clone().into_any_element() - } - })) - }) + .when( + is_local + && !context_menu_deployed + && this.show_hover_menus, + |this| { + this.tooltip(Tooltip::element({ + move |_, _| { + context.clone().into_any_element() + } + })) + }, + ) .into_any_element() }, ); From b4dc7f8a8aadd0a2f12650a0d393f7f9ae3ed29a Mon Sep 17 00:00:00 2001 From: Umesh Yadav <23421535+imumesh18@users.noreply.github.com> Date: Thu, 17 Jul 2025 21:14:40 +0530 Subject: [PATCH 0025/1052] debugger: Add support for running test methods with function receiver in Go (#34613) ![CleanShot 2025-07-17 at 16 35 10](https://github.com/user-attachments/assets/bad794fb-198e-40a1-958c-6ff30a0a4e53) Closes #33759 Release Notes: - debugger: Add support for running test methods with function receiver in Go Signed-off-by: Umesh Yadav --- crates/languages/src/go/runnables.scm | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/crates/languages/src/go/runnables.scm b/crates/languages/src/go/runnables.scm index 8d5f4375c1..bdeb77b46c 100644 --- a/crates/languages/src/go/runnables.scm +++ b/crates/languages/src/go/runnables.scm @@ -1,9 +1,21 @@ ; Functions names start with `Test` ( - ( + [ (function_declaration name: (_) @run (#match? @run "^Test.*")) - ) @_ + (method_declaration + receiver: (parameter_list + (parameter_declaration + name: (identifier) @_receiver_name + type: [ + (pointer_type (type_identifier) @_receiver_type) + (type_identifier) @_receiver_type + ] + ) + ) + name: (field_identifier) @run @_method_name + (#match? @_method_name "^Test.*")) + ] @_ (#set! tag go-test) ) From 8980526a859cc7ee3d9b120a6df6f966c8fef165 Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Thu, 17 Jul 2025 17:58:54 +0200 Subject: [PATCH 0026/1052] chore: Bump lsp-types rev (#34345) Closes #ISSUE Release Notes: - N/A --- Cargo.lock | 2 +- Cargo.toml | 2 +- crates/lsp/src/lsp.rs | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 540e3039ef..ea7bfa0a38 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -9704,7 +9704,7 @@ dependencies = [ [[package]] name = "lsp-types" version = "0.95.1" -source = "git+https://github.com/zed-industries/lsp-types?rev=6add7052b598ea1f40f7e8913622c3958b009b60#6add7052b598ea1f40f7e8913622c3958b009b60" +source = "git+https://github.com/zed-industries/lsp-types?rev=39f629bdd03d59abd786ed9fc27e8bca02c0c0ec#39f629bdd03d59abd786ed9fc27e8bca02c0c0ec" dependencies = [ "bitflags 1.3.2", "serde", diff --git a/Cargo.toml b/Cargo.toml index 1c79f4c1c8..1be2eb8d77 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -496,7 +496,7 @@ libc = "0.2" libsqlite3-sys = { version = "0.30.1", features = ["bundled"] } linkify = "0.10.0" log = { version = "0.4.16", features = ["kv_unstable_serde", "serde"] } -lsp-types = { git = "https://github.com/zed-industries/lsp-types", rev = "6add7052b598ea1f40f7e8913622c3958b009b60" } +lsp-types = { git = "https://github.com/zed-industries/lsp-types", rev = "39f629bdd03d59abd786ed9fc27e8bca02c0c0ec" } markup5ever_rcdom = "0.3.0" metal = "0.29" moka = { version = "0.12.10", features = ["sync"] } diff --git a/crates/lsp/src/lsp.rs b/crates/lsp/src/lsp.rs index 4248f910ee..7dcfa61f47 100644 --- a/crates/lsp/src/lsp.rs +++ b/crates/lsp/src/lsp.rs @@ -633,7 +633,7 @@ impl LanguageServer { inlay_hint: Some(InlayHintWorkspaceClientCapabilities { refresh_support: Some(true), }), - diagnostic: Some(DiagnosticWorkspaceClientCapabilities { + diagnostics: Some(DiagnosticWorkspaceClientCapabilities { refresh_support: Some(true), }) .filter(|_| pull_diagnostics), From ae0d4f6a0d58397355896fde3b01b0e3d6a50fd3 Mon Sep 17 00:00:00 2001 From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com> Date: Thu, 17 Jul 2025 13:05:58 -0400 Subject: [PATCH 0027/1052] debugger: Add data breakpoint access type support (#34639) Release Notes: - Support specifying a data breakpoint's access type - Read, Write, Read & Write --- Cargo.lock | 1 + crates/debugger_ui/Cargo.toml | 13 ++-- crates/debugger_ui/src/debugger_ui.rs | 20 +++++- .../src/session/running/memory_view.rs | 2 +- .../src/session/running/variable_list.rs | 61 ++++++++++++++++--- 5 files changed, 77 insertions(+), 20 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index ea7bfa0a38..a8a8d12e37 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4427,6 +4427,7 @@ dependencies = [ "pretty_assertions", "project", "rpc", + "schemars", "serde", "serde_json", "serde_json_lenient", diff --git a/crates/debugger_ui/Cargo.toml b/crates/debugger_ui/Cargo.toml index ebb135c1d9..df4125860f 100644 --- a/crates/debugger_ui/Cargo.toml +++ b/crates/debugger_ui/Cargo.toml @@ -35,6 +35,7 @@ command_palette_hooks.workspace = true dap.workspace = true dap_adapters = { workspace = true, optional = true } db.workspace = true +debugger_tools.workspace = true editor.workspace = true file_icons.workspace = true futures.workspace = true @@ -54,6 +55,7 @@ picker.workspace = true pretty_assertions.workspace = true project.workspace = true rpc.workspace = true +schemars.workspace = true serde.workspace = true serde_json.workspace = true serde_json_lenient.workspace = true @@ -66,14 +68,13 @@ telemetry.workspace = true terminal_view.workspace = true text.workspace = true theme.workspace = true -tree-sitter.workspace = true tree-sitter-json.workspace = true +tree-sitter.workspace = true ui.workspace = true -util.workspace = true -workspace.workspace = true -workspace-hack.workspace = true -debugger_tools.workspace = true unindent = { workspace = true, optional = true } +util.workspace = true +workspace-hack.workspace = true +workspace.workspace = true zed_actions.workspace = true [dev-dependencies] @@ -83,8 +84,8 @@ debugger_tools = { workspace = true, features = ["test-support"] } editor = { workspace = true, features = ["test-support"] } gpui = { workspace = true, features = ["test-support"] } project = { workspace = true, features = ["test-support"] } +tree-sitter-go.workspace = true unindent.workspace = true util = { workspace = true, features = ["test-support"] } workspace = { workspace = true, features = ["test-support"] } zlog.workspace = true -tree-sitter-go.workspace = true diff --git a/crates/debugger_ui/src/debugger_ui.rs b/crates/debugger_ui/src/debugger_ui.rs index c932f1b600..9eac59af83 100644 --- a/crates/debugger_ui/src/debugger_ui.rs +++ b/crates/debugger_ui/src/debugger_ui.rs @@ -3,10 +3,12 @@ use std::any::TypeId; use dap::debugger_settings::DebuggerSettings; use debugger_panel::DebugPanel; use editor::Editor; -use gpui::{App, DispatchPhase, EntityInputHandler, actions}; +use gpui::{Action, App, DispatchPhase, EntityInputHandler, actions}; use new_process_modal::{NewProcessModal, NewProcessMode}; use onboarding_modal::DebuggerOnboardingModal; use project::debugger::{self, breakpoint_store::SourceBreakpoint, session::ThreadStatus}; +use schemars::JsonSchema; +use serde::Deserialize; use session::DebugSession; use settings::Settings; use stack_trace_view::StackTraceView; @@ -83,11 +85,23 @@ actions!( Rerun, /// Toggles expansion of the selected item in the debugger UI. ToggleExpandItem, - /// Set a data breakpoint on the selected variable or memory region. - ToggleDataBreakpoint, ] ); +/// Extends selection down by a specified number of lines. +#[derive(PartialEq, Clone, Deserialize, Default, JsonSchema, Action)] +#[action(namespace = debugger)] +#[serde(deny_unknown_fields)] +/// Set a data breakpoint on the selected variable or memory region. +pub struct ToggleDataBreakpoint { + /// The type of data breakpoint + /// Read & Write + /// Read + /// Write + #[serde(default)] + pub access_type: Option, +} + actions!( dev, [ diff --git a/crates/debugger_ui/src/session/running/memory_view.rs b/crates/debugger_ui/src/session/running/memory_view.rs index 499091ca0f..7b62a1d55d 100644 --- a/crates/debugger_ui/src/session/running/memory_view.rs +++ b/crates/debugger_ui/src/session/running/memory_view.rs @@ -688,7 +688,7 @@ impl MemoryView { menu = menu.action_disabled_when( *memory_unreadable, "Set Data Breakpoint", - ToggleDataBreakpoint.boxed_clone(), + ToggleDataBreakpoint { access_type: None }.boxed_clone(), ); } menu.context(self.focus_handle.clone()) diff --git a/crates/debugger_ui/src/session/running/variable_list.rs b/crates/debugger_ui/src/session/running/variable_list.rs index b158314b50..906e482687 100644 --- a/crates/debugger_ui/src/session/running/variable_list.rs +++ b/crates/debugger_ui/src/session/running/variable_list.rs @@ -670,9 +670,9 @@ impl VariableList { let focus_handle = self.focus_handle.clone(); cx.spawn_in(window, async move |this, cx| { let can_toggle_data_breakpoint = if let Some(task) = can_toggle_data_breakpoint { - task.await.is_some() + task.await } else { - true + None }; cx.update(|window, cx| { let context_menu = ContextMenu::build(window, cx, |menu, _, _| { @@ -686,11 +686,35 @@ impl VariableList { menu.action("Go To Memory", GoToMemory.boxed_clone()) }) .action("Watch Variable", AddWatch.boxed_clone()) - .when(can_toggle_data_breakpoint, |menu| { - menu.action( - "Toggle Data Breakpoint", - crate::ToggleDataBreakpoint.boxed_clone(), - ) + .when_some(can_toggle_data_breakpoint, |mut menu, data_info| { + menu = menu.separator(); + if let Some(access_types) = data_info.access_types { + for access in access_types { + menu = menu.action( + format!( + "Toggle {} Data Breakpoint", + match access { + dap::DataBreakpointAccessType::Read => "Read", + dap::DataBreakpointAccessType::Write => "Write", + dap::DataBreakpointAccessType::ReadWrite => + "Read/Write", + } + ), + crate::ToggleDataBreakpoint { + access_type: Some(access), + } + .boxed_clone(), + ); + } + + menu + } else { + menu.action( + "Toggle Data Breakpoint", + crate::ToggleDataBreakpoint { access_type: None } + .boxed_clone(), + ) + } }) }) .when(entry.as_watcher().is_some(), |menu| { @@ -729,7 +753,7 @@ impl VariableList { fn toggle_data_breakpoint( &mut self, - _: &crate::ToggleDataBreakpoint, + data_info: &crate::ToggleDataBreakpoint, _window: &mut Window, cx: &mut Context, ) { @@ -759,17 +783,34 @@ impl VariableList { }); let session = self.session.downgrade(); + let access_type = data_info.access_type; cx.spawn(async move |_, cx| { - let Some(data_id) = data_breakpoint.await.and_then(|info| info.data_id) else { + let Some((data_id, access_types)) = data_breakpoint + .await + .and_then(|info| Some((info.data_id?, info.access_types))) + else { return; }; + + // Because user's can manually add this action to the keymap + // we check if access type is supported + let access_type = match access_types { + None => None, + Some(access_types) => { + if access_type.is_some_and(|access_type| access_types.contains(&access_type)) { + access_type + } else { + None + } + } + }; _ = session.update(cx, |session, cx| { session.create_data_breakpoint( context, data_id.clone(), dap::DataBreakpoint { data_id, - access_type: None, + access_type, condition: None, hit_condition: None, }, From 1ceda2babd71a07049dfce85dc64efe779bb5935 Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Thu, 17 Jul 2025 13:14:24 -0400 Subject: [PATCH 0028/1052] JetBrains keymap improvements (July 2025) (#34641) Closes: https://github.com/zed-industries/zed/issues/14639 Closes: https://github.com/zed-industries/zed/issues/33020 If would have ideas for future enhancements, please see: - https://github.com/zed-industries/zed/discussions/34643 Various Jetbrains keymaps improvements for macOS and Linux/Windows: | Area | Action | macOS | Linux | | ------------- | -------------------------- | --------------------------------- | --------------------------------- | | Workspace | Toggle Git Panel | `cmd-0` | `ctrl-0` | | Workspace | Toggle Project Panel | `cmd-1` | `alt-0` | | Workspace | Toggle Debug Panel | `cmd-5` | `alt-1` | | Workspace | Toggle Diagnostics | `cmd-6` | `alt-6` | | Workspace | Toggle Outline Panel | `cmd-7` | `alt-7` | | Workspace | Toggle Terminal Panel | `alt-f12` | `alt-f12` | | Workspace | File Finder | `cmd-e` | `ctrl-e` | | Workspace | Task Spawn | `ctrl-alt-r` | `alt-shift-f10` | | Workspace | Close All Docks | `ctrl-shift-f12` | `ctrl-shift-f12` | | Project Panel | Search in Directory | `cmd-shift-f` | `ctrl-shift-f` | | Search | Replace in Files | `cmd-shift-r` | `ctrl-shift-r` | | Search | Replace in Buffer | `cmd-r` | `ctrl-r` | | Search | Toggle Case Sensitive | `ctrl-alt-c` / `alt-c` | `ctrl-alt-c` | | Search | Toggle Search in Selection | `ctrl-alt-s` / `alt-s` | `ctrl-alt-s` | | Search | Toggle Regex | `ctrl-alt-x` / `alt-x` | `ctrl-alt-x` | | Search | Toggle Whole Word | `ctrl-alt-w` / `alt-w` | `ctrl-alt-w` | | Terminal | New Terminal Tab | `cmd-t` | `ctrl-shift-t` | | Terminal | Scroll Line | `cmd-up` / `cmd-down` | `ctrl-up` / `ctrl-down` | | Terminal | Scroll Page | `shift-pageup` / `shift-pagedown` | `shift-pageup` / `shift-pagedown` | | Git | Git Panel | `cmd-k` | `ctrl-k` | | Git | Git Push | `cmd-shift-k` | `ctrl-shift-k` | In addition, with the help of the recently merged https://github.com/zed-industries/zed/pull/34495, no matter where you are mashing `escape` will refocus you back to your most recent editor buffer similar to the behavior of JetBrains. Release Notes: - jetbrains: Added 25+ keybinds to the macOS and Linux/Windows JetBrains compatibility keymaps --- assets/keymaps/linux/jetbrains.json | 53 +++++++++++++++++++++++++++-- assets/keymaps/macos/jetbrains.json | 53 ++++++++++++++++++++++++++--- 2 files changed, 98 insertions(+), 8 deletions(-) diff --git a/assets/keymaps/linux/jetbrains.json b/assets/keymaps/linux/jetbrains.json index dbf50b0fce..7266318a9e 100644 --- a/assets/keymaps/linux/jetbrains.json +++ b/assets/keymaps/linux/jetbrains.json @@ -66,22 +66,46 @@ "context": "Editor && mode == full", "bindings": { "ctrl-f12": "outline::Toggle", - "alt-7": "outline::Toggle", + "ctrl-r": ["buffer_search::Deploy", { "replace_enabled": true }], "ctrl-shift-n": "file_finder::Toggle", "ctrl-g": "go_to_line::Toggle", "alt-enter": "editor::ToggleCodeActions" } }, + { + "context": "BufferSearchBar || ProjectSearchBar", + "bindings": { + "shift-enter": "search::SelectPreviousMatch", + "ctrl-alt-c": "search::ToggleCaseSensitive", + "ctrl-alt-e": "search::ToggleSelection", + "ctrl-alt-w": "search::ToggleWholeWord", + "ctrl-alt-x": "search::ToggleRegex" + } + }, { "context": "Workspace", "bindings": { + "ctrl-shift-f12": "workspace::CloseAllDocks", + "ctrl-shift-r": ["pane::DeploySearch", { "replace_enabled": true }], + "alt-shift-f10": "task::Spawn", + "ctrl-e": "file_finder::Toggle", + "ctrl-k": "git_panel::ToggleFocus", // bug: This should also focus commit editor "ctrl-shift-n": "file_finder::Toggle", "ctrl-shift-a": "command_palette::Toggle", "shift shift": "command_palette::Toggle", "ctrl-alt-shift-n": "project_symbols::Toggle", + "alt-0": "git_panel::ToggleFocus", "alt-1": "workspace::ToggleLeftDock", - "ctrl-e": "tab_switcher::Toggle", - "alt-6": "diagnostics::Deploy" + "alt-5": "debug_panel::ToggleFocus", + "alt-6": "diagnostics::Deploy", + "alt-7": "outline_panel::ToggleFocus" + } + }, + { + "context": "Workspace || Editor", + "bindings": { + "alt-f12": "terminal_panel::ToggleFocus", + "ctrl-shift-k": "git::Push" } }, { @@ -95,10 +119,33 @@ "context": "ProjectPanel", "bindings": { "enter": "project_panel::Open", + "ctrl-shift-f": "project_panel::NewSearchInDirectory", "backspace": ["project_panel::Trash", { "skip_prompt": false }], "delete": ["project_panel::Trash", { "skip_prompt": false }], "shift-delete": ["project_panel::Delete", { "skip_prompt": false }], "shift-f6": "project_panel::Rename" } + }, + { + "context": "Terminal", + "bindings": { + "ctrl-shift-t": "workspace::NewTerminal", + "alt-f12": "workspace::CloseActiveDock", + "alt-left": "pane::ActivatePreviousItem", + "alt-right": "pane::ActivateNextItem", + "ctrl-up": "terminal::ScrollLineUp", + "ctrl-down": "terminal::ScrollLineDown", + "shift-pageup": "terminal::ScrollPageUp", + "shift-pagedown": "terminal::ScrollPageDown" + } + }, + { "context": "GitPanel", "bindings": { "alt-0": "workspace::CloseActiveDock" } }, + { "context": "ProjectPanel", "bindings": { "alt-1": "workspace::CloseActiveDock" } }, + { "context": "DebugPanel", "bindings": { "alt-5": "workspace::CloseActiveDock" } }, + { "context": "Diagnostics > Editor", "bindings": { "alt-6": "pane::CloseActiveItem" } }, + { "context": "OutlinePanel", "bindings": { "alt-7": "workspace::CloseActiveDock" } }, + { + "context": "Dock || Workspace || Terminal || OutlinePanel || ProjectPanel || CollabPanel || (Editor && mode == auto_height)", + "bindings": { "escape": "editor::ToggleFocus" } } ] diff --git a/assets/keymaps/macos/jetbrains.json b/assets/keymaps/macos/jetbrains.json index 22c6f18383..a41e39932f 100644 --- a/assets/keymaps/macos/jetbrains.json +++ b/assets/keymaps/macos/jetbrains.json @@ -3,6 +3,7 @@ "bindings": { "cmd-{": "pane::ActivatePreviousItem", "cmd-}": "pane::ActivateNextItem", + "cmd-0": "git_panel::ToggleFocus", // overrides `cmd-0` zoom reset "ctrl-f2": "debugger::Stop", "f6": "debugger::Pause", "f7": "debugger::StepInto", @@ -63,28 +64,50 @@ "context": "Editor && mode == full", "bindings": { "cmd-f12": "outline::Toggle", - "cmd-7": "outline::Toggle", + "cmd-r": ["buffer_search::Deploy", { "replace_enabled": true }], "cmd-shift-o": "file_finder::Toggle", "cmd-l": "go_to_line::Toggle", "alt-enter": "editor::ToggleCodeActions" } }, { - "context": "BufferSearchBar > Editor", + "context": "BufferSearchBar || ProjectSearchBar", "bindings": { - "shift-enter": "search::SelectPreviousMatch" + "shift-enter": "search::SelectPreviousMatch", + "alt-c": "search::ToggleCaseSensitive", + "alt-e": "search::ToggleSelection", + "alt-x": "search::ToggleRegex", + "alt-w": "search::ToggleWholeWord", + "ctrl-alt-c": "search::ToggleCaseSensitive", + "ctrl-alt-e": "search::ToggleSelection", + "ctrl-alt-w": "search::ToggleWholeWord", + "ctrl-alt-x": "search::ToggleRegex" } }, { "context": "Workspace", "bindings": { + "cmd-shift-f12": "workspace::CloseAllDocks", + "cmd-shift-r": ["pane::DeploySearch", { "replace_enabled": true }], + "ctrl-alt-r": "task::Spawn", + "cmd-e": "file_finder::Toggle", + "cmd-k": "git_panel::ToggleFocus", // bug: This should also focus commit editor "cmd-shift-o": "file_finder::Toggle", "cmd-shift-a": "command_palette::Toggle", "shift shift": "command_palette::Toggle", "cmd-alt-o": "project_symbols::Toggle", // JetBrains: Go to Symbol "cmd-o": "project_symbols::Toggle", // JetBrains: Go to Class - "cmd-1": "workspace::ToggleLeftDock", - "cmd-6": "diagnostics::Deploy" + "cmd-1": "project_panel::ToggleFocus", + "cmd-5": "debug_panel::ToggleFocus", + "cmd-6": "diagnostics::Deploy", + "cmd-7": "outline_panel::ToggleFocus" + } + }, + { + "context": "Workspace || Editor", + "bindings": { + "alt-f12": "terminal_panel::ToggleFocus", + "cmd-shift-k": "git::Push" } }, { @@ -98,11 +121,31 @@ "context": "ProjectPanel", "bindings": { "enter": "project_panel::Open", + "cmd-shift-f": "project_panel::NewSearchInDirectory", "cmd-backspace": ["project_panel::Trash", { "skip_prompt": false }], "backspace": ["project_panel::Trash", { "skip_prompt": false }], "delete": ["project_panel::Trash", { "skip_prompt": false }], "shift-delete": ["project_panel::Delete", { "skip_prompt": false }], "shift-f6": "project_panel::Rename" } + }, + { + "context": "Terminal", + "bindings": { + "cmd-t": "workspace::NewTerminal", + "alt-f12": "workspace::CloseActiveDock", + "cmd-up": "terminal::ScrollLineUp", + "cmd-down": "terminal::ScrollLineDown", + "shift-pageup": "terminal::ScrollPageUp", + "shift-pagedown": "terminal::ScrollPageDown" + } + }, + { "context": "GitPanel", "bindings": { "cmd-0": "workspace::CloseActiveDock" } }, + { "context": "DebugPanel", "bindings": { "cmd-5": "workspace::CloseActiveDock" } }, + { "context": "Diagnostics > Editor", "bindings": { "cmd-6": "pane::CloseActiveItem" } }, + { "context": "OutlinePanel", "bindings": { "cmd-7": "workspace::CloseActiveDock" } }, + { + "context": "Dock || Workspace || Terminal || OutlinePanel || ProjectPanel || CollabPanel || (Editor && mode == auto_height)", + "bindings": { "escape": "editor::ToggleFocus" } } ] From 0f72d7ed52bad0c8f6a5e504a2adf9670d726814 Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Thu, 17 Jul 2025 22:46:44 +0530 Subject: [PATCH 0029/1052] editor: Fix sometimes green (+) cursor style appearing when cmd-clicking in same buffer (#34638) Follow-up for https://github.com/zed-industries/zed/pull/34557 This PR clears the selection drag state on click, because mouse up doesn't trigger on click event because of `cx.stop_propagation`. The issue occurs with similar repro steps as mentioned in the attached PR. Release Notes: - Fixed the issue where the green (+) cursor style sometimes appears when navigating to the definition in buffer. --- crates/editor/src/element.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index e77be3398c..fef185bb15 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -949,6 +949,7 @@ impl EditorElement { if !pending_nonempty_selections && hovered_link_modifier && text_hitbox.is_hovered(window) { let point = position_map.point_for_position(event.up.position); editor.handle_click_hovered_link(point, event.modifiers(), window, cx); + editor.selection_drag_state = SelectionDragState::None; cx.stop_propagation(); } From dab0b3509d2394cd073cbd8b4260454c1f1d5278 Mon Sep 17 00:00:00 2001 From: Agus Zubiaga Date: Thu, 17 Jul 2025 14:34:38 -0300 Subject: [PATCH 0030/1052] Unify agent server settings and extract e2e tests out (#34642) Release Notes: - N/A --- crates/agent_servers/Cargo.toml | 2 +- crates/agent_servers/src/agent_servers.rs | 125 +++++- crates/agent_servers/src/claude.rs | 75 ++-- crates/agent_servers/src/e2e_tests.rs | 368 +++++++++++++++ crates/agent_servers/src/gemini.rs | 422 +----------------- crates/agent_servers/src/settings.rs | 1 + .../agent_servers/src/stdio_agent_server.rs | 54 +-- 7 files changed, 547 insertions(+), 500 deletions(-) create mode 100644 crates/agent_servers/src/e2e_tests.rs diff --git a/crates/agent_servers/Cargo.toml b/crates/agent_servers/Cargo.toml index d65235aee3..2d68148264 100644 --- a/crates/agent_servers/Cargo.toml +++ b/crates/agent_servers/Cargo.toml @@ -7,7 +7,7 @@ license = "GPL-3.0-or-later" [features] test-support = ["acp_thread/test-support", "gpui/test-support", "project/test-support"] -gemini = [] +e2e = [] [lints] workspace = true diff --git a/crates/agent_servers/src/agent_servers.rs b/crates/agent_servers/src/agent_servers.rs index ebebeca511..6d9c77f296 100644 --- a/crates/agent_servers/src/agent_servers.rs +++ b/crates/agent_servers/src/agent_servers.rs @@ -3,6 +3,9 @@ mod gemini; mod settings; mod stdio_agent_server; +#[cfg(test)] +mod e2e_tests; + pub use claude::*; pub use gemini::*; pub use settings::*; @@ -11,34 +14,20 @@ pub use stdio_agent_server::*; use acp_thread::AcpThread; use anyhow::Result; use collections::HashMap; -use gpui::{App, Entity, SharedString, Task}; +use gpui::{App, AsyncApp, Entity, SharedString, Task}; use project::Project; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; -use std::path::{Path, PathBuf}; +use std::{ + path::{Path, PathBuf}, + sync::Arc, +}; +use util::ResultExt as _; pub fn init(cx: &mut App) { settings::init(cx); } -#[derive(Deserialize, Serialize, Clone, PartialEq, Eq, JsonSchema)] -pub struct AgentServerCommand { - #[serde(rename = "command")] - pub path: PathBuf, - #[serde(default)] - pub args: Vec, - pub env: Option>, -} - -pub enum AgentServerVersion { - Supported, - Unsupported { - error_message: SharedString, - upgrade_message: SharedString, - upgrade_command: String, - }, -} - pub trait AgentServer: Send { fn logo(&self) -> ui::IconName; fn name(&self) -> &'static str; @@ -78,3 +67,99 @@ impl std::fmt::Debug for AgentServerCommand { .finish() } } + +pub enum AgentServerVersion { + Supported, + Unsupported { + error_message: SharedString, + upgrade_message: SharedString, + upgrade_command: String, + }, +} + +#[derive(Deserialize, Serialize, Clone, PartialEq, Eq, JsonSchema)] +pub struct AgentServerCommand { + #[serde(rename = "command")] + pub path: PathBuf, + #[serde(default)] + pub args: Vec, + pub env: Option>, +} + +impl AgentServerCommand { + pub(crate) async fn resolve( + path_bin_name: &'static str, + extra_args: &[&'static str], + settings: Option, + project: &Entity, + cx: &mut AsyncApp, + ) -> Option { + if let Some(agent_settings) = settings { + return Some(Self { + path: agent_settings.command.path, + args: agent_settings + .command + .args + .into_iter() + .chain(extra_args.iter().map(|arg| arg.to_string())) + .collect(), + env: agent_settings.command.env, + }); + } else { + find_bin_in_path(path_bin_name, project, cx) + .await + .map(|path| Self { + path, + args: extra_args.iter().map(|arg| arg.to_string()).collect(), + env: None, + }) + } + } +} + +async fn find_bin_in_path( + bin_name: &'static str, + project: &Entity, + cx: &mut AsyncApp, +) -> Option { + let (env_task, root_dir) = project + .update(cx, |project, cx| { + let worktree = project.visible_worktrees(cx).next(); + match worktree { + Some(worktree) => { + let env_task = project.environment().update(cx, |env, cx| { + env.get_worktree_environment(worktree.clone(), cx) + }); + + let path = worktree.read(cx).abs_path(); + (env_task, path) + } + None => { + let path: Arc = paths::home_dir().as_path().into(); + let env_task = project.environment().update(cx, |env, cx| { + env.get_directory_environment(path.clone(), cx) + }); + (env_task, path) + } + } + }) + .log_err()?; + + cx.background_executor() + .spawn(async move { + let which_result = if cfg!(windows) { + which::which(bin_name) + } else { + let env = env_task.await.unwrap_or_default(); + let shell_path = env.get("PATH").cloned(); + which::which_in(bin_name, shell_path.as_ref(), root_dir.as_ref()) + }; + + if let Err(which::Error::CannotFindBinaryPath) = which_result { + return None; + } + + which_result.log_err() + }) + .await +} diff --git a/crates/agent_servers/src/claude.rs b/crates/agent_servers/src/claude.rs index 897158dc57..5760a96d8c 100644 --- a/crates/agent_servers/src/claude.rs +++ b/crates/agent_servers/src/claude.rs @@ -3,6 +3,7 @@ mod tools; use collections::HashMap; use project::Project; +use settings::SettingsStore; use std::cell::RefCell; use std::fmt::Display; use std::path::Path; @@ -12,7 +13,7 @@ use agentic_coding_protocol::{ self as acp, AnyAgentRequest, AnyAgentResult, Client, ProtocolVersion, StreamAssistantMessageChunkParams, ToolCallContent, UpdateToolCallParams, }; -use anyhow::{Context as _, Result, anyhow}; +use anyhow::{Result, anyhow}; use futures::channel::oneshot; use futures::future::LocalBoxFuture; use futures::{AsyncBufReadExt, AsyncWriteExt}; @@ -28,7 +29,7 @@ use util::ResultExt; use crate::claude::mcp_server::ClaudeMcpServer; use crate::claude::tools::ClaudeTool; -use crate::{AgentServer, find_bin_in_path}; +use crate::{AgentServer, AgentServerCommand, AllAgentServersSettings}; use acp_thread::{AcpClientDelegate, AcpThread, AgentConnection}; #[derive(Clone)] @@ -87,31 +88,41 @@ impl AgentServer for ClaudeCode { .await?; mcp_config_file.flush().await?; - let command = find_bin_in_path("claude", &project, cx) - .await - .context("Failed to find claude binary")?; + let settings = cx.read_global(|settings: &SettingsStore, _| { + settings.get::(None).claude.clone() + })?; - let mut child = util::command::new_smol_command(&command) - .args([ - "--input-format", - "stream-json", - "--output-format", - "stream-json", - "--print", - "--verbose", - "--mcp-config", - mcp_config_path.to_string_lossy().as_ref(), - "--permission-prompt-tool", - &format!( - "mcp__{}__{}", - mcp_server::SERVER_NAME, - mcp_server::PERMISSION_TOOL - ), - "--allowedTools", - "mcp__zed__Read,mcp__zed__Edit", - "--disallowedTools", - "Read,Edit", - ]) + let Some(command) = + AgentServerCommand::resolve("claude", &[], settings, &project, cx).await + else { + anyhow::bail!("Failed to find claude binary"); + }; + + let mut child = util::command::new_smol_command(&command.path) + .args( + [ + "--input-format", + "stream-json", + "--output-format", + "stream-json", + "--print", + "--verbose", + "--mcp-config", + mcp_config_path.to_string_lossy().as_ref(), + "--permission-prompt-tool", + &format!( + "mcp__{}__{}", + mcp_server::SERVER_NAME, + mcp_server::PERMISSION_TOOL + ), + "--allowedTools", + "mcp__zed__Read,mcp__zed__Edit", + "--disallowedTools", + "Read,Edit", + ] + .into_iter() + .chain(command.args.iter().map(|arg| arg.as_str())), + ) .current_dir(root_dir) .stdin(std::process::Stdio::piped()) .stdout(std::process::Stdio::piped()) @@ -562,10 +573,20 @@ struct McpServerConfig { } #[cfg(test)] -mod tests { +pub(crate) mod tests { use super::*; use serde_json::json; + // crate::common_e2e_tests!(ClaudeCode); + + pub fn local_command() -> AgentServerCommand { + AgentServerCommand { + path: "claude".into(), + args: vec![], + env: None, + } + } + #[test] fn test_deserialize_content_untagged_text() { let json = json!("Hello, world!"); diff --git a/crates/agent_servers/src/e2e_tests.rs b/crates/agent_servers/src/e2e_tests.rs new file mode 100644 index 0000000000..923c6cdd6f --- /dev/null +++ b/crates/agent_servers/src/e2e_tests.rs @@ -0,0 +1,368 @@ +use std::{path::Path, sync::Arc, time::Duration}; + +use crate::{AgentServer, AgentServerSettings, AllAgentServersSettings}; +use acp_thread::{ + AcpThread, AgentThreadEntry, ToolCall, ToolCallConfirmation, ToolCallContent, ToolCallStatus, +}; +use agentic_coding_protocol as acp; +use futures::{FutureExt, StreamExt, channel::mpsc, select}; +use gpui::{Entity, TestAppContext}; +use indoc::indoc; +use project::{FakeFs, Project}; +use serde_json::json; +use settings::{Settings, SettingsStore}; +use util::path; + +pub async fn test_basic(server: impl AgentServer + 'static, cx: &mut TestAppContext) { + let fs = init_test(cx).await; + let project = Project::test(fs, [], cx).await; + let thread = new_test_thread(server, project.clone(), "/private/tmp", cx).await; + + thread + .update(cx, |thread, cx| thread.send_raw("Hello from Zed!", cx)) + .await + .unwrap(); + + thread.read_with(cx, |thread, _| { + assert_eq!(thread.entries().len(), 2); + assert!(matches!( + thread.entries()[0], + AgentThreadEntry::UserMessage(_) + )); + assert!(matches!( + thread.entries()[1], + AgentThreadEntry::AssistantMessage(_) + )); + }); +} + +pub async fn test_path_mentions(server: impl AgentServer + 'static, cx: &mut TestAppContext) { + let _fs = init_test(cx).await; + + let tempdir = tempfile::tempdir().unwrap(); + std::fs::write( + tempdir.path().join("foo.rs"), + indoc! {" + fn main() { + println!(\"Hello, world!\"); + } + "}, + ) + .expect("failed to write file"); + let project = Project::example([tempdir.path()], &mut cx.to_async()).await; + let thread = new_test_thread(server, project.clone(), tempdir.path(), cx).await; + thread + .update(cx, |thread, cx| { + thread.send( + acp::SendUserMessageParams { + chunks: vec![ + acp::UserMessageChunk::Text { + text: "Read the file ".into(), + }, + acp::UserMessageChunk::Path { + path: Path::new("foo.rs").into(), + }, + acp::UserMessageChunk::Text { + text: " and tell me what the content of the println! is".into(), + }, + ], + }, + cx, + ) + }) + .await + .unwrap(); + + thread.read_with(cx, |thread, cx| { + assert_eq!(thread.entries().len(), 3); + assert!(matches!( + thread.entries()[0], + AgentThreadEntry::UserMessage(_) + )); + assert!(matches!(thread.entries()[1], AgentThreadEntry::ToolCall(_))); + let AgentThreadEntry::AssistantMessage(assistant_message) = &thread.entries()[2] else { + panic!("Expected AssistantMessage") + }; + assert!( + assistant_message.to_markdown(cx).contains("Hello, world!"), + "unexpected assistant message: {:?}", + assistant_message.to_markdown(cx) + ); + }); +} + +pub async fn test_tool_call(server: impl AgentServer + 'static, cx: &mut TestAppContext) { + let fs = init_test(cx).await; + fs.insert_tree( + path!("/private/tmp"), + json!({"foo": "Lorem ipsum dolor", "bar": "bar", "baz": "baz"}), + ) + .await; + let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await; + let thread = new_test_thread(server, project.clone(), "/private/tmp", cx).await; + + thread + .update(cx, |thread, cx| { + thread.send_raw( + "Read the '/private/tmp/foo' file and tell me what you see.", + cx, + ) + }) + .await + .unwrap(); + thread.read_with(cx, |thread, _cx| { + assert!(matches!( + &thread.entries()[2], + AgentThreadEntry::ToolCall(ToolCall { + status: ToolCallStatus::Allowed { .. }, + .. + }) + )); + + assert!(matches!( + thread.entries()[3], + AgentThreadEntry::AssistantMessage(_) + )); + }); +} + +pub async fn test_tool_call_with_confirmation( + server: impl AgentServer + 'static, + cx: &mut TestAppContext, +) { + let fs = init_test(cx).await; + let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await; + let thread = new_test_thread(server, project.clone(), "/private/tmp", cx).await; + let full_turn = thread.update(cx, |thread, cx| { + thread.send_raw(r#"Run `echo "Hello, world!"`"#, cx) + }); + + run_until_first_tool_call(&thread, cx).await; + + let tool_call_id = thread.read_with(cx, |thread, _cx| { + let AgentThreadEntry::ToolCall(ToolCall { + id, + status: + ToolCallStatus::WaitingForConfirmation { + confirmation: ToolCallConfirmation::Execute { root_command, .. }, + .. + }, + .. + }) = &thread.entries()[2] + else { + panic!(); + }; + + assert_eq!(root_command, "echo"); + + *id + }); + + thread.update(cx, |thread, cx| { + thread.authorize_tool_call(tool_call_id, acp::ToolCallConfirmationOutcome::Allow, cx); + + assert!(matches!( + &thread.entries()[2], + AgentThreadEntry::ToolCall(ToolCall { + status: ToolCallStatus::Allowed { .. }, + .. + }) + )); + }); + + full_turn.await.unwrap(); + + thread.read_with(cx, |thread, cx| { + let AgentThreadEntry::ToolCall(ToolCall { + content: Some(ToolCallContent::Markdown { markdown }), + status: ToolCallStatus::Allowed { .. }, + .. + }) = &thread.entries()[2] + else { + panic!(); + }; + + markdown.read_with(cx, |md, _cx| { + assert!( + md.source().contains("Hello, world!"), + r#"Expected '{}' to contain "Hello, world!""#, + md.source() + ); + }); + }); +} + +pub async fn test_cancel(server: impl AgentServer + 'static, cx: &mut TestAppContext) { + let fs = init_test(cx).await; + + let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await; + let thread = new_test_thread(server, project.clone(), "/private/tmp", cx).await; + let full_turn = thread.update(cx, |thread, cx| { + thread.send_raw(r#"Run `echo "Hello, world!"`"#, cx) + }); + + let first_tool_call_ix = run_until_first_tool_call(&thread, cx).await; + + thread.read_with(cx, |thread, _cx| { + let AgentThreadEntry::ToolCall(ToolCall { + id, + status: + ToolCallStatus::WaitingForConfirmation { + confirmation: ToolCallConfirmation::Execute { root_command, .. }, + .. + }, + .. + }) = &thread.entries()[first_tool_call_ix] + else { + panic!("{:?}", thread.entries()[1]); + }; + + assert_eq!(root_command, "echo"); + + *id + }); + + thread + .update(cx, |thread, cx| thread.cancel(cx)) + .await + .unwrap(); + full_turn.await.unwrap(); + thread.read_with(cx, |thread, _| { + let AgentThreadEntry::ToolCall(ToolCall { + status: ToolCallStatus::Canceled, + .. + }) = &thread.entries()[first_tool_call_ix] + else { + panic!(); + }; + }); + + thread + .update(cx, |thread, cx| { + thread.send_raw(r#"Stop running and say goodbye to me."#, cx) + }) + .await + .unwrap(); + thread.read_with(cx, |thread, _| { + assert!(matches!( + &thread.entries().last().unwrap(), + AgentThreadEntry::AssistantMessage(..), + )) + }); +} + +#[macro_export] +macro_rules! common_e2e_tests { + ($server:expr) => { + mod common_e2e { + use super::*; + + #[::gpui::test] + #[cfg_attr(not(feature = "e2e"), ignore)] + async fn basic(cx: &mut ::gpui::TestAppContext) { + $crate::e2e_tests::test_basic($server, cx).await; + } + + #[::gpui::test] + #[cfg_attr(not(feature = "e2e"), ignore)] + async fn path_mentions(cx: &mut ::gpui::TestAppContext) { + $crate::e2e_tests::test_path_mentions($server, cx).await; + } + + #[::gpui::test] + #[cfg_attr(not(feature = "e2e"), ignore)] + async fn tool_call(cx: &mut ::gpui::TestAppContext) { + $crate::e2e_tests::test_tool_call($server, cx).await; + } + + #[::gpui::test] + #[cfg_attr(not(feature = "e2e"), ignore)] + async fn tool_call_with_confirmation(cx: &mut ::gpui::TestAppContext) { + $crate::e2e_tests::test_tool_call_with_confirmation($server, cx).await; + } + + #[::gpui::test] + #[cfg_attr(not(feature = "e2e"), ignore)] + async fn cancel(cx: &mut ::gpui::TestAppContext) { + $crate::e2e_tests::test_cancel($server, cx).await; + } + } + }; +} + +// Helpers + +pub async fn init_test(cx: &mut TestAppContext) -> Arc { + env_logger::try_init().ok(); + + cx.update(|cx| { + let settings_store = SettingsStore::test(cx); + cx.set_global(settings_store); + Project::init_settings(cx); + language::init(cx); + crate::settings::init(cx); + + crate::AllAgentServersSettings::override_global( + AllAgentServersSettings { + claude: Some(AgentServerSettings { + command: crate::claude::tests::local_command(), + }), + gemini: Some(AgentServerSettings { + command: crate::gemini::tests::local_command(), + }), + }, + cx, + ); + }); + + cx.executor().allow_parking(); + + FakeFs::new(cx.executor()) +} + +pub async fn new_test_thread( + server: impl AgentServer + 'static, + project: Entity, + current_dir: impl AsRef, + cx: &mut TestAppContext, +) -> Entity { + let thread = cx + .update(|cx| server.new_thread(current_dir.as_ref(), &project, cx)) + .await + .unwrap(); + + thread + .update(cx, |thread, _| thread.initialize()) + .await + .unwrap(); + thread +} + +pub async fn run_until_first_tool_call( + thread: &Entity, + cx: &mut TestAppContext, +) -> usize { + let (mut tx, mut rx) = mpsc::channel::(1); + + let subscription = cx.update(|cx| { + cx.subscribe(thread, move |thread, _, cx| { + for (ix, entry) in thread.read(cx).entries().iter().enumerate() { + if matches!(entry, AgentThreadEntry::ToolCall(_)) { + return tx.try_send(ix).unwrap(); + } + } + }) + }); + + select! { + // We have to use a smol timer here because + // cx.background_executor().timer isn't real in the test context + _ = futures::FutureExt::fuse(smol::Timer::after(Duration::from_secs(10))) => { + panic!("Timeout waiting for tool call") + } + ix = rx.next().fuse() => { + drop(subscription); + ix.unwrap() + } + } +} diff --git a/crates/agent_servers/src/gemini.rs b/crates/agent_servers/src/gemini.rs index bf1d13429e..8ad147cbff 100644 --- a/crates/agent_servers/src/gemini.rs +++ b/crates/agent_servers/src/gemini.rs @@ -1,4 +1,4 @@ -use crate::stdio_agent_server::{StdioAgentServer, find_bin_in_path}; +use crate::stdio_agent_server::StdioAgentServer; use crate::{AgentServerCommand, AgentServerVersion}; use anyhow::{Context as _, Result}; use gpui::{AsyncApp, Entity}; @@ -38,35 +38,15 @@ impl StdioAgentServer for Gemini { project: &Entity, cx: &mut AsyncApp, ) -> Result { - let custom_command = cx.read_global(|settings: &SettingsStore, _| { - let settings = settings.get::(None); - settings - .gemini - .as_ref() - .map(|gemini_settings| AgentServerCommand { - path: gemini_settings.command.path.clone(), - args: gemini_settings - .command - .args - .iter() - .cloned() - .chain(std::iter::once(ACP_ARG.into())) - .collect(), - env: gemini_settings.command.env.clone(), - }) + let settings = cx.read_global(|settings: &SettingsStore, _| { + settings.get::(None).gemini.clone() })?; - if let Some(custom_command) = custom_command { - return Ok(custom_command); - } - - if let Some(path) = find_bin_in_path("gemini", project, cx).await { - return Ok(AgentServerCommand { - path, - args: vec![ACP_ARG.into()], - env: None, - }); - } + if let Some(command) = + AgentServerCommand::resolve("gemini", &[ACP_ARG], settings, &project, cx).await + { + return Ok(command); + }; let (fs, node_runtime) = project.update(cx, |project, _| { (project.fs().clone(), project.node_runtime().cloned()) @@ -121,381 +101,23 @@ impl StdioAgentServer for Gemini { } #[cfg(test)] -mod test { - use std::{path::Path, time::Duration}; +pub(crate) mod tests { + use super::*; + use crate::AgentServerCommand; + use std::path::Path; - use acp_thread::{ - AcpThread, AgentThreadEntry, ToolCall, ToolCallConfirmation, ToolCallContent, - ToolCallStatus, - }; - use agentic_coding_protocol as acp; - use anyhow::Result; - use futures::{FutureExt, StreamExt, channel::mpsc, select}; - use gpui::{AsyncApp, Entity, TestAppContext}; - use indoc::indoc; - use project::{FakeFs, Project}; - use serde_json::json; - use settings::SettingsStore; - use util::path; + crate::common_e2e_tests!(Gemini); - use crate::{AgentServer, AgentServerCommand, AgentServerVersion, StdioAgentServer}; + pub fn local_command() -> AgentServerCommand { + let cli_path = Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../gemini-cli/packages/cli") + .to_string_lossy() + .to_string(); - pub async fn gemini_acp_thread( - project: Entity, - current_dir: impl AsRef, - cx: &mut TestAppContext, - ) -> Entity { - #[derive(Clone)] - struct DevGemini; - - impl StdioAgentServer for DevGemini { - async fn command( - &self, - _project: &Entity, - _cx: &mut AsyncApp, - ) -> Result { - let cli_path = Path::new(env!("CARGO_MANIFEST_DIR")) - .join("../../../gemini-cli/packages/cli") - .to_string_lossy() - .to_string(); - - Ok(AgentServerCommand { - path: "node".into(), - args: vec![cli_path, "--experimental-acp".into()], - env: None, - }) - } - - async fn version(&self, _command: &AgentServerCommand) -> Result { - Ok(AgentServerVersion::Supported) - } - - fn logo(&self) -> ui::IconName { - ui::IconName::AiGemini - } - - fn name(&self) -> &'static str { - "test" - } - - fn empty_state_headline(&self) -> &'static str { - "test" - } - - fn empty_state_message(&self) -> &'static str { - "test" - } - - fn supports_always_allow(&self) -> bool { - true - } - } - - let thread = cx - .update(|cx| AgentServer::new_thread(&DevGemini, current_dir.as_ref(), &project, cx)) - .await - .unwrap(); - - thread - .update(cx, |thread, _| thread.initialize()) - .await - .unwrap(); - thread - } - - fn init_test(cx: &mut TestAppContext) { - env_logger::try_init().ok(); - cx.update(|cx| { - let settings_store = SettingsStore::test(cx); - cx.set_global(settings_store); - Project::init_settings(cx); - language::init(cx); - }); - } - - #[gpui::test] - #[cfg_attr(not(feature = "gemini"), ignore)] - async fn test_gemini_basic(cx: &mut TestAppContext) { - init_test(cx); - - cx.executor().allow_parking(); - - let fs = FakeFs::new(cx.executor()); - let project = Project::test(fs, [], cx).await; - let thread = gemini_acp_thread(project.clone(), "/private/tmp", cx).await; - thread - .update(cx, |thread, cx| thread.send_raw("Hello from Zed!", cx)) - .await - .unwrap(); - - thread.read_with(cx, |thread, _| { - assert_eq!(thread.entries().len(), 2); - assert!(matches!( - thread.entries()[0], - AgentThreadEntry::UserMessage(_) - )); - assert!(matches!( - thread.entries()[1], - AgentThreadEntry::AssistantMessage(_) - )); - }); - } - - #[gpui::test] - #[cfg_attr(not(feature = "gemini"), ignore)] - async fn test_gemini_path_mentions(cx: &mut TestAppContext) { - init_test(cx); - - cx.executor().allow_parking(); - let tempdir = tempfile::tempdir().unwrap(); - std::fs::write( - tempdir.path().join("foo.rs"), - indoc! {" - fn main() { - println!(\"Hello, world!\"); - } - "}, - ) - .expect("failed to write file"); - let project = Project::example([tempdir.path()], &mut cx.to_async()).await; - let thread = gemini_acp_thread(project.clone(), tempdir.path(), cx).await; - thread - .update(cx, |thread, cx| { - thread.send( - acp::SendUserMessageParams { - chunks: vec![ - acp::UserMessageChunk::Text { - text: "Read the file ".into(), - }, - acp::UserMessageChunk::Path { - path: Path::new("foo.rs").into(), - }, - acp::UserMessageChunk::Text { - text: " and tell me what the content of the println! is".into(), - }, - ], - }, - cx, - ) - }) - .await - .unwrap(); - - thread.read_with(cx, |thread, cx| { - assert_eq!(thread.entries().len(), 3); - assert!(matches!( - thread.entries()[0], - AgentThreadEntry::UserMessage(_) - )); - assert!(matches!(thread.entries()[1], AgentThreadEntry::ToolCall(_))); - let AgentThreadEntry::AssistantMessage(assistant_message) = &thread.entries()[2] else { - panic!("Expected AssistantMessage") - }; - assert!( - assistant_message.to_markdown(cx).contains("Hello, world!"), - "unexpected assistant message: {:?}", - assistant_message.to_markdown(cx) - ); - }); - } - - #[gpui::test] - #[cfg_attr(not(feature = "gemini"), ignore)] - async fn test_gemini_tool_call(cx: &mut TestAppContext) { - init_test(cx); - - cx.executor().allow_parking(); - - let fs = FakeFs::new(cx.executor()); - fs.insert_tree( - path!("/private/tmp"), - json!({"foo": "Lorem ipsum dolor", "bar": "bar", "baz": "baz"}), - ) - .await; - let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await; - let thread = gemini_acp_thread(project.clone(), "/private/tmp", cx).await; - thread - .update(cx, |thread, cx| { - thread.send_raw( - "Read the '/private/tmp/foo' file and tell me what you see.", - cx, - ) - }) - .await - .unwrap(); - thread.read_with(cx, |thread, _cx| { - assert!(matches!( - &thread.entries()[2], - AgentThreadEntry::ToolCall(ToolCall { - status: ToolCallStatus::Allowed { .. }, - .. - }) - )); - - assert!(matches!( - thread.entries()[3], - AgentThreadEntry::AssistantMessage(_) - )); - }); - } - - #[gpui::test] - #[cfg_attr(not(feature = "gemini"), ignore)] - async fn test_gemini_tool_call_with_confirmation(cx: &mut TestAppContext) { - init_test(cx); - - cx.executor().allow_parking(); - - let fs = FakeFs::new(cx.executor()); - let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await; - let thread = gemini_acp_thread(project.clone(), "/private/tmp", cx).await; - let full_turn = thread.update(cx, |thread, cx| { - thread.send_raw(r#"Run `echo "Hello, world!"`"#, cx) - }); - - run_until_first_tool_call(&thread, cx).await; - - let tool_call_id = thread.read_with(cx, |thread, _cx| { - let AgentThreadEntry::ToolCall(ToolCall { - id, - status: - ToolCallStatus::WaitingForConfirmation { - confirmation: ToolCallConfirmation::Execute { root_command, .. }, - .. - }, - .. - }) = &thread.entries()[2] - else { - panic!(); - }; - - assert_eq!(root_command, "echo"); - - *id - }); - - thread.update(cx, |thread, cx| { - thread.authorize_tool_call(tool_call_id, acp::ToolCallConfirmationOutcome::Allow, cx); - - assert!(matches!( - &thread.entries()[2], - AgentThreadEntry::ToolCall(ToolCall { - status: ToolCallStatus::Allowed { .. }, - .. - }) - )); - }); - - full_turn.await.unwrap(); - - thread.read_with(cx, |thread, cx| { - let AgentThreadEntry::ToolCall(ToolCall { - content: Some(ToolCallContent::Markdown { markdown }), - status: ToolCallStatus::Allowed { .. }, - .. - }) = &thread.entries()[2] - else { - panic!(); - }; - - markdown.read_with(cx, |md, _cx| { - assert!( - md.source().contains("Hello, world!"), - r#"Expected '{}' to contain "Hello, world!""#, - md.source() - ); - }); - }); - } - - #[gpui::test] - #[cfg_attr(not(feature = "gemini"), ignore)] - async fn test_gemini_cancel(cx: &mut TestAppContext) { - init_test(cx); - - cx.executor().allow_parking(); - - let fs = FakeFs::new(cx.executor()); - let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await; - let thread = gemini_acp_thread(project.clone(), "/private/tmp", cx).await; - let full_turn = thread.update(cx, |thread, cx| { - thread.send_raw(r#"Run `echo "Hello, world!"`"#, cx) - }); - - let first_tool_call_ix = run_until_first_tool_call(&thread, cx).await; - - thread.read_with(cx, |thread, _cx| { - let AgentThreadEntry::ToolCall(ToolCall { - id, - status: - ToolCallStatus::WaitingForConfirmation { - confirmation: ToolCallConfirmation::Execute { root_command, .. }, - .. - }, - .. - }) = &thread.entries()[first_tool_call_ix] - else { - panic!("{:?}", thread.entries()[1]); - }; - - assert_eq!(root_command, "echo"); - - *id - }); - - thread - .update(cx, |thread, cx| thread.cancel(cx)) - .await - .unwrap(); - full_turn.await.unwrap(); - thread.read_with(cx, |thread, _| { - let AgentThreadEntry::ToolCall(ToolCall { - status: ToolCallStatus::Canceled, - .. - }) = &thread.entries()[first_tool_call_ix] - else { - panic!(); - }; - }); - - thread - .update(cx, |thread, cx| { - thread.send_raw(r#"Stop running and say goodbye to me."#, cx) - }) - .await - .unwrap(); - thread.read_with(cx, |thread, _| { - assert!(matches!( - &thread.entries().last().unwrap(), - AgentThreadEntry::AssistantMessage(..), - )) - }); - } - - async fn run_until_first_tool_call( - thread: &Entity, - cx: &mut TestAppContext, - ) -> usize { - let (mut tx, mut rx) = mpsc::channel::(1); - - let subscription = cx.update(|cx| { - cx.subscribe(thread, move |thread, _, cx| { - for (ix, entry) in thread.read(cx).entries().iter().enumerate() { - if matches!(entry, AgentThreadEntry::ToolCall(_)) { - return tx.try_send(ix).unwrap(); - } - } - }) - }); - - select! { - _ = cx.executor().timer(Duration::from_secs(10)).fuse() => { - panic!("Timeout waiting for tool call") - } - ix = rx.next().fuse() => { - drop(subscription); - ix.unwrap() - } + AgentServerCommand { + path: "node".into(), + args: vec![cli_path, ACP_ARG.into()], + env: None, } } } diff --git a/crates/agent_servers/src/settings.rs b/crates/agent_servers/src/settings.rs index 8e6914352b..29dcf5eb8c 100644 --- a/crates/agent_servers/src/settings.rs +++ b/crates/agent_servers/src/settings.rs @@ -12,6 +12,7 @@ pub fn init(cx: &mut App) { #[derive(Default, Deserialize, Serialize, Clone, JsonSchema, Debug)] pub struct AllAgentServersSettings { pub gemini: Option, + pub claude: Option, } #[derive(Deserialize, Serialize, Clone, JsonSchema, Debug)] diff --git a/crates/agent_servers/src/stdio_agent_server.rs b/crates/agent_servers/src/stdio_agent_server.rs index d78506022d..e60dd39de4 100644 --- a/crates/agent_servers/src/stdio_agent_server.rs +++ b/crates/agent_servers/src/stdio_agent_server.rs @@ -4,11 +4,8 @@ use agentic_coding_protocol as acp; use anyhow::{Result, anyhow}; use gpui::{App, AsyncApp, Entity, Task, prelude::*}; use project::Project; -use std::{ - path::{Path, PathBuf}, - sync::Arc, -}; -use util::{ResultExt, paths}; +use std::path::Path; +use util::ResultExt; pub trait StdioAgentServer: Send + Clone { fn logo(&self) -> ui::IconName; @@ -120,50 +117,3 @@ impl AgentServer for T { }) } } - -pub async fn find_bin_in_path( - bin_name: &'static str, - project: &Entity, - cx: &mut AsyncApp, -) -> Option { - let (env_task, root_dir) = project - .update(cx, |project, cx| { - let worktree = project.visible_worktrees(cx).next(); - match worktree { - Some(worktree) => { - let env_task = project.environment().update(cx, |env, cx| { - env.get_worktree_environment(worktree.clone(), cx) - }); - - let path = worktree.read(cx).abs_path(); - (env_task, path) - } - None => { - let path: Arc = paths::home_dir().as_path().into(); - let env_task = project.environment().update(cx, |env, cx| { - env.get_directory_environment(path.clone(), cx) - }); - (env_task, path) - } - } - }) - .log_err()?; - - cx.background_executor() - .spawn(async move { - let which_result = if cfg!(windows) { - which::which(bin_name) - } else { - let env = env_task.await.unwrap_or_default(); - let shell_path = env.get("PATH").cloned(); - which::which_in(bin_name, shell_path.as_ref(), root_dir.as_ref()) - }; - - if let Err(which::Error::CannotFindBinaryPath) = which_result { - return None; - } - - which_result.log_err() - }) - .await -} From 9efe9df80080fe09e8bfe679cdb5804611a3a8b9 Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Thu, 17 Jul 2025 14:32:04 -0400 Subject: [PATCH 0031/1052] Harmonize `buffer_font_size` between default.json and initial_settings.json (#34650) Release Notes: - N/A --- assets/settings/initial_user_settings.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/assets/settings/initial_user_settings.json b/assets/settings/initial_user_settings.json index 71f3beb1d6..5ac2063bdb 100644 --- a/assets/settings/initial_user_settings.json +++ b/assets/settings/initial_user_settings.json @@ -8,7 +8,7 @@ // command palette (cmd-shift-p / ctrl-shift-p) { "ui_font_size": 16, - "buffer_font_size": 16, + "buffer_font_size": 15, "theme": { "mode": "system", "light": "One Light", From 1e60ebb2c6364279be3d08ed20ff4399fe61197c Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Thu, 17 Jul 2025 14:34:04 -0400 Subject: [PATCH 0032/1052] collab: Remove `GET /billing/usage` endpoint (#34651) This PR removes the `GET /billing/usage` endpoint, as it has been moved to `cloud.zed.dev`. Release Notes: - N/A --- crates/collab/src/api/billing.rs | 159 +------------------------------ 1 file changed, 1 insertion(+), 158 deletions(-) diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs index 1ca71726f9..09f307c672 100644 --- a/crates/collab/src/api/billing.rs +++ b/crates/collab/src/api/billing.rs @@ -1,10 +1,6 @@ use anyhow::{Context as _, bail}; use axum::routing::put; -use axum::{ - Extension, Json, Router, - extract::{self, Query}, - routing::{get, post}, -}; +use axum::{Extension, Json, Router, extract, routing::post}; use chrono::{DateTime, SecondsFormat, Utc}; use collections::{HashMap, HashSet}; use reqwest::StatusCode; @@ -28,7 +24,6 @@ use crate::api::events::SnowflakeRow; use crate::db::billing_subscription::{ StripeCancellationReason, StripeSubscriptionStatus, SubscriptionKind, }; -use crate::llm::AGENT_EXTENDED_TRIAL_FEATURE_FLAG; use crate::llm::db::subscription_usage_meter::{self, CompletionMode}; use crate::rpc::{ResultExt as _, Server}; use crate::stripe_client::{ @@ -58,7 +53,6 @@ pub fn router() -> Router { "/billing/subscriptions/sync", post(sync_billing_subscription), ) - .route("/billing/usage", get(get_current_usage)) } #[derive(Debug, Serialize)] @@ -1027,157 +1021,6 @@ async fn handle_customer_subscription_event( Ok(()) } -#[derive(Debug, Deserialize)] -struct GetCurrentUsageParams { - github_user_id: i32, -} - -#[derive(Debug, Serialize)] -struct UsageCounts { - pub used: i32, - pub limit: Option, - pub remaining: Option, -} - -#[derive(Debug, Serialize)] -struct ModelRequestUsage { - pub model: String, - pub mode: CompletionMode, - pub requests: i32, -} - -#[derive(Debug, Serialize)] -struct CurrentUsage { - pub model_requests: UsageCounts, - pub model_request_usage: Vec, - pub edit_predictions: UsageCounts, -} - -#[derive(Debug, Default, Serialize)] -struct GetCurrentUsageResponse { - pub plan: String, - pub current_usage: Option, -} - -async fn get_current_usage( - Extension(app): Extension>, - Query(params): Query, -) -> Result> { - let user = app - .db - .get_user_by_github_user_id(params.github_user_id) - .await? - .context("user not found")?; - - let feature_flags = app.db.get_user_flags(user.id).await?; - let has_extended_trial = feature_flags - .iter() - .any(|flag| flag == AGENT_EXTENDED_TRIAL_FEATURE_FLAG); - - let Some(llm_db) = app.llm_db.clone() else { - return Err(Error::http( - StatusCode::NOT_IMPLEMENTED, - "LLM database not available".into(), - )); - }; - - let Some(subscription) = app.db.get_active_billing_subscription(user.id).await? else { - return Ok(Json(GetCurrentUsageResponse::default())); - }; - - let subscription_period = maybe!({ - let period_start_at = subscription.current_period_start_at()?; - let period_end_at = subscription.current_period_end_at()?; - - Some((period_start_at, period_end_at)) - }); - - let Some((period_start_at, period_end_at)) = subscription_period else { - return Ok(Json(GetCurrentUsageResponse::default())); - }; - - let usage = llm_db - .get_subscription_usage_for_period(user.id, period_start_at, period_end_at) - .await?; - - let plan = subscription - .kind - .map(Into::into) - .unwrap_or(zed_llm_client::Plan::ZedFree); - - let model_requests_limit = match plan.model_requests_limit() { - zed_llm_client::UsageLimit::Limited(limit) => { - let limit = if plan == zed_llm_client::Plan::ZedProTrial && has_extended_trial { - 1_000 - } else { - limit - }; - - Some(limit) - } - zed_llm_client::UsageLimit::Unlimited => None, - }; - - let edit_predictions_limit = match plan.edit_predictions_limit() { - zed_llm_client::UsageLimit::Limited(limit) => Some(limit), - zed_llm_client::UsageLimit::Unlimited => None, - }; - - let Some(usage) = usage else { - return Ok(Json(GetCurrentUsageResponse { - plan: plan.as_str().to_string(), - current_usage: Some(CurrentUsage { - model_requests: UsageCounts { - used: 0, - limit: model_requests_limit, - remaining: model_requests_limit, - }, - model_request_usage: Vec::new(), - edit_predictions: UsageCounts { - used: 0, - limit: edit_predictions_limit, - remaining: edit_predictions_limit, - }, - }), - })); - }; - - let subscription_usage_meters = llm_db - .get_current_subscription_usage_meters_for_user(user.id, Utc::now()) - .await?; - - let model_request_usage = subscription_usage_meters - .into_iter() - .filter_map(|(usage_meter, _usage)| { - let model = llm_db.model_by_id(usage_meter.model_id).ok()?; - - Some(ModelRequestUsage { - model: model.name.clone(), - mode: usage_meter.mode, - requests: usage_meter.requests, - }) - }) - .collect::>(); - - Ok(Json(GetCurrentUsageResponse { - plan: plan.as_str().to_string(), - current_usage: Some(CurrentUsage { - model_requests: UsageCounts { - used: usage.model_requests, - limit: model_requests_limit, - remaining: model_requests_limit.map(|limit| (limit - usage.model_requests).max(0)), - }, - model_request_usage, - edit_predictions: UsageCounts { - used: usage.edit_predictions, - limit: edit_predictions_limit, - remaining: edit_predictions_limit - .map(|limit| (limit - usage.edit_predictions).max(0)), - }, - }), - })) -} - impl From for StripeSubscriptionStatus { fn from(value: SubscriptionStatus) -> Self { match value { From 0c88189aab0bee0661ee8bcfebdcceccf47e5003 Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Thu, 17 Jul 2025 15:23:00 -0400 Subject: [PATCH 0033/1052] Refine JetBrains keymaps (#34658) Follow-up to: https://github.com/zed-industries/zed/pull/34641 Release Notes: - N/A --- assets/keymaps/linux/jetbrains.json | 15 ++++++++++----- assets/keymaps/macos/jetbrains.json | 7 ++++++- 2 files changed, 16 insertions(+), 6 deletions(-) diff --git a/assets/keymaps/linux/jetbrains.json b/assets/keymaps/linux/jetbrains.json index 7266318a9e..629333663d 100644 --- a/assets/keymaps/linux/jetbrains.json +++ b/assets/keymaps/linux/jetbrains.json @@ -72,14 +72,19 @@ "alt-enter": "editor::ToggleCodeActions" } }, + { + "context": "BufferSearchBar", + "bindings": { + "shift-enter": "search::SelectPreviousMatch" + } + }, { "context": "BufferSearchBar || ProjectSearchBar", "bindings": { - "shift-enter": "search::SelectPreviousMatch", - "ctrl-alt-c": "search::ToggleCaseSensitive", - "ctrl-alt-e": "search::ToggleSelection", - "ctrl-alt-w": "search::ToggleWholeWord", - "ctrl-alt-x": "search::ToggleRegex" + "alt-c": "search::ToggleCaseSensitive", + "alt-e": "search::ToggleSelection", + "alt-x": "search::ToggleRegex", + "alt-w": "search::ToggleWholeWord" } }, { diff --git a/assets/keymaps/macos/jetbrains.json b/assets/keymaps/macos/jetbrains.json index a41e39932f..e8b796f534 100644 --- a/assets/keymaps/macos/jetbrains.json +++ b/assets/keymaps/macos/jetbrains.json @@ -70,10 +70,15 @@ "alt-enter": "editor::ToggleCodeActions" } }, + { + "context": "BufferSearchBar", + "bindings": { + "shift-enter": "search::SelectPreviousMatch" + } + }, { "context": "BufferSearchBar || ProjectSearchBar", "bindings": { - "shift-enter": "search::SelectPreviousMatch", "alt-c": "search::ToggleCaseSensitive", "alt-e": "search::ToggleSelection", "alt-x": "search::ToggleRegex", From 237ce5c8e8e3107981c6922a883527afa2ea2c83 Mon Sep 17 00:00:00 2001 From: Cole Miller Date: Thu, 17 Jul 2025 17:38:45 -0400 Subject: [PATCH 0034/1052] Report build SHA to Slack for Zed Nightly panics (#34665) There can be a bunch of nightlies with the same version number and it's helpful to know exactly which one reported a panic. Release Notes: - N/A --- crates/collab/src/api/events.rs | 81 +++++++++++++++++---------------- 1 file changed, 43 insertions(+), 38 deletions(-) diff --git a/crates/collab/src/api/events.rs b/crates/collab/src/api/events.rs index 6ccc86c520..bc7dd152b0 100644 --- a/crates/collab/src/api/events.rs +++ b/crates/collab/src/api/events.rs @@ -389,53 +389,58 @@ pub async fn post_panic( } } - let backtrace = if panic.backtrace.len() > 25 { - let total = panic.backtrace.len(); - format!( - "{}\n and {} more", - panic - .backtrace - .iter() - .take(20) - .cloned() - .collect::>() - .join("\n"), - total - 20 - ) - } else { - panic.backtrace.join("\n") - }; - if !report_to_slack(&panic) { return Ok(()); } - let backtrace_with_summary = panic.payload + "\n" + &backtrace; - if let Some(slack_panics_webhook) = app.config.slack_panics_webhook.clone() { + let backtrace = if panic.backtrace.len() > 25 { + let total = panic.backtrace.len(); + format!( + "{}\n and {} more", + panic + .backtrace + .iter() + .take(20) + .cloned() + .collect::>() + .join("\n"), + total - 20 + ) + } else { + panic.backtrace.join("\n") + }; + let backtrace_with_summary = panic.payload + "\n" + &backtrace; + + let version = if panic.release_channel == "nightly" + && !panic.app_version.contains("remote-server") + && let Some(sha) = panic.app_commit_sha + { + format!("Zed Nightly {}", sha.chars().take(7).collect::()) + } else { + panic.app_version + }; + let payload = slack::WebhookBody::new(|w| { w.add_section(|s| s.text(slack::Text::markdown("Panic request".to_string()))) .add_section(|s| { - s.add_field(slack::Text::markdown(format!( - "*Version:*\n {} ", - panic.app_version - ))) - .add_field({ - let hostname = app.config.blob_store_url.clone().unwrap_or_default(); - let hostname = hostname.strip_prefix("https://").unwrap_or_else(|| { - hostname.strip_prefix("http://").unwrap_or_default() - }); + s.add_field(slack::Text::markdown(format!("*Version:*\n {version} ",))) + .add_field({ + let hostname = app.config.blob_store_url.clone().unwrap_or_default(); + let hostname = hostname.strip_prefix("https://").unwrap_or_else(|| { + hostname.strip_prefix("http://").unwrap_or_default() + }); - slack::Text::markdown(format!( - "*{} {}:*\n", - panic.os_name, - panic.os_version.unwrap_or_default(), - CRASH_REPORTS_BUCKET, - hostname, - incident_id, - incident_id.chars().take(8).collect::(), - )) - }) + slack::Text::markdown(format!( + "*{} {}:*\n", + panic.os_name, + panic.os_version.unwrap_or_default(), + CRASH_REPORTS_BUCKET, + hostname, + incident_id, + incident_id.chars().take(8).collect::(), + )) + }) }) .add_rich_text(|r| r.add_preformatted(|p| p.add_text(backtrace_with_summary))) }); From 29030a243ca9cf3b99e6746f9addcaf318da5112 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Thu, 17 Jul 2025 18:49:44 -0300 Subject: [PATCH 0035/1052] docs: Add instructions about how to use MCP servers (#34656) Release Notes: - N/A --- docs/src/ai/agent-panel.md | 6 ++ docs/src/ai/mcp.md | 109 +++++++++++++++++++++++++++++++------ 2 files changed, 97 insertions(+), 18 deletions(-) diff --git a/docs/src/ai/agent-panel.md b/docs/src/ai/agent-panel.md index ca35e06e11..97568d6643 100644 --- a/docs/src/ai/agent-panel.md +++ b/docs/src/ai/agent-panel.md @@ -121,6 +121,12 @@ Zed will store this profile in your settings using the same profile name as the All custom profiles can be edited via the UI or by hand under the `assistant.profiles` key in your `settings.json` file. +### Tool Approval + +Zed's Agent Panel surfaces the `agent.always_allow_tool_actions` setting that, if turned to `false`, will require you to give permission to any editing attempt as well as tool calls coming from MCP servers. + +You can change that by setting this key to `true` in either your `settings.json` or via the Agent Panel's settings view. + ### Model Support {#model-support} Tool calling needs to be individually supported by each model and model provider. diff --git a/docs/src/ai/mcp.md b/docs/src/ai/mcp.md index 202b141022..95929b2d7e 100644 --- a/docs/src/ai/mcp.md +++ b/docs/src/ai/mcp.md @@ -4,35 +4,35 @@ Zed uses the [Model Context Protocol](https://modelcontextprotocol.io/) to inter > The Model Context Protocol (MCP) is an open protocol that enables seamless integration between LLM applications and external data sources and tools. Whether you're building an AI-powered IDE, enhancing a chat interface, or creating custom AI workflows, MCP provides a standardized way to connect LLMs with the context they need. -Check out the [Anthropic news post](https://www.anthropic.com/news/model-context-protocol) and the [Zed blog post](https://zed.dev/blog/mcp) for an introduction to MCP. +Check out the [Anthropic news post](https://www.anthropic.com/news/model-context-protocol) and the [Zed blog post](https://zed.dev/blog/mcp) for a general intro to MCP. -## MCP Servers as Extensions +## Installing MCP Servers + +### As Extensions One of the ways you can use MCP servers in Zed is by exposing them as an extension. -To learn how to do that, check out the [MCP Server Extensions](../extensions/mcp-extensions.md) page for more details. +To learn how to create your own, check out the [MCP Server Extensions](../extensions/mcp-extensions.md) page for more details. -### Available extensions - -Many MCP servers have been exposed as extensions already, thanks to Zed's awesome community. -Check which ones are already available in Zed's extension store via any of these routes: +Thanks to our awesome community, many MCP servers have already been added as extensions. +You can check which ones are available via any of these routes: 1. [the Zed website](https://zed.dev/extensions?filter=context-servers) -2. in the app, run the `zed: extensions` action +2. in the app, open the Command Palette and run the `zed: extensions` action 3. in the app, go to the Agent Panel's top-right menu and look for the "View Server Extensions" menu item In any case, here are some of the ones available: -- [Postgres](https://github.com/zed-extensions/postgres-context-server) -- [GitHub](https://github.com/LoamStudios/zed-mcp-server-github) -- [Puppeteer](https://github.com/zed-extensions/mcp-server-puppeteer) -- [BrowserTools](https://github.com/mirageN1349/browser-tools-context-server) -- [Brave Search](https://github.com/zed-extensions/mcp-server-brave-search) +- [Context7](https://zed.dev/extensions/context7-mcp-server) +- [GitHub](https://zed.dev/extensions/github-mcp-server) +- [Puppeteer](https://zed.dev/extensions/puppeteer-mcp-server) +- [Gem](https://zed.dev/extensions/gem) +- [Brave Search](https://zed.dev/extensions/brave-search-mcp-server) - [Prisma](https://github.com/aqrln/prisma-mcp-zed) -- [Framelink Figma](https://github.com/LoamStudios/zed-mcp-server-figma) -- [Linear](https://github.com/LoamStudios/zed-mcp-server-linear) -- [Resend](https://github.com/danilo-leal/zed-resend-mcp-server) +- [Framelink Figma](https://zed.dev/extensions/framelink-figma-mcp-server) +- [Linear](https://zed.dev/extensions/linear-mcp-server) +- [Resend](https://zed.dev/extensions/resend-mcp-server) -## Add your own MCP server +### As Custom Servers Creating an extension is not the only way to use MCP servers in Zed. You can connect them by adding their commands directly to your `settings.json`, like so: @@ -51,4 +51,77 @@ You can connect them by adding their commands directly to your `settings.json`, ``` Alternatively, you can also add a custom server by accessing the Agent Panel's Settings view (also accessible via the `agent: open configuration` action). -From there, you can add it through the modal that appears when clicking the "Add Custom Server" button. +From there, you can add it through the modal that appears when you click the "Add Custom Server" button. + +## Using MCP Servers + +### Installation Check + +Regardless of whether you're using MCP servers as an extension or adding them directly, most servers out there need some sort of configuration as part of the set up process. + +In the case of extensions, Zed will show a modal displaying what is required for you to properly set up a given server. +For example, the GitHub MCP extension requires you to add a [Personal Access Token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens). + +In the case of custom servers, make sure you check the provider documentation to determine what type of command, arguments, and environment variables need to be added to the JSON. + +To check whether your MCP server is properly installed, go to the Agent Panel's settings view and watch the indicator dot next to its name. +If they're running correctly, the indicator will be green and its tooltip will say "Server is active". +If not, other colors and tooltip messages will indicate what is happening. + +### Using in the Agent Panel + +Once installation is complete, you can return to the Agent Panel and start prompting. +Mentioning your MCP server by name helps the agent pick it up. + +If you want to ensure a given server will be used, you can create [a custom profile](./agent-panel.md#custom-profiles) by turning off the built-in tools (either all of them or the ones that would cause conflicts) and turning on only the tools coming from the MCP server. + +As an example, [the Dagger team suggests](https://container-use.com/agent-integrations#add-container-use-agent-profile-optional) doing that with their [Container Use MCP server](https://zed.dev/extensions/container-use-mcp-server): + +```json +"agent": { + "profiles": { + "container-use": { + "name": "Container Use", + "tools": { + "fetch": true, + "thinking": true, + "copy_path": false, + "find_path": false, + "delete_path": false, + "create_directory": false, + "list_directory": false, + "diagnostics": false, + "read_file": false, + "open": false, + "move_path": false, + "grep": false, + "edit_file": false, + "terminal": false + }, + "enable_all_context_servers": false, + "context_servers": { + "container-use": { + "tools": { + "environment_create": true, + "environment_add_service": true, + "environment_update": true, + "environment_run_cmd": true, + "environment_open": true, + "environment_file_write": true, + "environment_file_read": true, + "environment_file_list": true, + "environment_file_delete": true, + "environment_checkpoint": true + } + } + } + } + } +} +``` + +### Tool Approval + +Zed's Agent Panel includes the `agent.always_allow_tool_actions` setting that, if set to `false`, will require you to give permission for any editing attempt as well as tool calls coming from MCP servers. + +You can change this by setting this key to `true` in either your `settings.json` or through the Agent Panel's settings view. From 6c741292dfc538b10fcb753a1c35e631611b386a Mon Sep 17 00:00:00 2001 From: Finn Evers Date: Fri, 18 Jul 2025 00:12:10 +0200 Subject: [PATCH 0036/1052] keymap_ui: Fix various keymap editor issues (#34647) This PR tackles miscellaneous nits for the new keymap editor UI. Release Notes: - N/A --------- Co-authored-by: Ben Kunkle --- crates/settings_ui/src/keybindings.rs | 373 ++++++++++-------- crates/settings_ui/src/ui_components/table.rs | 31 ++ 2 files changed, 246 insertions(+), 158 deletions(-) diff --git a/crates/settings_ui/src/keybindings.rs b/crates/settings_ui/src/keybindings.rs index af096f4ce1..d5ac253fb8 100644 --- a/crates/settings_ui/src/keybindings.rs +++ b/crates/settings_ui/src/keybindings.rs @@ -22,9 +22,9 @@ use settings::{BaseKeymap, KeybindSource, KeymapFile, SettingsAssets}; use util::ResultExt; use ui::{ - ActiveTheme as _, App, Banner, BorrowAppContext, ContextMenu, IconButtonShape, Modal, - ModalFooter, ModalHeader, ParentElement as _, Render, Section, SharedString, Styled as _, - Tooltip, Window, prelude::*, + ActiveTheme as _, App, Banner, BorrowAppContext, ContextMenu, IconButtonShape, Indicator, + Modal, ModalFooter, ModalHeader, ParentElement as _, Render, Section, SharedString, + Styled as _, Tooltip, Window, prelude::*, }; use ui_input::SingleLineInput; use workspace::{ @@ -179,14 +179,29 @@ impl FilterState { #[derive(Debug, Default, PartialEq, Eq, Clone, Hash)] struct ActionMapping { - keystroke_text: SharedString, + keystrokes: Vec, context: Option, } +#[derive(Debug)] +struct KeybindConflict { + first_conflict_index: usize, + remaining_conflict_amount: usize, +} + +impl KeybindConflict { + fn from_iter<'a>(mut indices: impl Iterator) -> Option { + indices.next().map(|index| Self { + first_conflict_index: *index, + remaining_conflict_amount: indices.count(), + }) + } +} + #[derive(Default)] struct ConflictState { conflicts: Vec, - action_keybind_mapping: HashMap>, + keybind_mapping: HashMap>, } impl ConflictState { @@ -197,7 +212,7 @@ impl ConflictState { .iter() .enumerate() .filter(|(_, binding)| { - !binding.keystroke_text.is_empty() + binding.keystrokes().is_some() && binding .source .as_ref() @@ -217,27 +232,26 @@ impl ConflictState { .flatten() .copied() .collect(), - action_keybind_mapping, + keybind_mapping: action_keybind_mapping, } } fn conflicting_indices_for_mapping( &self, - action_mapping: ActionMapping, + action_mapping: &ActionMapping, keybind_idx: usize, - ) -> Option> { - self.action_keybind_mapping - .get(&action_mapping) + ) -> Option { + self.keybind_mapping + .get(action_mapping) .and_then(|indices| { - let mut indices = indices.iter().filter(|&idx| *idx != keybind_idx).peekable(); - indices.peek().is_some().then(|| indices.copied().collect()) + KeybindConflict::from_iter(indices.iter().filter(|&idx| *idx != keybind_idx)) }) } - fn will_conflict(&self, action_mapping: ActionMapping) -> Option> { - self.action_keybind_mapping - .get(&action_mapping) - .and_then(|indices| indices.is_empty().not().then_some(indices.clone())) + fn will_conflict(&self, action_mapping: &ActionMapping) -> Option { + self.keybind_mapping + .get(action_mapping) + .and_then(|indices| KeybindConflict::from_iter(indices.iter())) } fn has_conflict(&self, candidate_idx: &usize) -> bool { @@ -267,7 +281,7 @@ struct KeymapEditor { selected_index: Option, context_menu: Option<(Entity, Point, Subscription)>, previous_edit: Option, - humanized_action_names: HashMap<&'static str, SharedString>, + humanized_action_names: HumanizedActionNameCache, show_hover_menus: bool, } @@ -332,14 +346,6 @@ impl KeymapEditor { }) .detach(); - let humanized_action_names = - HashMap::from_iter(cx.all_action_names().into_iter().map(|&action_name| { - ( - action_name, - command_palette::humanize_action_name(action_name).into(), - ) - })); - let mut this = Self { workspace, keybindings: vec![], @@ -356,8 +362,8 @@ impl KeymapEditor { selected_index: None, context_menu: None, previous_edit: None, - humanized_action_names, search_query_debounce: None, + humanized_action_names: HumanizedActionNameCache::new(cx), show_hover_menus: true, }; @@ -383,6 +389,24 @@ impl KeymapEditor { } } + fn filter_on_selected_binding_keystrokes(&mut self, cx: &mut Context) { + let Some(selected_binding) = self.selected_binding() else { + return; + }; + + let keystrokes = selected_binding + .keystrokes() + .map(Vec::from) + .unwrap_or_default(); + + self.filter_state = FilterState::All; + self.search_mode = SearchMode::KeyStroke { exact_match: true }; + + self.keystroke_editor.update(cx, |editor, cx| { + editor.set_keystrokes(keystrokes, cx); + }); + } + fn on_query_changed(&mut self, cx: &mut Context) { let action_query = self.current_action_query(cx); let keystroke_query = self.current_keystroke_query(cx); @@ -523,6 +547,7 @@ impl KeymapEditor { fn process_bindings( json_language: Arc, zed_keybind_context_language: Arc, + humanized_action_names: &HumanizedActionNameCache, cx: &mut App, ) -> (Vec, Vec) { let key_bindings_ptr = cx.key_bindings(); @@ -570,12 +595,14 @@ impl KeymapEditor { let action_docs = action_documentation.get(action_name).copied(); let index = processed_bindings.len(); - let string_match_candidate = StringMatchCandidate::new(index, &action_name); + let humanized_action_name = humanized_action_names.get(action_name); + let string_match_candidate = StringMatchCandidate::new(index, &humanized_action_name); processed_bindings.push(ProcessedKeybinding { keystroke_text: keystroke_text.into(), ui_key_binding, action_name, action_arguments, + humanized_action_name, action_docs, action_schema: action_schema.get(action_name).cloned(), context: Some(context), @@ -587,12 +614,14 @@ impl KeymapEditor { let empty = SharedString::new_static(""); for action_name in unmapped_action_names.into_iter() { let index = processed_bindings.len(); - let string_match_candidate = StringMatchCandidate::new(index, &action_name); + let humanized_action_name = humanized_action_names.get(action_name); + let string_match_candidate = StringMatchCandidate::new(index, &humanized_action_name); processed_bindings.push(ProcessedKeybinding { keystroke_text: empty.clone(), ui_key_binding: None, action_name, action_arguments: None, + humanized_action_name, action_docs: action_documentation.get(action_name).copied(), action_schema: action_schema.get(action_name).cloned(), context: None, @@ -612,15 +641,15 @@ impl KeymapEditor { load_keybind_context_language(workspace.clone(), cx).await; let (action_query, keystroke_query) = this.update(cx, |this, cx| { - let (key_bindings, string_match_candidates) = - Self::process_bindings(json_language, zed_keybind_context_language, cx); + let (key_bindings, string_match_candidates) = Self::process_bindings( + json_language, + zed_keybind_context_language, + &this.humanized_action_names, + cx, + ); this.keybinding_conflict_state = ConflictState::new(&key_bindings); - if !this.keybinding_conflict_state.any_conflicts() { - this.filter_state = FilterState::All; - } - this.keybindings = key_bindings; this.string_match_candidates = Arc::new(string_match_candidates); this.matches = this @@ -751,10 +780,6 @@ impl KeymapEditor { ) { let weak = cx.weak_entity(); self.context_menu = self.selected_binding().map(|selected_binding| { - let key_strokes = selected_binding - .keystrokes() - .map(Vec::from) - .unwrap_or_default(); let selected_binding_has_no_context = selected_binding .context .as_ref() @@ -784,17 +809,9 @@ impl KeymapEditor { Box::new(CopyContext), ) .entry("Show matching keybindings", None, { - let weak = weak.clone(); - let key_strokes = key_strokes.clone(); - move |_, cx| { weak.update(cx, |this, cx| { - this.filter_state = FilterState::All; - this.search_mode = SearchMode::KeyStroke { exact_match: true }; - - this.keystroke_editor.update(cx, |editor, cx| { - editor.set_keystrokes(key_strokes.clone(), cx); - }); + this.filter_on_selected_binding_keystrokes(cx); }) .ok(); } @@ -826,6 +843,24 @@ impl KeymapEditor { self.context_menu.is_some() } + fn render_no_matches_hint(&self, _window: &mut Window, _cx: &App) -> AnyElement { + let hint = match (self.filter_state, &self.search_mode) { + (FilterState::Conflicts, _) => { + if self.keybinding_conflict_state.any_conflicts() { + "No conflicting keybinds found that match the provided query" + } else { + "No conflicting keybinds found" + } + } + (FilterState::All, SearchMode::KeyStroke { .. }) => { + "No keybinds found matching the entered keystrokes" + } + (FilterState::All, SearchMode::Normal) => "No matches found for the provided query", + }; + + Label::new(hint).color(Color::Muted).into_any_element() + } + fn select_next(&mut self, _: &menu::SelectNext, window: &mut Window, cx: &mut Context) { self.show_hover_menus = false; if let Some(selected) = self.selected_index { @@ -1064,11 +1099,35 @@ impl KeymapEditor { } } +struct HumanizedActionNameCache { + cache: HashMap<&'static str, SharedString>, +} + +impl HumanizedActionNameCache { + fn new(cx: &App) -> Self { + let cache = HashMap::from_iter(cx.all_action_names().into_iter().map(|&action_name| { + ( + action_name, + command_palette::humanize_action_name(action_name).into(), + ) + })); + Self { cache } + } + + fn get(&self, action_name: &'static str) -> SharedString { + match self.cache.get(action_name) { + Some(name) => name.clone(), + None => action_name.into(), + } + } +} + #[derive(Clone)] struct ProcessedKeybinding { keystroke_text: SharedString, ui_key_binding: Option, action_name: &'static str, + humanized_action_name: SharedString, action_arguments: Option, action_docs: Option<&'static str>, action_schema: Option, @@ -1079,7 +1138,7 @@ struct ProcessedKeybinding { impl ProcessedKeybinding { fn get_action_mapping(&self) -> ActionMapping { ActionMapping { - keystroke_text: self.keystroke_text.clone(), + keystrokes: self.keystrokes().map(Vec::from).unwrap_or_default(), context: self .context .as_ref() @@ -1223,38 +1282,39 @@ impl Render for KeymapEditor { window.dispatch_action(ToggleKeystrokeSearch.boxed_clone(), cx); }), ) - .when(self.keybinding_conflict_state.any_conflicts(), |this| { - this.child( - IconButton::new("KeymapEditorConflictIcon", IconName::Warning) - .shape(ui::IconButtonShape::Square) - .tooltip({ - let filter_state = self.filter_state; + .child( + IconButton::new("KeymapEditorConflictIcon", IconName::Warning) + .shape(ui::IconButtonShape::Square) + .when(self.keybinding_conflict_state.any_conflicts(), |this| { + this.indicator(Indicator::dot().color(Color::Warning)) + }) + .tooltip({ + let filter_state = self.filter_state; - move |window, cx| { - Tooltip::for_action( - match filter_state { - FilterState::All => "Show Conflicts", - FilterState::Conflicts => "Hide Conflicts", - }, - &ToggleConflictFilter, - window, - cx, - ) - } - }) - .selected_icon_color(Color::Warning) - .toggle_state(matches!( - self.filter_state, - FilterState::Conflicts - )) - .on_click(|_, window, cx| { - window.dispatch_action( - ToggleConflictFilter.boxed_clone(), + move |window, cx| { + Tooltip::for_action( + match filter_state { + FilterState::All => "Show Conflicts", + FilterState::Conflicts => "Hide Conflicts", + }, + &ToggleConflictFilter, + window, cx, - ); - }), - ) - }), + ) + } + }) + .selected_icon_color(Color::Warning) + .toggle_state(matches!( + self.filter_state, + FilterState::Conflicts + )) + .on_click(|_, window, cx| { + window.dispatch_action( + ToggleConflictFilter.boxed_clone(), + cx, + ); + }), + ), ) .when_some( match self.search_mode { @@ -1310,13 +1370,17 @@ impl Render for KeymapEditor { Table::new() .interactable(&self.table_interaction_state) .striped() + .empty_table_callback({ + let this = cx.entity(); + move |window, cx| this.read(cx).render_no_matches_hint(window, cx) + }) .column_widths([ - rems(2.5), - rems(16.), - rems(16.), - rems(16.), - rems(32.), - rems(8.), + DefiniteLength::Absolute(AbsoluteLength::Pixels(px(40.))), + DefiniteLength::Fraction(0.25), + DefiniteLength::Fraction(0.20), + DefiniteLength::Fraction(0.14), + DefiniteLength::Fraction(0.45), + DefiniteLength::Fraction(0.08), ]) .header(["", "Action", "Arguments", "Keystrokes", "Context", "Source"]) .uniform_list( @@ -1393,10 +1457,9 @@ impl Render for KeymapEditor { .id(("keymap action", index)) .child({ if action_name != gpui::NoAction.name() { - this.humanized_action_names - .get(action_name) - .cloned() - .unwrap_or(action_name.into()) + binding + .humanized_action_name + .clone() .into_any_element() } else { const NULL: SharedString = @@ -1606,7 +1669,7 @@ impl RenderOnce for SyntaxHighlightedText { runs.push(text_style.to_run(text.len() - offset)); } - return StyledText::new(text).with_runs(runs); + StyledText::new(text).with_runs(runs) } } @@ -1621,8 +1684,8 @@ impl InputError { Self::Warning(message.into()) } - fn error(message: impl Into) -> Self { - Self::Error(message.into()) + fn error(error: anyhow::Error) -> Self { + Self::Error(error.to_string().into()) } fn content(&self) -> &SharedString { @@ -1630,10 +1693,6 @@ impl InputError { InputError::Warning(content) | InputError::Error(content) => content, } } - - fn is_warning(&self) -> bool { - matches!(self, InputError::Warning(_)) - } } struct KeybindingEditorModal { @@ -1766,17 +1825,14 @@ impl KeybindingEditorModal { } } - fn set_error(&mut self, error: InputError, cx: &mut Context) -> bool { + fn set_error(&mut self, error: InputError, cx: &mut Context) { if self .error .as_ref() - .is_some_and(|old_error| old_error.is_warning() && *old_error == error) + .is_none_or(|old_error| *old_error != error) { - false - } else { self.error = Some(error); cx.notify(); - true } } @@ -1818,66 +1874,62 @@ impl KeybindingEditorModal { Ok(Some(context)) } - fn save(&mut self, cx: &mut Context) { + fn save_or_display_error(&mut self, cx: &mut Context) { + self.save(cx).map_err(|err| self.set_error(err, cx)).ok(); + } + + fn save(&mut self, cx: &mut Context) -> Result<(), InputError> { let existing_keybind = self.editing_keybind.clone(); let fs = self.fs.clone(); let tab_size = cx.global::().json_tab_size(); - let new_keystrokes = match self.validate_keystrokes(cx) { - Err(err) => { - self.set_error(InputError::error(err.to_string()), cx); - return; - } - Ok(keystrokes) => keystrokes, - }; - let new_context = match self.validate_context(cx) { - Err(err) => { - self.set_error(InputError::error(err.to_string()), cx); - return; - } - Ok(context) => context, - }; + let new_keystrokes = self + .validate_keystrokes(cx) + .map_err(InputError::error)? + .into_iter() + .map(remove_key_char) + .collect::>(); - let new_action_args = match self.validate_action_arguments(cx) { - Err(input_err) => { - self.set_error(InputError::error(input_err.to_string()), cx); - return; - } - Ok(input) => input, - }; + let new_context = self.validate_context(cx).map_err(InputError::error)?; + let new_action_args = self + .validate_action_arguments(cx) + .map_err(InputError::error)?; let action_mapping = ActionMapping { - keystroke_text: ui::text_for_keystrokes(&new_keystrokes, cx).into(), - context: new_context.as_ref().map(Into::into), + keystrokes: new_keystrokes, + context: new_context.map(SharedString::from), }; let conflicting_indices = if self.creating { self.keymap_editor .read(cx) .keybinding_conflict_state - .will_conflict(action_mapping) + .will_conflict(&action_mapping) } else { self.keymap_editor .read(cx) .keybinding_conflict_state - .conflicting_indices_for_mapping(action_mapping, self.editing_keybind_idx) + .conflicting_indices_for_mapping(&action_mapping, self.editing_keybind_idx) }; - if let Some(conflicting_indices) = conflicting_indices { - let first_conflicting_index = conflicting_indices[0]; + + conflicting_indices.map(|KeybindConflict { + first_conflict_index, + remaining_conflict_amount, + }| + { let conflicting_action_name = self .keymap_editor .read(cx) .keybindings - .get(first_conflicting_index) + .get(first_conflict_index) .map(|keybind| keybind.action_name); let warning_message = match conflicting_action_name { Some(name) => { - let confliction_action_amount = conflicting_indices.len() - 1; - if confliction_action_amount > 0 { + if remaining_conflict_amount > 0 { format!( "Your keybind would conflict with the \"{}\" action and {} other bindings", - name, confliction_action_amount + name, remaining_conflict_amount ) } else { format!("Your keybind would conflict with the \"{}\" action", name) @@ -1886,23 +1938,26 @@ impl KeybindingEditorModal { None => { log::info!( "Could not find action in keybindings with index {}", - first_conflicting_index + first_conflict_index ); "Your keybind would conflict with other actions".to_string() } }; - if self.set_error(InputError::warning(warning_message), cx) { - return; + let warning = InputError::warning(warning_message); + if self.error.as_ref().is_some_and(|old_error| *old_error == warning) { + Ok(()) + } else { + Err(warning) } - } + }).unwrap_or(Ok(()))?; let create = self.creating; let status_toast = StatusToast::new( format!( "Saved edits to the {} action.", - command_palette::humanize_action_name(&self.editing_keybind.action_name) + &self.editing_keybind.humanized_action_name ), cx, move |this, _cx| { @@ -1924,8 +1979,7 @@ impl KeybindingEditorModal { if let Err(err) = save_keybinding_update( create, existing_keybind, - &new_keystrokes, - new_context.as_deref(), + &action_mapping, new_action_args.as_deref(), &fs, tab_size, @@ -1933,17 +1987,11 @@ impl KeybindingEditorModal { .await { this.update(cx, |this, cx| { - this.set_error(InputError::error(err.to_string()), cx); + this.set_error(InputError::error(err), cx); }) .log_err(); } else { this.update(cx, |this, cx| { - let action_mapping = ActionMapping { - keystroke_text: ui::text_for_keystrokes(new_keystrokes.as_slice(), cx) - .into(), - context: new_context.map(SharedString::from), - }; - this.keymap_editor.update(cx, |keymap, cx| { keymap.previous_edit = Some(PreviousEdit::Keybinding { action_mapping, @@ -1960,6 +2008,8 @@ impl KeybindingEditorModal { } }) .detach(); + + Ok(()) } fn key_context(&self) -> KeyContext { @@ -1982,7 +2032,7 @@ impl KeybindingEditorModal { } fn confirm(&mut self, _: &menu::Confirm, _window: &mut Window, cx: &mut Context) { - self.save(cx); + self.save_or_display_error(cx); } fn cancel(&mut self, _: &menu::Cancel, _window: &mut Window, cx: &mut Context) { @@ -1990,11 +2040,17 @@ impl KeybindingEditorModal { } } +fn remove_key_char(Keystroke { modifiers, key, .. }: Keystroke) -> Keystroke { + Keystroke { + modifiers, + key, + ..Default::default() + } +} + impl Render for KeybindingEditorModal { fn render(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement { let theme = cx.theme().colors(); - let action_name = - command_palette::humanize_action_name(&self.editing_keybind.action_name).to_string(); v_flex() .w(rems(34.)) @@ -2014,7 +2070,9 @@ impl Render for KeybindingEditorModal { .gap_0p5() .border_b_1() .border_color(theme.border_variant) - .child(Label::new(action_name)) + .child(Label::new( + self.editing_keybind.humanized_action_name.clone(), + )) .when_some(self.editing_keybind.action_docs, |this, docs| { this.child( Label::new(docs).size(LabelSize::Small).color(Color::Muted), @@ -2085,7 +2143,7 @@ impl Render for KeybindingEditorModal { ) .child(Button::new("save-btn", "Save").on_click(cx.listener( |this, _event, _window, cx| { - this.save(cx); + this.save_or_display_error(cx); }, ))), ), @@ -2273,8 +2331,7 @@ async fn load_keybind_context_language( async fn save_keybinding_update( create: bool, existing: ProcessedKeybinding, - new_keystrokes: &[Keystroke], - new_context: Option<&str>, + action_mapping: &ActionMapping, new_args: Option<&str>, fs: &Arc, tab_size: usize, @@ -2301,8 +2358,8 @@ async fn save_keybinding_update( }; let source = settings::KeybindUpdateTarget { - context: new_context, - keystrokes: new_keystrokes, + context: action_mapping.context.as_ref().map(|a| &***a), + keystrokes: &action_mapping.keystrokes, action_name: &existing.action_name, action_arguments: new_args, }; @@ -2772,7 +2829,7 @@ impl Render for KeystrokeInput { IconName::PlayFilled }; - return h_flex() + h_flex() .id("keystroke-input") .track_focus(&self.outer_focus_handle) .py_2() @@ -2895,7 +2952,7 @@ impl Render for KeystrokeInput { this.clear_keystrokes(&ClearKeystrokes, window, cx); })), ), - ); + ) } } diff --git a/crates/settings_ui/src/ui_components/table.rs b/crates/settings_ui/src/ui_components/table.rs index 98dd738765..6ea59cd2f4 100644 --- a/crates/settings_ui/src/ui_components/table.rs +++ b/crates/settings_ui/src/ui_components/table.rs @@ -40,6 +40,10 @@ impl TableContents { TableContents::UniformList(data) => data.row_count, } } + + fn is_empty(&self) -> bool { + self.len() == 0 + } } pub struct TableInteractionState { @@ -375,6 +379,7 @@ pub struct Table { interaction_state: Option>, column_widths: Option<[Length; COLS]>, map_row: Option AnyElement>>, + empty_table_callback: Option AnyElement>>, } impl Table { @@ -388,6 +393,7 @@ impl Table { interaction_state: None, column_widths: None, map_row: None, + empty_table_callback: None, } } @@ -460,6 +466,15 @@ impl Table { self.map_row = Some(Rc::new(callback)); self } + + /// Provide a callback that is invoked when the table is rendered without any rows + pub fn empty_table_callback( + mut self, + callback: impl Fn(&mut Window, &mut App) -> AnyElement + 'static, + ) -> Self { + self.empty_table_callback = Some(Rc::new(callback)); + self + } } fn base_cell_style(width: Option, cx: &App) -> Div { @@ -582,6 +597,7 @@ impl RenderOnce for Table { }; let width = self.width; + let no_rows_rendered = self.rows.is_empty(); let table = div() .when_some(width, |this, width| this.w(width)) @@ -662,6 +678,21 @@ impl RenderOnce for Table { }) }), ) + .when_some( + no_rows_rendered + .then_some(self.empty_table_callback) + .flatten(), + |this, callback| { + this.child( + h_flex() + .size_full() + .p_3() + .items_start() + .justify_center() + .child(callback(window, cx)), + ) + }, + ) .when_some( width.and(interaction_state.as_ref()), |this, interaction_state| { From d470411725d8de6f1129d3b9ddd322b6eaf50e42 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 17 Jul 2025 18:12:48 -0400 Subject: [PATCH 0037/1052] Improve upstream error reporting (#34668) Now we handle more upstream error cases using the same auto-retry logic. Release Notes: - N/A --- crates/agent/src/thread.rs | 29 +++ crates/agent_ui/src/active_thread.rs | 2 +- .../assistant_tools/src/edit_agent/evals.rs | 25 +++ crates/language_model/src/language_model.rs | 6 + crates/language_models/src/provider/cloud.rs | 206 ++++++++++++++++++ 5 files changed, 267 insertions(+), 1 deletion(-) diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs index dca0f5a430..54cc6296d5 100644 --- a/crates/agent/src/thread.rs +++ b/crates/agent/src/thread.rs @@ -2146,6 +2146,35 @@ impl Thread { max_attempts: MAX_RETRY_ATTEMPTS, }) } + UpstreamProviderError { + status, + retry_after, + .. + } => match *status { + StatusCode::TOO_MANY_REQUESTS | StatusCode::SERVICE_UNAVAILABLE => { + Some(RetryStrategy::Fixed { + delay: retry_after.unwrap_or(BASE_RETRY_DELAY), + max_attempts: MAX_RETRY_ATTEMPTS, + }) + } + StatusCode::INTERNAL_SERVER_ERROR => Some(RetryStrategy::Fixed { + delay: retry_after.unwrap_or(BASE_RETRY_DELAY), + // Internal Server Error could be anything, so only retry once. + max_attempts: 1, + }), + status => { + // There is no StatusCode variant for the unofficial HTTP 529 ("The service is overloaded"), + // but we frequently get them in practice. See https://http.dev/529 + if status.as_u16() == 529 { + Some(RetryStrategy::Fixed { + delay: retry_after.unwrap_or(BASE_RETRY_DELAY), + max_attempts: MAX_RETRY_ATTEMPTS, + }) + } else { + None + } + } + }, ApiInternalServerError { .. } => Some(RetryStrategy::Fixed { delay: BASE_RETRY_DELAY, max_attempts: 1, diff --git a/crates/agent_ui/src/active_thread.rs b/crates/agent_ui/src/active_thread.rs index 3cf68b887d..f5f6952519 100644 --- a/crates/agent_ui/src/active_thread.rs +++ b/crates/agent_ui/src/active_thread.rs @@ -1036,7 +1036,7 @@ impl ActiveThread { .collect::>() .join("\n"); self.last_error = Some(ThreadError::Message { - header: "Error interacting with language model".into(), + header: "Error".into(), message: error_message.into(), }); } diff --git a/crates/assistant_tools/src/edit_agent/evals.rs b/crates/assistant_tools/src/edit_agent/evals.rs index c7af7dc64e..eda7eee0e3 100644 --- a/crates/assistant_tools/src/edit_agent/evals.rs +++ b/crates/assistant_tools/src/edit_agent/evals.rs @@ -12,6 +12,7 @@ use collections::HashMap; use fs::FakeFs; use futures::{FutureExt, future::LocalBoxFuture}; use gpui::{AppContext, TestAppContext, Timer}; +use http_client::StatusCode; use indoc::{formatdoc, indoc}; use language_model::{ LanguageModelRegistry, LanguageModelRequestTool, LanguageModelToolResult, @@ -1675,6 +1676,30 @@ async fn retry_on_rate_limit(mut request: impl AsyncFnMut() -> Result) -> Timer::after(retry_after + jitter).await; continue; } + LanguageModelCompletionError::UpstreamProviderError { + status, + retry_after, + .. + } => { + // Only retry for specific status codes + let should_retry = matches!( + *status, + StatusCode::TOO_MANY_REQUESTS | StatusCode::SERVICE_UNAVAILABLE + ) || status.as_u16() == 529; + + if !should_retry { + return Err(err.into()); + } + + // Use server-provided retry_after if available, otherwise use default + let retry_after = retry_after.unwrap_or(Duration::from_secs(5)); + let jitter = retry_after.mul_f64(rand::thread_rng().gen_range(0.0..1.0)); + eprintln!( + "Attempt #{attempt}: {err}. Retry after {retry_after:?} + jitter of {jitter:?}" + ); + Timer::after(retry_after + jitter).await; + continue; + } _ => return Err(err.into()), }, Err(err) => return Err(err), diff --git a/crates/language_model/src/language_model.rs b/crates/language_model/src/language_model.rs index 8962e9d8d1..6bd33fcdf5 100644 --- a/crates/language_model/src/language_model.rs +++ b/crates/language_model/src/language_model.rs @@ -116,6 +116,12 @@ pub enum LanguageModelCompletionError { provider: LanguageModelProviderName, message: String, }, + #[error("{message}")] + UpstreamProviderError { + message: String, + status: StatusCode, + retry_after: Option, + }, #[error("HTTP response error from {provider}'s API: status {status_code} - {message:?}")] HttpResponseError { provider: LanguageModelProviderName, diff --git a/crates/language_models/src/provider/cloud.rs b/crates/language_models/src/provider/cloud.rs index c044a318b8..6aea576258 100644 --- a/crates/language_models/src/provider/cloud.rs +++ b/crates/language_models/src/provider/cloud.rs @@ -644,8 +644,62 @@ struct ApiError { headers: HeaderMap, } +/// Represents error responses from Zed's cloud API. +/// +/// Example JSON for an upstream HTTP error: +/// ```json +/// { +/// "code": "upstream_http_error", +/// "message": "Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers, reset reason: connection timeout", +/// "upstream_status": 503 +/// } +/// ``` +#[derive(Debug, serde::Deserialize)] +struct CloudApiError { + code: String, + message: String, + #[serde(default)] + #[serde(deserialize_with = "deserialize_optional_status_code")] + upstream_status: Option, + #[serde(default)] + retry_after: Option, +} + +fn deserialize_optional_status_code<'de, D>(deserializer: D) -> Result, D::Error> +where + D: serde::Deserializer<'de>, +{ + let opt: Option = Option::deserialize(deserializer)?; + Ok(opt.and_then(|code| StatusCode::from_u16(code).ok())) +} + impl From for LanguageModelCompletionError { fn from(error: ApiError) -> Self { + if let Ok(cloud_error) = serde_json::from_str::(&error.body) { + if cloud_error.code.starts_with("upstream_http_") { + let status = if let Some(status) = cloud_error.upstream_status { + status + } else if cloud_error.code.ends_with("_error") { + error.status + } else { + // If there's a status code in the code string (e.g. "upstream_http_429") + // then use that; otherwise, see if the JSON contains a status code. + cloud_error + .code + .strip_prefix("upstream_http_") + .and_then(|code_str| code_str.parse::().ok()) + .and_then(|code| StatusCode::from_u16(code).ok()) + .unwrap_or(error.status) + }; + + return LanguageModelCompletionError::UpstreamProviderError { + message: cloud_error.message, + status, + retry_after: cloud_error.retry_after.map(Duration::from_secs_f64), + }; + } + } + let retry_after = None; LanguageModelCompletionError::from_http_status( PROVIDER_NAME, @@ -1279,3 +1333,155 @@ impl Component for ZedAiConfiguration { ) } } + +#[cfg(test)] +mod tests { + use super::*; + use http_client::http::{HeaderMap, StatusCode}; + use language_model::LanguageModelCompletionError; + + #[test] + fn test_api_error_conversion_with_upstream_http_error() { + // upstream_http_error with 503 status should become ServerOverloaded + let error_body = r#"{"code":"upstream_http_error","message":"Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers, reset reason: connection timeout","upstream_status":503}"#; + + let api_error = ApiError { + status: StatusCode::INTERNAL_SERVER_ERROR, + body: error_body.to_string(), + headers: HeaderMap::new(), + }; + + let completion_error: LanguageModelCompletionError = api_error.into(); + + match completion_error { + LanguageModelCompletionError::UpstreamProviderError { message, .. } => { + assert_eq!( + message, + "Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers, reset reason: connection timeout" + ); + } + _ => panic!( + "Expected UpstreamProviderError for upstream 503, got: {:?}", + completion_error + ), + } + + // upstream_http_error with 500 status should become ApiInternalServerError + let error_body = r#"{"code":"upstream_http_error","message":"Received an error from the OpenAI API: internal server error","upstream_status":500}"#; + + let api_error = ApiError { + status: StatusCode::INTERNAL_SERVER_ERROR, + body: error_body.to_string(), + headers: HeaderMap::new(), + }; + + let completion_error: LanguageModelCompletionError = api_error.into(); + + match completion_error { + LanguageModelCompletionError::UpstreamProviderError { message, .. } => { + assert_eq!( + message, + "Received an error from the OpenAI API: internal server error" + ); + } + _ => panic!( + "Expected UpstreamProviderError for upstream 500, got: {:?}", + completion_error + ), + } + + // upstream_http_error with 429 status should become RateLimitExceeded + let error_body = r#"{"code":"upstream_http_error","message":"Received an error from the Google API: rate limit exceeded","upstream_status":429}"#; + + let api_error = ApiError { + status: StatusCode::INTERNAL_SERVER_ERROR, + body: error_body.to_string(), + headers: HeaderMap::new(), + }; + + let completion_error: LanguageModelCompletionError = api_error.into(); + + match completion_error { + LanguageModelCompletionError::UpstreamProviderError { message, .. } => { + assert_eq!( + message, + "Received an error from the Google API: rate limit exceeded" + ); + } + _ => panic!( + "Expected UpstreamProviderError for upstream 429, got: {:?}", + completion_error + ), + } + + // Regular 500 error without upstream_http_error should remain ApiInternalServerError for Zed + let error_body = "Regular internal server error"; + + let api_error = ApiError { + status: StatusCode::INTERNAL_SERVER_ERROR, + body: error_body.to_string(), + headers: HeaderMap::new(), + }; + + let completion_error: LanguageModelCompletionError = api_error.into(); + + match completion_error { + LanguageModelCompletionError::ApiInternalServerError { provider, message } => { + assert_eq!(provider, PROVIDER_NAME); + assert_eq!(message, "Regular internal server error"); + } + _ => panic!( + "Expected ApiInternalServerError for regular 500, got: {:?}", + completion_error + ), + } + + // upstream_http_429 format should be converted to UpstreamProviderError + let error_body = r#"{"code":"upstream_http_429","message":"Upstream Anthropic rate limit exceeded.","retry_after":30.5}"#; + + let api_error = ApiError { + status: StatusCode::INTERNAL_SERVER_ERROR, + body: error_body.to_string(), + headers: HeaderMap::new(), + }; + + let completion_error: LanguageModelCompletionError = api_error.into(); + + match completion_error { + LanguageModelCompletionError::UpstreamProviderError { + message, + status, + retry_after, + } => { + assert_eq!(message, "Upstream Anthropic rate limit exceeded."); + assert_eq!(status, StatusCode::TOO_MANY_REQUESTS); + assert_eq!(retry_after, Some(Duration::from_secs_f64(30.5))); + } + _ => panic!( + "Expected UpstreamProviderError for upstream_http_429, got: {:?}", + completion_error + ), + } + + // Invalid JSON in error body should fall back to regular error handling + let error_body = "Not JSON at all"; + + let api_error = ApiError { + status: StatusCode::INTERNAL_SERVER_ERROR, + body: error_body.to_string(), + headers: HeaderMap::new(), + }; + + let completion_error: LanguageModelCompletionError = api_error.into(); + + match completion_error { + LanguageModelCompletionError::ApiInternalServerError { provider, .. } => { + assert_eq!(provider, PROVIDER_NAME); + } + _ => panic!( + "Expected ApiInternalServerError for invalid JSON, got: {:?}", + completion_error + ), + } + } +} From 1ab659c71fc8b12ab37c96dafec546d3afb744ea Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 17 Jul 2025 19:04:03 -0400 Subject: [PATCH 0038/1052] Retry on burn mode (#34669) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Now we only auto-retry if burn mode is enabled. We also show a "Retry" button (so you don't have to type "continue") if you think that's the right remedy, and additionally we show a "Retry and Enable Burn Mode" button if you don't have it enabled. Screenshot 2025-07-17 at 6 25 27 PM Screenshot 2025-07-17 at 6 22 36 PM Release Notes: - Only auto-retry Agent requests when Burn Mode is enabled --- crates/agent/src/thread.rs | 200 ++++++++++++++++++++++++++++- crates/agent_ui/src/agent_panel.rs | 92 ++++++++++++- 2 files changed, 285 insertions(+), 7 deletions(-) diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs index 54cc6296d5..180cc88390 100644 --- a/crates/agent/src/thread.rs +++ b/crates/agent/src/thread.rs @@ -396,6 +396,7 @@ pub struct Thread { remaining_turns: u32, configured_model: Option, profile: AgentProfile, + last_error_context: Option<(Arc, CompletionIntent)>, } #[derive(Clone, Debug)] @@ -489,10 +490,11 @@ impl Thread { retry_state: None, message_feedback: HashMap::default(), last_auto_capture_at: None, + last_error_context: None, last_received_chunk_at: None, request_callback: None, remaining_turns: u32::MAX, - configured_model, + configured_model: configured_model.clone(), profile: AgentProfile::new(profile_id, tools), } } @@ -613,6 +615,7 @@ impl Thread { feedback: None, message_feedback: HashMap::default(), last_auto_capture_at: None, + last_error_context: None, last_received_chunk_at: None, request_callback: None, remaining_turns: u32::MAX, @@ -1264,9 +1267,58 @@ impl Thread { self.flush_notifications(model.clone(), intent, cx); - let request = self.to_completion_request(model.clone(), intent, cx); + let _checkpoint = self.finalize_pending_checkpoint(cx); + self.stream_completion( + self.to_completion_request(model.clone(), intent, cx), + model, + intent, + window, + cx, + ); + } - self.stream_completion(request, model, intent, window, cx); + pub fn retry_last_completion( + &mut self, + window: Option, + cx: &mut Context, + ) { + // Clear any existing error state + self.retry_state = None; + + // Use the last error context if available, otherwise fall back to configured model + let (model, intent) = if let Some((model, intent)) = self.last_error_context.take() { + (model, intent) + } else if let Some(configured_model) = self.configured_model.as_ref() { + let model = configured_model.model.clone(); + let intent = if self.has_pending_tool_uses() { + CompletionIntent::ToolResults + } else { + CompletionIntent::UserPrompt + }; + (model, intent) + } else if let Some(configured_model) = self.get_or_init_configured_model(cx) { + let model = configured_model.model.clone(); + let intent = if self.has_pending_tool_uses() { + CompletionIntent::ToolResults + } else { + CompletionIntent::UserPrompt + }; + (model, intent) + } else { + return; + }; + + self.send_to_model(model, intent, window, cx); + } + + pub fn enable_burn_mode_and_retry( + &mut self, + window: Option, + cx: &mut Context, + ) { + self.completion_mode = CompletionMode::Burn; + cx.emit(ThreadEvent::ProfileChanged); + self.retry_last_completion(window, cx); } pub fn used_tools_since_last_user_message(&self) -> bool { @@ -2222,6 +2274,23 @@ impl Thread { window: Option, cx: &mut Context, ) -> bool { + // Store context for the Retry button + self.last_error_context = Some((model.clone(), intent)); + + // Only auto-retry if Burn Mode is enabled + if self.completion_mode != CompletionMode::Burn { + // Show error with retry options + cx.emit(ThreadEvent::ShowError(ThreadError::RetryableError { + message: format!( + "{}\n\nTo automatically retry when similar errors happen, enable Burn Mode.", + error + ) + .into(), + can_enable_burn_mode: true, + })); + return false; + } + let Some(strategy) = strategy.or_else(|| Self::get_retry_strategy(error)) else { return false; }; @@ -2302,6 +2371,13 @@ impl Thread { // Stop generating since we're giving up on retrying. self.pending_completions.clear(); + // Show error alongside a Retry button, but no + // Enable Burn Mode button (since it's already enabled) + cx.emit(ThreadEvent::ShowError(ThreadError::RetryableError { + message: format!("Failed after retrying: {}", error).into(), + can_enable_burn_mode: false, + })); + false } } @@ -3212,6 +3288,11 @@ pub enum ThreadError { header: SharedString, message: SharedString, }, + #[error("Retryable error: {message}")] + RetryableError { + message: SharedString, + can_enable_burn_mode: bool, + }, } #[derive(Debug, Clone)] @@ -4167,6 +4248,11 @@ fn main() {{ let project = create_test_project(cx, json!({})).await; let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await; + // Enable Burn Mode to allow retries + thread.update(cx, |thread, _| { + thread.set_completion_mode(CompletionMode::Burn); + }); + // Create model that returns overloaded error let model = Arc::new(ErrorInjector::new(TestError::Overloaded)); @@ -4240,6 +4326,11 @@ fn main() {{ let project = create_test_project(cx, json!({})).await; let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await; + // Enable Burn Mode to allow retries + thread.update(cx, |thread, _| { + thread.set_completion_mode(CompletionMode::Burn); + }); + // Create model that returns internal server error let model = Arc::new(ErrorInjector::new(TestError::InternalServerError)); @@ -4316,6 +4407,11 @@ fn main() {{ let project = create_test_project(cx, json!({})).await; let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await; + // Enable Burn Mode to allow retries + thread.update(cx, |thread, _| { + thread.set_completion_mode(CompletionMode::Burn); + }); + // Create model that returns internal server error let model = Arc::new(ErrorInjector::new(TestError::InternalServerError)); @@ -4423,6 +4519,11 @@ fn main() {{ let project = create_test_project(cx, json!({})).await; let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await; + // Enable Burn Mode to allow retries + thread.update(cx, |thread, _| { + thread.set_completion_mode(CompletionMode::Burn); + }); + // Create model that returns overloaded error let model = Arc::new(ErrorInjector::new(TestError::Overloaded)); @@ -4509,6 +4610,11 @@ fn main() {{ let project = create_test_project(cx, json!({})).await; let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await; + // Enable Burn Mode to allow retries + thread.update(cx, |thread, _| { + thread.set_completion_mode(CompletionMode::Burn); + }); + // We'll use a wrapper to switch behavior after first failure struct RetryTestModel { inner: Arc, @@ -4677,6 +4783,11 @@ fn main() {{ let project = create_test_project(cx, json!({})).await; let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await; + // Enable Burn Mode to allow retries + thread.update(cx, |thread, _| { + thread.set_completion_mode(CompletionMode::Burn); + }); + // Create a model that fails once then succeeds struct FailOnceModel { inner: Arc, @@ -4838,6 +4949,11 @@ fn main() {{ let project = create_test_project(cx, json!({})).await; let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await; + // Enable Burn Mode to allow retries + thread.update(cx, |thread, _| { + thread.set_completion_mode(CompletionMode::Burn); + }); + // Create a model that returns rate limit error with retry_after struct RateLimitModel { inner: Arc, @@ -5111,6 +5227,79 @@ fn main() {{ ); } + #[gpui::test] + async fn test_no_retry_without_burn_mode(cx: &mut TestAppContext) { + init_test_settings(cx); + + let project = create_test_project(cx, json!({})).await; + let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await; + + // Ensure we're in Normal mode (not Burn mode) + thread.update(cx, |thread, _| { + thread.set_completion_mode(CompletionMode::Normal); + }); + + // Track error events + let error_events = Arc::new(Mutex::new(Vec::new())); + let error_events_clone = error_events.clone(); + + let _subscription = thread.update(cx, |_, cx| { + cx.subscribe(&thread, move |_, _, event: &ThreadEvent, _| { + if let ThreadEvent::ShowError(error) = event { + error_events_clone.lock().push(error.clone()); + } + }) + }); + + // Create model that returns overloaded error + let model = Arc::new(ErrorInjector::new(TestError::Overloaded)); + + // Insert a user message + thread.update(cx, |thread, cx| { + thread.insert_user_message("Hello!", ContextLoadResult::default(), None, vec![], cx); + }); + + // Start completion + thread.update(cx, |thread, cx| { + thread.send_to_model(model.clone(), CompletionIntent::UserPrompt, None, cx); + }); + + cx.run_until_parked(); + + // Verify no retry state was created + thread.read_with(cx, |thread, _| { + assert!( + thread.retry_state.is_none(), + "Should not have retry state in Normal mode" + ); + }); + + // Check that a retryable error was reported + let errors = error_events.lock(); + assert!(!errors.is_empty(), "Should have received an error event"); + + if let ThreadError::RetryableError { + message: _, + can_enable_burn_mode, + } = &errors[0] + { + assert!( + *can_enable_burn_mode, + "Error should indicate burn mode can be enabled" + ); + } else { + panic!("Expected RetryableError, got {:?}", errors[0]); + } + + // Verify the thread is no longer generating + thread.read_with(cx, |thread, _| { + assert!( + !thread.is_generating(), + "Should not be generating after error without retry" + ); + }); + } + #[gpui::test] async fn test_retry_cancelled_on_stop(cx: &mut TestAppContext) { init_test_settings(cx); @@ -5118,6 +5307,11 @@ fn main() {{ let project = create_test_project(cx, json!({})).await; let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await; + // Enable Burn Mode to allow retries + thread.update(cx, |thread, _| { + thread.set_completion_mode(CompletionMode::Burn); + }); + // Create model that returns overloaded error let model = Arc::new(ErrorInjector::new(TestError::Overloaded)); diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 895a499502..139e32f835 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -65,8 +65,9 @@ use theme::ThemeSettings; use time::UtcOffset; use ui::utils::WithRemSize; use ui::{ - Banner, Callout, CheckboxWithLabel, ContextMenu, ElevationIndex, KeyBinding, PopoverMenu, - PopoverMenuHandle, ProgressBar, Tab, Tooltip, Vector, VectorName, prelude::*, + Banner, Button, Callout, CheckboxWithLabel, ContextMenu, ElevationIndex, IconPosition, + KeyBinding, PopoverMenu, PopoverMenuHandle, ProgressBar, Tab, Tooltip, Vector, VectorName, + prelude::*, }; use util::ResultExt as _; use workspace::{ @@ -2977,6 +2978,21 @@ impl AgentPanel { .size(IconSize::Small) .color(Color::Error); + let retry_button = Button::new("retry", "Retry") + .icon(IconName::RotateCw) + .icon_position(IconPosition::Start) + .on_click({ + let thread = thread.clone(); + move |_, window, cx| { + thread.update(cx, |thread, cx| { + thread.clear_last_error(); + thread.thread().update(cx, |thread, cx| { + thread.retry_last_completion(Some(window.window_handle()), cx); + }); + }); + } + }); + div() .border_t_1() .border_color(cx.theme().colors().border) @@ -2985,13 +3001,72 @@ impl AgentPanel { .icon(icon) .title(header) .description(message.clone()) - .primary_action(self.dismiss_error_button(thread, cx)) - .secondary_action(self.create_copy_button(message_with_header)) + .primary_action(retry_button) + .secondary_action(self.dismiss_error_button(thread, cx)) + .tertiary_action(self.create_copy_button(message_with_header)) .bg_color(self.error_callout_bg(cx)), ) .into_any_element() } + fn render_retryable_error( + &self, + message: SharedString, + can_enable_burn_mode: bool, + thread: &Entity, + cx: &mut Context, + ) -> AnyElement { + let icon = Icon::new(IconName::XCircle) + .size(IconSize::Small) + .color(Color::Error); + + let retry_button = Button::new("retry", "Retry") + .icon(IconName::RotateCw) + .icon_position(IconPosition::Start) + .on_click({ + let thread = thread.clone(); + move |_, window, cx| { + thread.update(cx, |thread, cx| { + thread.clear_last_error(); + thread.thread().update(cx, |thread, cx| { + thread.retry_last_completion(Some(window.window_handle()), cx); + }); + }); + } + }); + + let mut callout = Callout::new() + .icon(icon) + .title("Error") + .description(message.clone()) + .bg_color(self.error_callout_bg(cx)) + .primary_action(retry_button); + + if can_enable_burn_mode { + let burn_mode_button = Button::new("enable_burn_retry", "Enable Burn Mode and Retry") + .icon(IconName::ZedBurnMode) + .icon_position(IconPosition::Start) + .on_click({ + let thread = thread.clone(); + move |_, window, cx| { + thread.update(cx, |thread, cx| { + thread.clear_last_error(); + thread.thread().update(cx, |thread, cx| { + thread.enable_burn_mode_and_retry(Some(window.window_handle()), cx); + }); + }); + } + }); + callout = callout.secondary_action(burn_mode_button); + } + + div() + .border_t_1() + .border_color(cx.theme().colors().border) + .child(callout) + .into_any_element() + } + fn render_prompt_editor( &self, context_editor: &Entity, @@ -3233,6 +3308,15 @@ impl Render for AgentPanel { ThreadError::Message { header, message } => { self.render_error_message(header, message, thread, cx) } + ThreadError::RetryableError { + message, + can_enable_burn_mode, + } => self.render_retryable_error( + message, + can_enable_burn_mode, + thread, + cx, + ), }) .into_any(), ) From f0a91502a925d74491083bd126690b6f730fbdf1 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Thu, 17 Jul 2025 20:22:21 -0300 Subject: [PATCH 0039/1052] keymap_ui: Add some design refinements (#34673) Mostly small stuff over here. Release Notes: - N/A --- crates/settings_ui/src/keybindings.rs | 91 +++++++++++++++------------ 1 file changed, 50 insertions(+), 41 deletions(-) diff --git a/crates/settings_ui/src/keybindings.rs b/crates/settings_ui/src/keybindings.rs index d5ac253fb8..2e00426c1b 100644 --- a/crates/settings_ui/src/keybindings.rs +++ b/crates/settings_ui/src/keybindings.rs @@ -808,7 +808,8 @@ impl KeymapEditor { "Copy Context", Box::new(CopyContext), ) - .entry("Show matching keybindings", None, { + .separator() + .entry("Show Matching Keybindings", None, { move |_, cx| { weak.update(cx, |this, cx| { this.filter_on_selected_binding_keystrokes(cx); @@ -1211,10 +1212,11 @@ impl Render for KeymapEditor { fn render(&mut self, _window: &mut Window, cx: &mut ui::Context) -> impl ui::IntoElement { let row_count = self.matches.len(); let theme = cx.theme(); + let focus_handle = &self.focus_handle; v_flex() .id("keymap-editor") - .track_focus(&self.focus_handle) + .track_focus(focus_handle) .key_context(self.key_context()) .on_action(cx.listener(Self::select_next)) .on_action(cx.listener(Self::select_previous)) @@ -1229,16 +1231,15 @@ impl Render for KeymapEditor { .on_action(cx.listener(Self::toggle_conflict_filter)) .on_action(cx.listener(Self::toggle_keystroke_search)) .on_action(cx.listener(Self::toggle_exact_keystroke_matching)) + .on_mouse_move(cx.listener(|this, _, _window, _cx| { + this.show_hover_menus = true; + })) .size_full() .p_2() .gap_1() .bg(theme.colors().editor_background) - .on_mouse_move(cx.listener(|this, _, _window, _cx| { - this.show_hover_menus = true; - })) .child( v_flex() - .p_2() .gap_2() .child( h_flex() @@ -1266,13 +1267,18 @@ impl Render for KeymapEditor { IconName::Keyboard, ) .shape(ui::IconButtonShape::Square) - .tooltip(|window, cx| { - Tooltip::for_action( - "Search by Keystroke", - &ToggleKeystrokeSearch, - window, - cx, - ) + .tooltip({ + let focus_handle = focus_handle.clone(); + + move |window, cx| { + Tooltip::for_action_in( + "Search by Keystroke", + &ToggleKeystrokeSearch, + &focus_handle.clone(), + window, + cx, + ) + } }) .toggle_state(matches!( self.search_mode, @@ -1290,14 +1296,16 @@ impl Render for KeymapEditor { }) .tooltip({ let filter_state = self.filter_state; + let focus_handle = focus_handle.clone(); move |window, cx| { - Tooltip::for_action( + Tooltip::for_action_in( match filter_state { FilterState::All => "Show Conflicts", FilterState::Conflicts => "Hide Conflicts", }, &ToggleConflictFilter, + &focus_handle.clone(), window, cx, ) @@ -1331,35 +1339,36 @@ impl Render for KeymapEditor { this.pr_7() } }) + .gap_2() .child(self.keystroke_editor.clone()) .child( - div().p_1().child( - IconButton::new( - "keystrokes-exact-match", - IconName::Equal, - ) - .tooltip(move |window, cx| { - Tooltip::for_action( - if exact_match { - "Partial match mode" - } else { - "Exact match mode" - }, + IconButton::new( + "keystrokes-exact-match", + IconName::CaseSensitive, + ) + .tooltip({ + let keystroke_focus_handle = + self.keystroke_editor.read(cx).focus_handle(cx); + + move |window, cx| { + Tooltip::for_action_in( + "Toggle Exact Match Mode", &ToggleExactKeystrokeMatching, + &keystroke_focus_handle, window, cx, ) - }) - .shape(IconButtonShape::Square) - .toggle_state(exact_match) - .on_click( - cx.listener(|_, _, window, cx| { - window.dispatch_action( - ToggleExactKeystrokeMatching.boxed_clone(), - cx, - ); - }), - ), + } + }) + .shape(IconButtonShape::Square) + .toggle_state(exact_match) + .on_click( + cx.listener(|_, _, window, cx| { + window.dispatch_action( + ToggleExactKeystrokeMatching.boxed_clone(), + cx, + ); + }), ), ), ) @@ -2771,7 +2780,7 @@ impl Render for KeystrokeInput { .editor_background .blend(colors.text_accent.opacity(0.1)); - let recording_pulse = || { + let recording_pulse = |color: Color| { Icon::new(IconName::Circle) .size(IconSize::Small) .color(Color::Error) @@ -2781,7 +2790,7 @@ impl Render for KeystrokeInput { .repeat() .with_easing(gpui::pulsating_between(0.4, 0.8)), { - let color = Color::Error.color(cx); + let color = color.color(cx); move |this, delta| this.color(Color::Custom(color.opacity(delta))) }, ) @@ -2797,7 +2806,7 @@ impl Render for KeystrokeInput { .editor_background .blend(colors.text_accent.opacity(0.1))) .rounded_sm() - .child(recording_pulse()) + .child(recording_pulse(Color::Error)) .child( Label::new("REC") .size(LabelSize::XSmall) @@ -2815,7 +2824,7 @@ impl Render for KeystrokeInput { .editor_background .blend(colors.text_accent.opacity(0.1))) .rounded_sm() - .child(recording_pulse()) + .child(recording_pulse(Color::Accent)) .child( Label::new("SEARCH") .size(LabelSize::XSmall) From ed4deaa7389e6d740c32b9a3a9c0dd69b7bececf Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Thu, 17 Jul 2025 20:46:16 -0300 Subject: [PATCH 0040/1052] agent: Remove layout shift due to the "waiting for confirmation" label (#34674) Take 2 on https://github.com/zed-industries/zed/pull/33046. Release Notes: - N/A --- crates/agent/src/context_server_tool.rs | 2 +- crates/agent_ui/src/active_thread.rs | 6 ++++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/crates/agent/src/context_server_tool.rs b/crates/agent/src/context_server_tool.rs index da7de1e312..4c6d2b2b0b 100644 --- a/crates/agent/src/context_server_tool.rs +++ b/crates/agent/src/context_server_tool.rs @@ -38,7 +38,7 @@ impl Tool for ContextServerTool { } fn icon(&self) -> IconName { - IconName::Cog + IconName::ToolHammer } fn source(&self) -> ToolSource { diff --git a/crates/agent_ui/src/active_thread.rs b/crates/agent_ui/src/active_thread.rs index f5f6952519..14e7cf05b5 100644 --- a/crates/agent_ui/src/active_thread.rs +++ b/crates/agent_ui/src/active_thread.rs @@ -3202,7 +3202,10 @@ impl ActiveThread { .border_color(self.tool_card_border_color(cx)) .rounded_b_lg() .child( - LoadingLabel::new("Waiting for Confirmation").size(LabelSize::Small) + div() + .min_w(rems_from_px(145.)) + .child(LoadingLabel::new("Waiting for Confirmation").size(LabelSize::Small) + ) ) .child( h_flex() @@ -3247,7 +3250,6 @@ impl ActiveThread { }, )) }) - .child(ui::Divider::vertical()) .child({ let tool_id = tool_use.id.clone(); Button::new("allow-tool-action", "Allow") From 4314b3528898050c119075f0adf98e8b0c680371 Mon Sep 17 00:00:00 2001 From: Ben Kunkle Date: Thu, 17 Jul 2025 19:03:10 -0500 Subject: [PATCH 0041/1052] keymap_ui: Don't panic on `KeybindSource::from_meta` (#34652) Closes #ISSUE Log error instead of panicking when `from_meta` is passed an invalid value Release Notes: - N/A *or* Added/Fixed/Improved ... --- crates/settings/src/keymap_file.rs | 10 +++++++--- crates/settings_ui/src/keybindings.rs | 5 ++++- 2 files changed, 11 insertions(+), 4 deletions(-) diff --git a/crates/settings/src/keymap_file.rs b/crates/settings/src/keymap_file.rs index e6a32f731b..3a01d889c4 100644 --- a/crates/settings/src/keymap_file.rs +++ b/crates/settings/src/keymap_file.rs @@ -992,13 +992,17 @@ impl KeybindSource { } pub fn from_meta(index: KeyBindingMetaIndex) -> Self { - match index { + Self::try_from_meta(index).unwrap() + } + + pub fn try_from_meta(index: KeyBindingMetaIndex) -> Result { + Ok(match index { Self::USER => KeybindSource::User, Self::BASE => KeybindSource::Base, Self::DEFAULT => KeybindSource::Default, Self::VIM => KeybindSource::Vim, - _ => unreachable!(), - } + _ => anyhow::bail!("Invalid keybind source {:?}", index), + }) } } diff --git a/crates/settings_ui/src/keybindings.rs b/crates/settings_ui/src/keybindings.rs index 2e00426c1b..29927c4196 100644 --- a/crates/settings_ui/src/keybindings.rs +++ b/crates/settings_ui/src/keybindings.rs @@ -567,7 +567,10 @@ impl KeymapEditor { let mut string_match_candidates = Vec::new(); for key_binding in key_bindings { - let source = key_binding.meta().map(settings::KeybindSource::from_meta); + let source = key_binding + .meta() + .map(settings::KeybindSource::try_from_meta) + .and_then(|source| source.log_err()); let keystroke_text = ui::text_for_keystrokes(key_binding.keystrokes(), cx); let ui_key_binding = Some( From a7284adafab23d96330584bb0db38c85b0f171e5 Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Fri, 18 Jul 2025 06:07:52 +0530 Subject: [PATCH 0042/1052] =?UTF-8?q?editor:=20Fix=20cursor=20doesn?= =?UTF-8?q?=E2=80=99t=20move=20up=20and=20down=20on=20arrow=20keys=20when?= =?UTF-8?q?=20no=20completions=20are=20shown=20(#34678)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closes #34338 After https://github.com/zed-industries/zed/pull/31872, to avoid re-querying language servers, we keep the context menu around, which stores initial query, completions items, etc., even though it may not contain any items and hence not be rendered on screen. In this state, up/down arrows try to switch focus in the context menu instead of propagating it to the editor. Hence blocking buffer movement. This PR fixes it by changing the context for `menu`, `showing_completions`, and `showing_code_actions` to only be added when the menu is actually being rendered (i.e., not empty). Release Notes: - Fix an issue where the cursor doesn’t move up and down on arrow keys when no completions are shown. --- crates/editor/src/code_context_menus.rs | 2 +- crates/editor/src/editor.rs | 16 ++++++++++------ 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/crates/editor/src/code_context_menus.rs b/crates/editor/src/code_context_menus.rs index c7477837dd..9f842836ed 100644 --- a/crates/editor/src/code_context_menus.rs +++ b/crates/editor/src/code_context_menus.rs @@ -1384,7 +1384,7 @@ impl CodeActionsMenu { } } - fn visible(&self) -> bool { + pub fn visible(&self) -> bool { !self.actions.is_empty() } diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index 6ad4fc0318..c3187f6b51 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -2382,13 +2382,17 @@ impl Editor { } match self.context_menu.borrow().as_ref() { - Some(CodeContextMenu::Completions(_)) => { - key_context.add("menu"); - key_context.add("showing_completions"); + Some(CodeContextMenu::Completions(menu)) => { + if menu.visible() { + key_context.add("menu"); + key_context.add("showing_completions"); + } } - Some(CodeContextMenu::CodeActions(_)) => { - key_context.add("menu"); - key_context.add("showing_code_actions") + Some(CodeContextMenu::CodeActions(menu)) => { + if menu.visible() { + key_context.add("menu"); + key_context.add("showing_code_actions") + } } None => {} } From c287397a18e3f1385d634daf00f88776ca688533 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Thu, 17 Jul 2025 21:40:02 -0300 Subject: [PATCH 0043/1052] Rename "CloseInactiveItems" action to "CloseOtherItems" (#34676) This is following feedback from folks that were searching the "close others" action, available in the tab's context menu, and not finding it because it was actually named "close inactive", which was confusing. So, this PR makes sure the tab's menu item and the action have consistent naming. Release Notes: - Rename "CloseInactiveItems" action to "CloseOtherItems" for naming consistency. --- assets/keymaps/default-linux.json | 2 +- assets/keymaps/default-macos.json | 2 +- assets/keymaps/linux/emacs.json | 2 +- assets/keymaps/macos/emacs.json | 2 +- crates/collab/src/tests/following_tests.rs | 2 +- crates/editor/src/editor_tests.rs | 6 ++--- crates/vim/src/command.rs | 4 ++-- crates/workspace/src/pane.rs | 27 +++++++++++----------- crates/workspace/src/workspace.rs | 8 +++---- 9 files changed, 28 insertions(+), 27 deletions(-) diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index ebc88ec135..b859d2d84c 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -419,7 +419,7 @@ "ctrl-shift-pagedown": "pane::SwapItemRight", "ctrl-f4": ["pane::CloseActiveItem", { "close_pinned": false }], "ctrl-w": ["pane::CloseActiveItem", { "close_pinned": false }], - "alt-ctrl-t": ["pane::CloseInactiveItems", { "close_pinned": false }], + "alt-ctrl-t": ["pane::CloseOtherItems", { "close_pinned": false }], "alt-ctrl-shift-w": "workspace::CloseInactiveTabsAndPanes", "ctrl-k e": ["pane::CloseItemsToTheLeft", { "close_pinned": false }], "ctrl-k t": ["pane::CloseItemsToTheRight", { "close_pinned": false }], diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index cec485ce88..748deaa05d 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -477,7 +477,7 @@ "ctrl-shift-pageup": "pane::SwapItemLeft", "ctrl-shift-pagedown": "pane::SwapItemRight", "cmd-w": ["pane::CloseActiveItem", { "close_pinned": false }], - "alt-cmd-t": ["pane::CloseInactiveItems", { "close_pinned": false }], + "alt-cmd-t": ["pane::CloseOtherItems", { "close_pinned": false }], "ctrl-alt-cmd-w": "workspace::CloseInactiveTabsAndPanes", "cmd-k e": ["pane::CloseItemsToTheLeft", { "close_pinned": false }], "cmd-k t": ["pane::CloseItemsToTheRight", { "close_pinned": false }], diff --git a/assets/keymaps/linux/emacs.json b/assets/keymaps/linux/emacs.json index 0c633efabe..0ff3796f03 100755 --- a/assets/keymaps/linux/emacs.json +++ b/assets/keymaps/linux/emacs.json @@ -114,7 +114,7 @@ "ctrl-x o": "workspace::ActivateNextPane", // other-window "ctrl-x k": "pane::CloseActiveItem", // kill-buffer "ctrl-x 0": "pane::CloseActiveItem", // delete-window - "ctrl-x 1": "pane::CloseInactiveItems", // delete-other-windows + "ctrl-x 1": "pane::CloseOtherItems", // delete-other-windows "ctrl-x 2": "pane::SplitDown", // split-window-below "ctrl-x 3": "pane::SplitRight", // split-window-right "ctrl-x ctrl-f": "file_finder::Toggle", // find-file diff --git a/assets/keymaps/macos/emacs.json b/assets/keymaps/macos/emacs.json index 0c633efabe..0ff3796f03 100755 --- a/assets/keymaps/macos/emacs.json +++ b/assets/keymaps/macos/emacs.json @@ -114,7 +114,7 @@ "ctrl-x o": "workspace::ActivateNextPane", // other-window "ctrl-x k": "pane::CloseActiveItem", // kill-buffer "ctrl-x 0": "pane::CloseActiveItem", // delete-window - "ctrl-x 1": "pane::CloseInactiveItems", // delete-other-windows + "ctrl-x 1": "pane::CloseOtherItems", // delete-other-windows "ctrl-x 2": "pane::SplitDown", // split-window-below "ctrl-x 3": "pane::SplitRight", // split-window-right "ctrl-x ctrl-f": "file_finder::Toggle", // find-file diff --git a/crates/collab/src/tests/following_tests.rs b/crates/collab/src/tests/following_tests.rs index 3aa86a434d..1a4c3a70a4 100644 --- a/crates/collab/src/tests/following_tests.rs +++ b/crates/collab/src/tests/following_tests.rs @@ -1013,7 +1013,7 @@ async fn test_peers_following_each_other(cx_a: &mut TestAppContext, cx_b: &mut T // and some of which were originally opened by client B. workspace_b.update_in(cx_b, |workspace, window, cx| { workspace.active_pane().update(cx, |pane, cx| { - pane.close_inactive_items(&Default::default(), None, window, cx) + pane.close_other_items(&Default::default(), None, window, cx) .detach(); }); }); diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index 43c9c0db65..4efb052c71 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -55,7 +55,7 @@ use util::{ uri, }; use workspace::{ - CloseActiveItem, CloseAllItems, CloseInactiveItems, MoveItemToPaneInDirection, NavigationEntry, + CloseActiveItem, CloseAllItems, CloseOtherItems, MoveItemToPaneInDirection, NavigationEntry, OpenOptions, ViewId, item::{FollowEvent, FollowableItem, Item, ItemHandle, SaveOptions}, }; @@ -21463,7 +21463,7 @@ println!("5"); .unwrap(); pane_1 .update_in(cx, |pane, window, cx| { - pane.close_inactive_items(&CloseInactiveItems::default(), None, window, cx) + pane.close_other_items(&CloseOtherItems::default(), None, window, cx) }) .await .unwrap(); @@ -21499,7 +21499,7 @@ println!("5"); .unwrap(); pane_2 .update_in(cx, |pane, window, cx| { - pane.close_inactive_items(&CloseInactiveItems::default(), None, window, cx) + pane.close_other_items(&CloseOtherItems::default(), None, window, cx) }) .await .unwrap(); diff --git a/crates/vim/src/command.rs b/crates/vim/src/command.rs index 74aed815a2..23e04cae2c 100644 --- a/crates/vim/src/command.rs +++ b/crates/vim/src/command.rs @@ -1085,12 +1085,12 @@ fn generate_commands(_: &App) -> Vec { ), VimCommand::new( ("tabo", "nly"), - workspace::CloseInactiveItems { + workspace::CloseOtherItems { save_intent: Some(SaveIntent::Close), close_pinned: false, }, ) - .bang(workspace::CloseInactiveItems { + .bang(workspace::CloseOtherItems { save_intent: Some(SaveIntent::Skip), close_pinned: false, }), diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs index 19afd49848..7cc10c27f7 100644 --- a/crates/workspace/src/pane.rs +++ b/crates/workspace/src/pane.rs @@ -116,7 +116,8 @@ pub struct CloseActiveItem { #[derive(Clone, PartialEq, Debug, Deserialize, JsonSchema, Default, Action)] #[action(namespace = pane)] #[serde(deny_unknown_fields)] -pub struct CloseInactiveItems { +#[action(deprecated_aliases = ["pane::CloseInactiveItems"])] +pub struct CloseOtherItems { #[serde(default)] pub save_intent: Option, #[serde(default)] @@ -1354,9 +1355,9 @@ impl Pane { }) } - pub fn close_inactive_items( + pub fn close_other_items( &mut self, - action: &CloseInactiveItems, + action: &CloseOtherItems, target_item_id: Option, window: &mut Window, cx: &mut Context, @@ -2578,7 +2579,7 @@ impl Pane { save_intent: None, close_pinned: true, }; - let close_inactive_items_action = CloseInactiveItems { + let close_inactive_items_action = CloseOtherItems { save_intent: None, close_pinned: false, }; @@ -2610,7 +2611,7 @@ impl Pane { .action(Box::new(close_inactive_items_action.clone())) .disabled(total_items == 1) .handler(window.handler_for(&pane, move |pane, window, cx| { - pane.close_inactive_items( + pane.close_other_items( &close_inactive_items_action, Some(item_id), window, @@ -3521,8 +3522,8 @@ impl Render for Pane { }), ) .on_action( - cx.listener(|pane: &mut Self, action: &CloseInactiveItems, window, cx| { - pane.close_inactive_items(action, None, window, cx) + cx.listener(|pane: &mut Self, action: &CloseOtherItems, window, cx| { + pane.close_other_items(action, None, window, cx) .detach_and_log_err(cx); }), ) @@ -5853,8 +5854,8 @@ mod tests { assert_item_labels(&pane, ["A!", "B!", "C", "D", "E*"], cx); pane.update_in(cx, |pane, window, cx| { - pane.close_inactive_items( - &CloseInactiveItems { + pane.close_other_items( + &CloseOtherItems { save_intent: None, close_pinned: false, }, @@ -5890,8 +5891,8 @@ mod tests { assert_item_labels(&pane, ["A", "B", "C", "D", "E*"], cx); pane.update_in(cx, |pane, window, cx| { - pane.close_inactive_items( - &CloseInactiveItems { + pane.close_other_items( + &CloseOtherItems { save_intent: None, close_pinned: false, }, @@ -6256,8 +6257,8 @@ mod tests { .unwrap(); pane.update_in(cx, |pane, window, cx| { - pane.close_inactive_items( - &CloseInactiveItems { + pane.close_other_items( + &CloseOtherItems { save_intent: None, close_pinned: false, }, diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index be5d693d35..f37abe59e2 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -2793,8 +2793,8 @@ impl Workspace { if retain_active_pane { let current_pane_close = current_pane.update(cx, |pane, cx| { - pane.close_inactive_items( - &CloseInactiveItems { + pane.close_other_items( + &CloseOtherItems { save_intent: None, close_pinned: false, }, @@ -9471,8 +9471,8 @@ mod tests { ); }); let close_all_but_multi_buffer_task = pane.update_in(cx, |pane, window, cx| { - pane.close_inactive_items( - &CloseInactiveItems { + pane.close_other_items( + &CloseOtherItems { save_intent: Some(SaveIntent::Save), close_pinned: true, }, From 8a7bd5f47b69741a66b8929f5937175cee4bc544 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Thu, 17 Jul 2025 22:19:27 -0300 Subject: [PATCH 0044/1052] agent: Adjust retry on Burn Mode layout (#34680) Quick follow-up to https://github.com/zed-industries/zed/pull/34669 so that the buttons don't look so big in comparison to the callout. Release Notes: - N/A --- crates/agent_ui/src/agent_panel.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 139e32f835..087eec5efb 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -2981,6 +2981,8 @@ impl AgentPanel { let retry_button = Button::new("retry", "Retry") .icon(IconName::RotateCw) .icon_position(IconPosition::Start) + .icon_size(IconSize::Small) + .label_size(LabelSize::Small) .on_click({ let thread = thread.clone(); move |_, window, cx| { @@ -3023,6 +3025,8 @@ impl AgentPanel { let retry_button = Button::new("retry", "Retry") .icon(IconName::RotateCw) .icon_position(IconPosition::Start) + .icon_size(IconSize::Small) + .label_size(LabelSize::Small) .on_click({ let thread = thread.clone(); move |_, window, cx| { @@ -3046,6 +3050,8 @@ impl AgentPanel { let burn_mode_button = Button::new("enable_burn_retry", "Enable Burn Mode and Retry") .icon(IconName::ZedBurnMode) .icon_position(IconPosition::Start) + .icon_size(IconSize::Small) + .label_size(LabelSize::Small) .on_click({ let thread = thread.clone(); move |_, window, cx| { From c1307cead48ba96c663d9d074ebeb21a1c90d96d Mon Sep 17 00:00:00 2001 From: Daniel Sauble Date: Thu, 17 Jul 2025 21:30:01 -0700 Subject: [PATCH 0045/1052] Add `;` key binding for Helix mode (#34315) Closes #34111 In Helix mode, the `;` key should collapse the current selection without moving the cursor. I've added a new action `vim::HelixCollapseSelection` to support this behavior. https://github.com/user-attachments/assets/1a40821a-f56f-456e-9d37-532500bef17b Release Notes: - Added `;` key binding to collapse the current text selection in Helix mode --- assets/keymaps/vim.json | 1 + crates/vim/src/normal.rs | 16 ++++++++++++++++ 2 files changed, 17 insertions(+) diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json index dcb52e5250..89a71e59e6 100644 --- a/assets/keymaps/vim.json +++ b/assets/keymaps/vim.json @@ -377,6 +377,7 @@ "context": "vim_mode == helix_normal && !menu", "bindings": { "ctrl-[": "editor::Cancel", + ";": "vim::HelixCollapseSelection", ":": "command_palette::Toggle", "left": "vim::WrappingLeft", "right": "vim::WrappingRight", diff --git a/crates/vim/src/normal.rs b/crates/vim/src/normal.rs index 6131032f4f..13128e7b40 100644 --- a/crates/vim/src/normal.rs +++ b/crates/vim/src/normal.rs @@ -64,6 +64,8 @@ actions!( DeleteRight, /// Deletes using Helix-style behavior. HelixDelete, + /// Collapse the current selection + HelixCollapseSelection, /// Changes from cursor to end of line. ChangeToEndOfLine, /// Deletes from cursor to end of line. @@ -143,6 +145,20 @@ pub(crate) fn register(editor: &mut Editor, cx: &mut Context) { vim.switch_mode(Mode::HelixNormal, true, window, cx); }); + Vim::action(editor, cx, |vim, _: &HelixCollapseSelection, window, cx| { + vim.update_editor(window, cx, |_, editor, window, cx| { + editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| { + s.move_with(|map, selection| { + let mut point = selection.head(); + if !selection.reversed && !selection.is_empty() { + point = movement::left(map, selection.head()); + } + selection.collapse_to(point, selection.goal) + }); + }); + }); + }); + Vim::action(editor, cx, |vim, _: &ChangeToEndOfLine, window, cx| { vim.start_recording(cx); let times = Vim::take_count(cx); From c13322397eaf81735a97d93ba236702c218dc27b Mon Sep 17 00:00:00 2001 From: Andy Waite Date: Fri, 18 Jul 2025 05:46:36 -0400 Subject: [PATCH 0046/1052] docs: Document pull diagnostics support for Ruby (#34028) This is now supported. Release Notes: - N/A --- docs/src/languages/ruby.md | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/docs/src/languages/ruby.md b/docs/src/languages/ruby.md index b7856b2cd0..6f530433bd 100644 --- a/docs/src/languages/ruby.md +++ b/docs/src/languages/ruby.md @@ -127,7 +127,7 @@ Solargraph reads its configuration from a file called `.solargraph.yml` in the r ## Setting up `ruby-lsp` -Ruby LSP uses pull-based diagnostics which Zed doesn't support yet. We can tell Zed to disable it by adding the following to your `settings.json`: +You can pass Ruby LSP configuration to `initialization_options`, e.g. ```json { @@ -140,8 +140,7 @@ Ruby LSP uses pull-based diagnostics which Zed doesn't support yet. We can tell "ruby-lsp": { "initialization_options": { "enabledFeatures": { - // This disables diagnostics - "diagnostics": false + // "someFeature": false } } } From 00097df0d585c65103e1c1fd170cce3a28c631aa Mon Sep 17 00:00:00 2001 From: Arseny Kapoulkine Date: Fri, 18 Jul 2025 03:24:20 -0700 Subject: [PATCH 0047/1052] Improve C/C++ indentation flow for single statement blocks (#34549) Before this, indentation did not automatically increase after if/for/while/do/else statements in C++, and only increased after if/for in C. This led to Zed using last line logic when inserting lines *after* the indented statement, as well as not indenting the statement itself, resulting in irregular indentation during typing. Just adding indentation (similar to C) creates a new problem: now if a scope is started with a brace on a new line, that brace is indented. Thus we need to deindent it. Using else_clause in the indent guide results in the else statement being indented forward as well, so we need to deindent that too. Note: the most significant issue for me is the one where indentation jumps forward when inserting lines after indented lines. Unfortunately, it appears that fixing that issue requires all of these other changes. I would have preferred a simpler fix, but I'm not sure if disabling last line behavior for C/C++ is appropriate as it probably breaks something else, like cases where the file is incomplete and the statements can't be parsed properly. Editing flow before this change: [Screencast From 2025-07-16 08-31-36.webm](https://github.com/user-attachments/assets/3dea86c5-47bd-47c2-aee8-b0aa613948e6) Editing flow after this change: [Screencast From 2025-07-16 08-35-36.webm](https://github.com/user-attachments/assets/7ef23e60-1ee3-49fd-90f9-d53f909ca674) (note: the "else" snippet is completely breaking the flow here, but I think that comes from clangd by default? Unfortunately I haven't found a way to disable it cleanly but that is a separate problem that happens right now too.) Release Notes: - Improve indentation during typing for C/C++ around if/for/while/do blocks --- crates/languages/src/c/config.toml | 4 ++++ crates/languages/src/c/indents.scm | 10 ++++++++++ crates/languages/src/cpp/config.toml | 4 ++++ crates/languages/src/cpp/indents.scm | 12 ++++++++++++ 4 files changed, 30 insertions(+) diff --git a/crates/languages/src/c/config.toml b/crates/languages/src/c/config.toml index 08cd100f4d..78213da5be 100644 --- a/crates/languages/src/c/config.toml +++ b/crates/languages/src/c/config.toml @@ -2,6 +2,10 @@ name = "C" grammar = "c" path_suffixes = ["c"] line_comments = ["// "] +decrease_indent_patterns = [ + { pattern = "^\\s*\\{.*\\}?\\s*$", valid_after = ["if", "for", "while", "do", "switch", "else"] }, + { pattern = "^\\s*else\\s*$", valid_after = ["if"] } +] autoclose_before = ";:.,=}])>" brackets = [ { start = "{", end = "}", close = true, newline = true }, diff --git a/crates/languages/src/c/indents.scm b/crates/languages/src/c/indents.scm index fa40ce215e..3b6d5135ab 100644 --- a/crates/languages/src/c/indents.scm +++ b/crates/languages/src/c/indents.scm @@ -3,7 +3,17 @@ (assignment_expression) (if_statement) (for_statement) + (while_statement) + (do_statement) + (else_clause) ] @indent (_ "{" "}" @end) @indent (_ "(" ")" @end) @indent + +(if_statement) @start.if +(for_statement) @start.for +(while_statement) @start.while +(do_statement) @start.do +(switch_statement) @start.switch +(else_clause) @start.else diff --git a/crates/languages/src/cpp/config.toml b/crates/languages/src/cpp/config.toml index a81cbe09cd..1e28381605 100644 --- a/crates/languages/src/cpp/config.toml +++ b/crates/languages/src/cpp/config.toml @@ -2,6 +2,10 @@ name = "C++" grammar = "cpp" path_suffixes = ["cc", "hh", "cpp", "h", "hpp", "cxx", "hxx", "c++", "ipp", "inl", "ixx", "cu", "cuh", "C", "H"] line_comments = ["// ", "/// ", "//! "] +decrease_indent_patterns = [ + { pattern = "^\\s*\\{.*\\}?\\s*$", valid_after = ["if", "for", "while", "do", "switch", "else"] }, + { pattern = "^\\s*else\\s*$", valid_after = ["if"] } +] autoclose_before = ";:.,=}])>" brackets = [ { start = "{", end = "}", close = true, newline = true }, diff --git a/crates/languages/src/cpp/indents.scm b/crates/languages/src/cpp/indents.scm index a17f4c4821..d95dfe178c 100644 --- a/crates/languages/src/cpp/indents.scm +++ b/crates/languages/src/cpp/indents.scm @@ -1,7 +1,19 @@ [ (field_expression) (assignment_expression) + (if_statement) + (for_statement) + (while_statement) + (do_statement) + (else_clause) ] @indent (_ "{" "}" @end) @indent (_ "(" ")" @end) @indent + +(if_statement) @start.if +(for_statement) @start.for +(while_statement) @start.while +(do_statement) @start.do +(switch_statement) @start.switch +(else_clause) @start.else From 7e3fd7bb020077383947950f4e899c258d48c2aa Mon Sep 17 00:00:00 2001 From: tidely <43219534+tidely@users.noreply.github.com> Date: Fri, 18 Jul 2025 13:35:38 +0300 Subject: [PATCH 0048/1052] gpui: Use static keyword with `LazyLock` when loading system fonts (#34555) Use the `static` keyword to actually make the `LazyLock` static, which previously would reinitialize on every call to `SvgRenderer::new`. Related: #26335 Release Notes: - N/A --- crates/gpui/src/svg_renderer.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/gpui/src/svg_renderer.rs b/crates/gpui/src/svg_renderer.rs index 08d281b850..0107624bc8 100644 --- a/crates/gpui/src/svg_renderer.rs +++ b/crates/gpui/src/svg_renderer.rs @@ -27,7 +27,7 @@ pub enum SvgSize { impl SvgRenderer { pub fn new(asset_source: Arc) -> Self { - let font_db = LazyLock::new(|| { + static FONT_DB: LazyLock> = LazyLock::new(|| { let mut db = usvg::fontdb::Database::new(); db.load_system_fonts(); Arc::new(db) @@ -36,7 +36,7 @@ impl SvgRenderer { let font_resolver = Box::new( move |font: &usvg::Font, db: &mut Arc| { if db.is_empty() { - *db = font_db.clone(); + *db = FONT_DB.clone(); } default_font_resolver(font, db) }, From fd05f17fa7e0253bc98698e84a1f8939bcb6616f Mon Sep 17 00:00:00 2001 From: Lukas Spiss <35728419+Spissable@users.noreply.github.com> Date: Fri, 18 Jul 2025 12:38:18 +0100 Subject: [PATCH 0049/1052] go: Support raw string subtest names (#34636) Currently, we're not able to run Go sub-tests that have a raw string (e.g. we're using multi-line names a lot) via the UI. I added the changes that are needed, plus a handful of tests to cover the basics. Quick comparison: Before: before After: after Release Notes: - Added support for Go subtest runner with raw string names --- crates/languages/src/go.rs | 121 +++++++++++++++++++++++++- crates/languages/src/go/runnables.scm | 5 +- 2 files changed, 121 insertions(+), 5 deletions(-) diff --git a/crates/languages/src/go.rs b/crates/languages/src/go.rs index 25aa5a67b9..16c1b67203 100644 --- a/crates/languages/src/go.rs +++ b/crates/languages/src/go.rs @@ -41,7 +41,7 @@ static VERSION_REGEX: LazyLock = LazyLock::new(|| Regex::new(r"\d+\.\d+\.\d+").expect("Failed to create VERSION_REGEX")); static GO_ESCAPE_SUBTEST_NAME_REGEX: LazyLock = LazyLock::new(|| { - Regex::new(r#"[.*+?^${}()|\[\]\\]"#).expect("Failed to create GO_ESCAPE_SUBTEST_NAME_REGEX") + Regex::new(r#"[.*+?^${}()|\[\]\\"']"#).expect("Failed to create GO_ESCAPE_SUBTEST_NAME_REGEX") }); const BINARY: &str = if cfg!(target_os = "windows") { @@ -685,11 +685,20 @@ impl ContextProvider for GoContextProvider { } fn extract_subtest_name(input: &str) -> Option { - let replaced_spaces = input.trim_matches('"').replace(' ', "_"); + let content = if input.starts_with('`') && input.ends_with('`') { + input.trim_matches('`') + } else { + input.trim_matches('"') + }; + + let processed = content + .chars() + .map(|c| if c.is_whitespace() { '_' } else { c }) + .collect::(); Some( GO_ESCAPE_SUBTEST_NAME_REGEX - .replace_all(&replaced_spaces, |caps: ®ex::Captures| { + .replace_all(&processed, |caps: ®ex::Captures| { format!("\\{}", &caps[0]) }) .to_string(), @@ -700,7 +709,7 @@ fn extract_subtest_name(input: &str) -> Option { mod tests { use super::*; use crate::language; - use gpui::Hsla; + use gpui::{AppContext, Hsla, TestAppContext}; use theme::SyntaxTheme; #[gpui::test] @@ -790,4 +799,108 @@ mod tests { }) ); } + + #[gpui::test] + fn test_go_runnable_detection(cx: &mut TestAppContext) { + let language = language("go", tree_sitter_go::LANGUAGE.into()); + + let interpreted_string_subtest = r#" + package main + + import "testing" + + func TestExample(t *testing.T) { + t.Run("subtest with double quotes", func(t *testing.T) { + // test code + }) + } + "#; + + let raw_string_subtest = r#" + package main + + import "testing" + + func TestExample(t *testing.T) { + t.Run(`subtest with + multiline + backticks`, func(t *testing.T) { + // test code + }) + } + "#; + + let buffer = cx.new(|cx| { + crate::Buffer::local(interpreted_string_subtest, cx).with_language(language.clone(), cx) + }); + cx.executor().run_until_parked(); + + let runnables: Vec<_> = buffer.update(cx, |buffer, _| { + let snapshot = buffer.snapshot(); + snapshot + .runnable_ranges(0..interpreted_string_subtest.len()) + .collect() + }); + + assert!( + runnables.len() == 2, + "Should find test function and subtest with double quotes, found: {}", + runnables.len() + ); + + let buffer = cx.new(|cx| { + crate::Buffer::local(raw_string_subtest, cx).with_language(language.clone(), cx) + }); + cx.executor().run_until_parked(); + + let runnables: Vec<_> = buffer.update(cx, |buffer, _| { + let snapshot = buffer.snapshot(); + snapshot + .runnable_ranges(0..raw_string_subtest.len()) + .collect() + }); + + assert!( + runnables.len() == 2, + "Should find test function and subtest with backticks, found: {}", + runnables.len() + ); + } + + #[test] + fn test_extract_subtest_name() { + // Interpreted string literal + let input_double_quoted = r#""subtest with double quotes""#; + let result = extract_subtest_name(input_double_quoted); + assert_eq!(result, Some(r#"subtest_with_double_quotes"#.to_string())); + + let input_double_quoted_with_backticks = r#""test with `backticks` inside""#; + let result = extract_subtest_name(input_double_quoted_with_backticks); + assert_eq!(result, Some(r#"test_with_`backticks`_inside"#.to_string())); + + // Raw string literal + let input_with_backticks = r#"`subtest with backticks`"#; + let result = extract_subtest_name(input_with_backticks); + assert_eq!(result, Some(r#"subtest_with_backticks"#.to_string())); + + let input_raw_with_quotes = r#"`test with "quotes" and other chars`"#; + let result = extract_subtest_name(input_raw_with_quotes); + assert_eq!( + result, + Some(r#"test_with_\"quotes\"_and_other_chars"#.to_string()) + ); + + let input_multiline = r#"`subtest with + multiline + backticks`"#; + let result = extract_subtest_name(input_multiline); + assert_eq!( + result, + Some(r#"subtest_with_________multiline_________backticks"#.to_string()) + ); + + let input_with_double_quotes = r#"`test with "double quotes"`"#; + let result = extract_subtest_name(input_with_double_quotes); + assert_eq!(result, Some(r#"test_with_\"double_quotes\""#.to_string())); + } } diff --git a/crates/languages/src/go/runnables.scm b/crates/languages/src/go/runnables.scm index bdeb77b46c..49e112b860 100644 --- a/crates/languages/src/go/runnables.scm +++ b/crates/languages/src/go/runnables.scm @@ -38,7 +38,10 @@ arguments: ( argument_list . - (interpreted_string_literal) @_subtest_name + [ + (interpreted_string_literal) + (raw_string_literal) + ] @_subtest_name . (func_literal parameters: ( From cfe1adc7922e2f4b337a5613a3bbe33e742a9904 Mon Sep 17 00:00:00 2001 From: Ben Brandt Date: Fri, 18 Jul 2025 15:17:41 +0200 Subject: [PATCH 0050/1052] E2E Claude tests (#34702) - **Fix cancellation of tool calls** - **Make tool_call test more resilient** - **Fix tool call confirmation test** Release Notes: - N/A --- Cargo.lock | 1 + crates/acp_thread/src/acp_thread.rs | 13 +++- crates/agent_servers/Cargo.toml | 1 + crates/agent_servers/src/claude.rs | 14 ++-- crates/agent_servers/src/claude/tools.rs | 99 +++++++++++++++++++++++- crates/agent_servers/src/e2e_tests.rs | 98 ++++++++++++++++------- 6 files changed, 188 insertions(+), 38 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index a8a8d12e37..4d84249b00 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -158,6 +158,7 @@ dependencies = [ "serde_json", "settings", "smol", + "strum 0.27.1", "tempfile", "ui", "util", diff --git a/crates/acp_thread/src/acp_thread.rs b/crates/acp_thread/src/acp_thread.rs index 1e3947351a..ae22725d5e 100644 --- a/crates/acp_thread/src/acp_thread.rs +++ b/crates/acp_thread/src/acp_thread.rs @@ -664,7 +664,7 @@ impl AcpThread { cx: &mut Context, ) -> Result { let project = self.project.read(cx).languages().clone(); - let Some((_, call)) = self.tool_call_mut(tool_call_id) else { + let Some((idx, call)) = self.tool_call_mut(tool_call_id) else { anyhow::bail!("Tool call not found"); }; @@ -675,6 +675,8 @@ impl AcpThread { respond_tx: tx, }; + cx.emit(AcpThreadEvent::EntryUpdated(idx)); + Ok(ToolCallRequest { id: tool_call_id, outcome: rx, @@ -768,8 +770,13 @@ impl AcpThread { let language_registry = self.project.read(cx).languages().clone(); let (ix, call) = self.tool_call_mut(id).context("Entry not found")?; - call.content = new_content - .map(|new_content| ToolCallContent::from_acp(new_content, language_registry, cx)); + if let Some(new_content) = new_content { + call.content = Some(ToolCallContent::from_acp( + new_content, + language_registry, + cx, + )); + } match &mut call.status { ToolCallStatus::Allowed { status } => { diff --git a/crates/agent_servers/Cargo.toml b/crates/agent_servers/Cargo.toml index 2d68148264..f3df25f709 100644 --- a/crates/agent_servers/Cargo.toml +++ b/crates/agent_servers/Cargo.toml @@ -33,6 +33,7 @@ serde.workspace = true serde_json.workspace = true settings.workspace = true smol.workspace = true +strum.workspace = true tempfile.workspace = true ui.workspace = true util.workspace = true diff --git a/crates/agent_servers/src/claude.rs b/crates/agent_servers/src/claude.rs index 5760a96d8c..52c6012267 100644 --- a/crates/agent_servers/src/claude.rs +++ b/crates/agent_servers/src/claude.rs @@ -281,14 +281,18 @@ impl ClaudeAgentConnection { } => { let id = tool_id_map.borrow_mut().remove(&tool_use_id); if let Some(id) = id { + let content = content.to_string(); delegate .update_tool_call(UpdateToolCallParams { tool_call_id: id, status: acp::ToolCallStatus::Finished, - content: Some(ToolCallContent::Markdown { - // For now we only include text content - markdown: content.to_string(), - }), + // Don't unset existing content + content: (!content.is_empty()).then_some( + ToolCallContent::Markdown { + // For now we only include text content + markdown: content, + }, + ), }) .await .log_err(); @@ -577,7 +581,7 @@ pub(crate) mod tests { use super::*; use serde_json::json; - // crate::common_e2e_tests!(ClaudeCode); + crate::common_e2e_tests!(ClaudeCode); pub fn local_command() -> AgentServerCommand { AgentServerCommand { diff --git a/crates/agent_servers/src/claude/tools.rs b/crates/agent_servers/src/claude/tools.rs index e3ac6c14e2..a2d6b487b2 100644 --- a/crates/agent_servers/src/claude/tools.rs +++ b/crates/agent_servers/src/claude/tools.rs @@ -118,13 +118,106 @@ impl ClaudeTool { pub fn content(&self) -> Option { match &self { - ClaudeTool::Other { input, .. } => Some(acp::ToolCallContent::Markdown { + Self::Other { input, .. } => Some(acp::ToolCallContent::Markdown { markdown: format!( "```json\n{}```", serde_json::to_string_pretty(&input).unwrap_or("{}".to_string()) ), }), - _ => None, + Self::Task(Some(params)) => Some(acp::ToolCallContent::Markdown { + markdown: params.prompt.clone(), + }), + Self::NotebookRead(Some(params)) => Some(acp::ToolCallContent::Markdown { + markdown: params.notebook_path.display().to_string(), + }), + Self::NotebookEdit(Some(params)) => Some(acp::ToolCallContent::Markdown { + markdown: params.new_source.clone(), + }), + Self::Terminal(Some(params)) => Some(acp::ToolCallContent::Markdown { + markdown: format!( + "`{}`\n\n{}", + params.command, + params.description.as_deref().unwrap_or_default() + ), + }), + Self::ReadFile(Some(params)) => Some(acp::ToolCallContent::Markdown { + markdown: params.abs_path.display().to_string(), + }), + Self::Ls(Some(params)) => Some(acp::ToolCallContent::Markdown { + markdown: params.path.display().to_string(), + }), + Self::Glob(Some(params)) => Some(acp::ToolCallContent::Markdown { + markdown: params.to_string(), + }), + Self::Grep(Some(params)) => Some(acp::ToolCallContent::Markdown { + markdown: format!("`{params}`"), + }), + Self::WebFetch(Some(params)) => Some(acp::ToolCallContent::Markdown { + markdown: params.prompt.clone(), + }), + Self::WebSearch(Some(params)) => Some(acp::ToolCallContent::Markdown { + markdown: params.to_string(), + }), + Self::TodoWrite(Some(params)) => Some(acp::ToolCallContent::Markdown { + markdown: params + .todos + .iter() + .map(|todo| { + format!( + "- {} {}: {}", + match todo.status { + TodoStatus::Completed => "✅", + TodoStatus::InProgress => "🚧", + TodoStatus::Pending => "⬜", + }, + todo.priority, + todo.content + ) + }) + .join("\n"), + }), + Self::ExitPlanMode(Some(params)) => Some(acp::ToolCallContent::Markdown { + markdown: params.plan.clone(), + }), + Self::Edit(Some(params)) => Some(acp::ToolCallContent::Diff { + diff: acp::Diff { + path: params.abs_path.clone(), + old_text: Some(params.old_text.clone()), + new_text: params.new_text.clone(), + }, + }), + Self::Write(Some(params)) => Some(acp::ToolCallContent::Diff { + diff: acp::Diff { + path: params.file_path.clone(), + old_text: None, + new_text: params.content.clone(), + }, + }), + Self::MultiEdit(Some(params)) => { + // todo: show multiple edits in a multibuffer? + params.edits.first().map(|edit| acp::ToolCallContent::Diff { + diff: acp::Diff { + path: params.file_path.clone(), + old_text: Some(edit.old_string.clone()), + new_text: edit.new_string.clone(), + }, + }) + } + Self::Task(None) + | Self::NotebookRead(None) + | Self::NotebookEdit(None) + | Self::Terminal(None) + | Self::ReadFile(None) + | Self::Ls(None) + | Self::Glob(None) + | Self::Grep(None) + | Self::WebFetch(None) + | Self::WebSearch(None) + | Self::TodoWrite(None) + | Self::ExitPlanMode(None) + | Self::Edit(None) + | Self::Write(None) + | Self::MultiEdit(None) => None, } } @@ -513,7 +606,7 @@ impl std::fmt::Display for GrepToolParams { } } -#[derive(Deserialize, Serialize, JsonSchema, Debug)] +#[derive(Deserialize, Serialize, JsonSchema, strum::Display, Debug)] #[serde(rename_all = "snake_case")] pub enum TodoPriority { High, diff --git a/crates/agent_servers/src/e2e_tests.rs b/crates/agent_servers/src/e2e_tests.rs index 923c6cdd6f..12f74cb13e 100644 --- a/crates/agent_servers/src/e2e_tests.rs +++ b/crates/agent_servers/src/e2e_tests.rs @@ -111,18 +111,21 @@ pub async fn test_tool_call(server: impl AgentServer + 'static, cx: &mut TestApp .await .unwrap(); thread.read_with(cx, |thread, _cx| { - assert!(matches!( - &thread.entries()[2], - AgentThreadEntry::ToolCall(ToolCall { - status: ToolCallStatus::Allowed { .. }, - .. - }) - )); - - assert!(matches!( - thread.entries()[3], - AgentThreadEntry::AssistantMessage(_) - )); + assert!(thread.entries().iter().any(|entry| { + matches!( + entry, + AgentThreadEntry::ToolCall(ToolCall { + status: ToolCallStatus::Allowed { .. }, + .. + }) + ) + })); + assert!( + thread + .entries() + .iter() + .any(|entry| { matches!(entry, AgentThreadEntry::AssistantMessage(_)) }) + ); }); } @@ -134,10 +137,26 @@ pub async fn test_tool_call_with_confirmation( let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await; let thread = new_test_thread(server, project.clone(), "/private/tmp", cx).await; let full_turn = thread.update(cx, |thread, cx| { - thread.send_raw(r#"Run `echo "Hello, world!"`"#, cx) + thread.send_raw( + r#"Run `touch hello.txt && echo "Hello, world!" | tee hello.txt`"#, + cx, + ) }); - run_until_first_tool_call(&thread, cx).await; + run_until_first_tool_call( + &thread, + |entry| { + matches!( + entry, + AgentThreadEntry::ToolCall(ToolCall { + status: ToolCallStatus::WaitingForConfirmation { .. }, + .. + }) + ) + }, + cx, + ) + .await; let tool_call_id = thread.read_with(cx, |thread, _cx| { let AgentThreadEntry::ToolCall(ToolCall { @@ -148,12 +167,16 @@ pub async fn test_tool_call_with_confirmation( .. }, .. - }) = &thread.entries()[2] + }) = &thread + .entries() + .iter() + .find(|entry| matches!(entry, AgentThreadEntry::ToolCall(_))) + .unwrap() else { panic!(); }; - assert_eq!(root_command, "echo"); + assert!(root_command.contains("touch")); *id }); @@ -161,13 +184,13 @@ pub async fn test_tool_call_with_confirmation( thread.update(cx, |thread, cx| { thread.authorize_tool_call(tool_call_id, acp::ToolCallConfirmationOutcome::Allow, cx); - assert!(matches!( - &thread.entries()[2], + assert!(thread.entries().iter().any(|entry| matches!( + entry, AgentThreadEntry::ToolCall(ToolCall { status: ToolCallStatus::Allowed { .. }, .. }) - )); + ))); }); full_turn.await.unwrap(); @@ -177,15 +200,19 @@ pub async fn test_tool_call_with_confirmation( content: Some(ToolCallContent::Markdown { markdown }), status: ToolCallStatus::Allowed { .. }, .. - }) = &thread.entries()[2] + }) = thread + .entries() + .iter() + .find(|entry| matches!(entry, AgentThreadEntry::ToolCall(_))) + .unwrap() else { panic!(); }; markdown.read_with(cx, |md, _cx| { assert!( - md.source().contains("Hello, world!"), - r#"Expected '{}' to contain "Hello, world!""#, + md.source().contains("Hello"), + r#"Expected '{}' to contain "Hello""#, md.source() ); }); @@ -198,10 +225,26 @@ pub async fn test_cancel(server: impl AgentServer + 'static, cx: &mut TestAppCon let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await; let thread = new_test_thread(server, project.clone(), "/private/tmp", cx).await; let full_turn = thread.update(cx, |thread, cx| { - thread.send_raw(r#"Run `echo "Hello, world!"`"#, cx) + thread.send_raw( + r#"Run `touch hello.txt && echo "Hello, world!" >> hello.txt`"#, + cx, + ) }); - let first_tool_call_ix = run_until_first_tool_call(&thread, cx).await; + let first_tool_call_ix = run_until_first_tool_call( + &thread, + |entry| { + matches!( + entry, + AgentThreadEntry::ToolCall(ToolCall { + status: ToolCallStatus::WaitingForConfirmation { .. }, + .. + }) + ) + }, + cx, + ) + .await; thread.read_with(cx, |thread, _cx| { let AgentThreadEntry::ToolCall(ToolCall { @@ -217,7 +260,7 @@ pub async fn test_cancel(server: impl AgentServer + 'static, cx: &mut TestAppCon panic!("{:?}", thread.entries()[1]); }; - assert_eq!(root_command, "echo"); + assert!(root_command.contains("touch")); *id }); @@ -340,6 +383,7 @@ pub async fn new_test_thread( pub async fn run_until_first_tool_call( thread: &Entity, + wait_until: impl Fn(&AgentThreadEntry) -> bool + 'static, cx: &mut TestAppContext, ) -> usize { let (mut tx, mut rx) = mpsc::channel::(1); @@ -347,7 +391,7 @@ pub async fn run_until_first_tool_call( let subscription = cx.update(|cx| { cx.subscribe(thread, move |thread, _, cx| { for (ix, entry) in thread.read(cx).entries().iter().enumerate() { - if matches!(entry, AgentThreadEntry::ToolCall(_)) { + if wait_until(entry) { return tx.try_send(ix).unwrap(); } } @@ -357,7 +401,7 @@ pub async fn run_until_first_tool_call( select! { // We have to use a smol timer here because // cx.background_executor().timer isn't real in the test context - _ = futures::FutureExt::fuse(smol::Timer::after(Duration::from_secs(10))) => { + _ = futures::FutureExt::fuse(smol::Timer::after(Duration::from_secs(20))) => { panic!("Timeout waiting for tool call") } ix = rx.next().fuse() => { From 1070de47ec2ac32e17ca756492cc11620cda8320 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Fri, 18 Jul 2025 10:24:57 -0300 Subject: [PATCH 0051/1052] component preview: Add separators between sections in sidebar (#34701) Small improvement for navigating inside the component preview. Release Notes: - N/A --- crates/component/src/component_layout.rs | 4 ++-- crates/zed/src/zed/component_preview.rs | 26 ++++++++---------------- 2 files changed, 11 insertions(+), 19 deletions(-) diff --git a/crates/component/src/component_layout.rs b/crates/component/src/component_layout.rs index 9fe52507d8..58bf1d8f0c 100644 --- a/crates/component/src/component_layout.rs +++ b/crates/component/src/component_layout.rs @@ -118,8 +118,8 @@ impl RenderOnce for ComponentExampleGroup { .flex() .items_center() .gap_3() - .pb_1() - .child(div().h_px().w_4().bg(cx.theme().colors().border)) + .mt_4() + .mb_1() .child( div() .flex_none() diff --git a/crates/zed/src/zed/component_preview.rs b/crates/zed/src/zed/component_preview.rs index c32248cbe0..670793cff3 100644 --- a/crates/zed/src/zed/component_preview.rs +++ b/crates/zed/src/zed/component_preview.rs @@ -369,7 +369,6 @@ impl ComponentPreview { // Always show all components first entries.push(PreviewEntry::AllComponents); entries.push(PreviewEntry::ActiveThread); - entries.push(PreviewEntry::Separator); let mut scopes: Vec<_> = scope_groups .keys() @@ -382,7 +381,9 @@ impl ComponentPreview { for scope in scopes { if let Some(components) = scope_groups.remove(&scope) { if !components.is_empty() { + entries.push(PreviewEntry::Separator); entries.push(PreviewEntry::SectionHeader(scope.to_string().into())); + let mut sorted_components = components; sorted_components.sort_by_key(|(component, _)| component.sort_name()); @@ -515,16 +516,12 @@ impl ComponentPreview { Vec::new() }; if valid_positions.is_empty() { - Label::new(name.clone()) - .color(Color::Default) - .into_any_element() + Label::new(name.clone()).into_any_element() } else { HighlightedLabel::new(name.clone(), valid_positions).into_any_element() } } else { - Label::new(name.clone()) - .color(Color::Default) - .into_any_element() + Label::new(name.clone()).into_any_element() }) .selectable(true) .toggle_state(selected) @@ -542,7 +539,7 @@ impl ComponentPreview { let selected = self.active_page == PreviewPage::AllComponents; ListItem::new(ix) - .child(Label::new("All Components").color(Color::Default)) + .child(Label::new("All Components")) .selectable(true) .toggle_state(selected) .inset(true) @@ -555,7 +552,7 @@ impl ComponentPreview { let selected = self.active_page == PreviewPage::ActiveThread; ListItem::new(ix) - .child(Label::new("Active Thread").color(Color::Default)) + .child(Label::new("Active Thread")) .selectable(true) .toggle_state(selected) .inset(true) @@ -565,12 +562,8 @@ impl ComponentPreview { .into_any_element() } PreviewEntry::Separator => ListItem::new(ix) - .child( - h_flex() - .occlude() - .pt_3() - .child(Divider::horizontal_dashed()), - ) + .disabled(true) + .child(div().w_full().py_2().child(Divider::horizontal())) .into_any_element(), } } @@ -585,7 +578,6 @@ impl ComponentPreview { h_flex() .w_full() .h_10() - .items_center() .child(Headline::new(title).size(HeadlineSize::XSmall)) .child(Divider::horizontal()) } @@ -798,7 +790,7 @@ impl Render for ComponentPreview { ) .track_scroll(self.nav_scroll_handle.clone()) .p_2p5() - .w(px(240.)) + .w(px(229.)) .h_full() .flex_1(), ) From fd8480a9dc6cf07668b1e70f6b24b31268a88e15 Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Fri, 18 Jul 2025 09:35:36 -0400 Subject: [PATCH 0052/1052] Document terminal.cursor_shape (#34707) Release Notes: - N/A --- docs/src/configuring-zed.md | 48 ++++++++++++++++++++++++++++++++ docs/src/visual-customization.md | 2 +- 2 files changed, 49 insertions(+), 1 deletion(-) diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md index 91a39d1ccd..cc4800fd6d 100644 --- a/docs/src/configuring-zed.md +++ b/docs/src/configuring-zed.md @@ -2698,6 +2698,54 @@ List of `integer` column numbers } ``` +### Terminal: Cursor Shape + +- Description: Whether or not selecting text in the terminal will automatically copy to the system clipboard. +- Setting: `cursor_shape` +- Default: `null` (defaults to block) + +**Options** + +1. A block that surrounds the following character + +```json +{ + "terminal": { + "cursor_shape": "block" + } +} +``` + +2. A vertical bar + +```json +{ + "terminal": { + "cursor_shape": "bar" + } +} +``` + +3. An underline / underscore that runs along the following character + +```json +{ + "terminal": { + "cursor_shape": "underline" + } +} +``` + +4. A box drawn around the following character + +```json +{ + "terminal": { + "cursor_shape": "hollow" + } +} +``` + ### Terminal: Keep Selection On Copy - Description: Whether or not to keep the selection in the terminal after copying text. diff --git a/docs/src/visual-customization.md b/docs/src/visual-customization.md index ad38b86406..197c9b80f8 100644 --- a/docs/src/visual-customization.md +++ b/docs/src/visual-customization.md @@ -448,7 +448,7 @@ See [Zed AI Documentation](./ai/overview.md) for additional non-visual AI settin // Set the cursor blinking behavior in the terminal (on, off, terminal_controlled) "blinking": "terminal_controlled", - // Default cursor shape for the terminal (block, bar, underline, hollow) + // Default cursor shape for the terminal cursor (block, bar, underline, hollow) "cursor_shape": "block", // Environment variables to add to terminal's process environment From 40028010347f658b4576348d8ff70cf68873213b Mon Sep 17 00:00:00 2001 From: Bennet Bo Fenner Date: Fri, 18 Jul 2025 15:58:44 +0200 Subject: [PATCH 0053/1052] agent: Fix new thread model selection when starting new thread (#34708) Release Notes: - agent: Fixed an issue where clicking on "Start New Thread" in the agent configuration would not always switch to the correct provider/model --- crates/agent_ui/src/agent_panel.rs | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 087eec5efb..103e439615 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -53,7 +53,8 @@ use gpui::{ }; use language::LanguageRegistry; use language_model::{ - ConfigurationError, LanguageModelProviderTosView, LanguageModelRegistry, ZED_CLOUD_PROVIDER_ID, + ConfigurationError, ConfiguredModel, LanguageModelProviderTosView, LanguageModelRegistry, + ZED_CLOUD_PROVIDER_ID, }; use project::{Project, ProjectPath, Worktree}; use prompt_store::{PromptBuilder, PromptStore, UserPromptId}; @@ -1347,6 +1348,19 @@ impl AgentPanel { } self.new_thread(&NewThread::default(), window, cx); + if let Some((thread, model)) = + self.active_thread(cx).zip(provider.default_model(cx)) + { + thread.update(cx, |thread, cx| { + thread.set_configured_model( + Some(ConfiguredModel { + provider: provider.clone(), + model, + }), + cx, + ); + }); + } } } } From d604b3b29183a09579f408059e7ca0f6bf6fbc62 Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Fri, 18 Jul 2025 10:01:09 -0400 Subject: [PATCH 0054/1052] Fix incorrect minimum_contrast comment (#34710) Actual default is 45 https://github.com/zed-industries/zed/blob/fd05f17fa7e0253bc98698e84a1f8939bcb6616f/assets/settings/default.json#L1402 Release Notes: - N/A --- crates/terminal/src/terminal_settings.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/terminal/src/terminal_settings.rs b/crates/terminal/src/terminal_settings.rs index a290ce9c81..3f89afffab 100644 --- a/crates/terminal/src/terminal_settings.rs +++ b/crates/terminal/src/terminal_settings.rs @@ -248,7 +248,7 @@ pub struct TerminalSettingsContent { /// - 75: Minimum for body text /// - 90: Preferred for body text /// - /// Default: 0 (no adjustment) + /// Default: 45 pub minimum_contrast: Option, } From 2ac99e7a1158e1e6d3bfd44016fa01af000d5ad7 Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Fri, 18 Jul 2025 16:28:03 +0200 Subject: [PATCH 0055/1052] debugger: Fix attaching with DebugPy (#34706) @cole-miller found a root cause of our struggles with attach scenarios; we did not fetch .so files necessary for attaching to work, as we were downloading DebugPy source tarballs from GitHub. This PR does away with it by setting up a virtualenv instead that has debugpy installed. Closes #34660 Closes #34575 Release Notes: - debugger: Fixed attaching with DebugPy. DebugPy is now installed automatically from pip (instead of GitHub), unless it is present in active virtual environment. Additionally this should resolve any startup issues with missing .so on Linux. --- Cargo.lock | 1 + crates/dap_adapters/Cargo.toml | 1 + crates/dap_adapters/src/dap_adapters.rs | 1 - crates/dap_adapters/src/python.rs | 189 ++++++++++++------------ 4 files changed, 98 insertions(+), 94 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 4d84249b00..aad5349a87 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4248,6 +4248,7 @@ dependencies = [ "serde", "serde_json", "shlex", + "smol", "task", "util", "workspace-hack", diff --git a/crates/dap_adapters/Cargo.toml b/crates/dap_adapters/Cargo.toml index 65544fbb6a..e7366785c8 100644 --- a/crates/dap_adapters/Cargo.toml +++ b/crates/dap_adapters/Cargo.toml @@ -36,6 +36,7 @@ paths.workspace = true serde.workspace = true serde_json.workspace = true shlex.workspace = true +smol.workspace = true task.workspace = true util.workspace = true workspace-hack.workspace = true diff --git a/crates/dap_adapters/src/dap_adapters.rs b/crates/dap_adapters/src/dap_adapters.rs index a147861f8d..a4e6beb249 100644 --- a/crates/dap_adapters/src/dap_adapters.rs +++ b/crates/dap_adapters/src/dap_adapters.rs @@ -13,7 +13,6 @@ use dap::{ DapRegistry, adapters::{ self, AdapterVersion, DapDelegate, DebugAdapter, DebugAdapterBinary, DebugAdapterName, - GithubRepo, }, configure_tcp_connection, }; diff --git a/crates/dap_adapters/src/python.rs b/crates/dap_adapters/src/python.rs index eb541bde8e..aa64fea6ed 100644 --- a/crates/dap_adapters/src/python.rs +++ b/crates/dap_adapters/src/python.rs @@ -1,31 +1,39 @@ use crate::*; use anyhow::Context as _; -use dap::adapters::latest_github_release; use dap::{DebugRequest, StartDebuggingRequestArguments, adapters::DebugTaskDefinition}; -use gpui::{AppContext, AsyncApp, SharedString}; +use gpui::{AsyncApp, SharedString}; use json_dotpath::DotPaths; -use language::{LanguageName, Toolchain}; +use language::LanguageName; +use paths::debug_adapters_dir; use serde_json::Value; +use smol::lock::OnceCell; use std::net::Ipv4Addr; use std::{ collections::HashMap, ffi::OsStr, path::{Path, PathBuf}, - sync::OnceLock, }; -use util::ResultExt; #[derive(Default)] pub(crate) struct PythonDebugAdapter { - checked: OnceLock<()>, + python_venv_base: OnceCell, String>>, } impl PythonDebugAdapter { const ADAPTER_NAME: &'static str = "Debugpy"; const DEBUG_ADAPTER_NAME: DebugAdapterName = DebugAdapterName(SharedString::new_static(Self::ADAPTER_NAME)); - const ADAPTER_PACKAGE_NAME: &'static str = "debugpy"; - const ADAPTER_PATH: &'static str = "src/debugpy/adapter"; + const PYTHON_ADAPTER_IN_VENV: &'static str = if cfg!(target_os = "windows") { + "Scripts/python3" + } else { + "bin/python3" + }; + const ADAPTER_PATH: &'static str = if cfg!(target_os = "windows") { + "debugpy-venv/Scripts/debugpy-adapter" + } else { + "debugpy-venv/bin/debugpy-adapter" + }; + const LANGUAGE_NAME: &'static str = "Python"; async fn generate_debugpy_arguments( @@ -46,25 +54,12 @@ impl PythonDebugAdapter { vec!["-m".to_string(), "debugpy.adapter".to_string()] } else { let adapter_path = paths::debug_adapters_dir().join(Self::DEBUG_ADAPTER_NAME.as_ref()); - let file_name_prefix = format!("{}_", Self::ADAPTER_NAME); - - let debugpy_dir = - util::fs::find_file_name_in_dir(adapter_path.as_path(), |file_name| { - file_name.starts_with(&file_name_prefix) - }) - .await - .context("Debugpy directory not found")?; - - log::debug!( - "Using GitHub-downloaded debugpy adapter from: {}", - debugpy_dir.display() - ); - vec![ - debugpy_dir - .join(Self::ADAPTER_PATH) - .to_string_lossy() - .to_string(), - ] + let path = adapter_path + .join(Self::ADAPTER_PATH) + .to_string_lossy() + .into_owned(); + log::debug!("Using pip debugpy adapter from: {path}"); + vec![path] }; args.extend(if let Some(args) = user_args { @@ -100,44 +95,67 @@ impl PythonDebugAdapter { request, }) } - async fn fetch_latest_adapter_version( - &self, - delegate: &Arc, - ) -> Result { - let github_repo = GithubRepo { - repo_name: Self::ADAPTER_PACKAGE_NAME.into(), - repo_owner: "microsoft".into(), - }; - fetch_latest_adapter_version_from_github(github_repo, delegate.as_ref()).await - } - - async fn install_binary( - adapter_name: DebugAdapterName, - version: AdapterVersion, - delegate: Arc, - ) -> Result<()> { - let version_path = adapters::download_adapter_from_github( - adapter_name, - version, - adapters::DownloadedFileType::GzipTar, - delegate.as_ref(), - ) - .await?; - // only needed when you install the latest version for the first time - if let Some(debugpy_dir) = - util::fs::find_file_name_in_dir(version_path.as_path(), |file_name| { - file_name.starts_with("microsoft-debugpy-") - }) + async fn ensure_venv(delegate: &dyn DapDelegate) -> Result> { + let python_path = Self::find_base_python(delegate) .await - { - // TODO Debugger: Rename folder instead of moving all files to another folder - // We're doing unnecessary IO work right now - util::fs::move_folder_files_to_folder(debugpy_dir.as_path(), version_path.as_path()) + .context("Could not find Python installation for DebugPy")?; + let work_dir = debug_adapters_dir().join(Self::ADAPTER_NAME); + let mut path = work_dir.clone(); + path.push("debugpy-venv"); + if !path.exists() { + util::command::new_smol_command(python_path) + .arg("-m") + .arg("venv") + .arg("debugpy-venv") + .current_dir(work_dir) + .spawn()? + .output() .await?; } - Ok(()) + Ok(path.into()) + } + + // Find "baseline", user python version from which we'll create our own venv. + async fn find_base_python(delegate: &dyn DapDelegate) -> Option { + for path in ["python3", "python"] { + if let Some(path) = delegate.which(path.as_ref()).await { + return Some(path); + } + } + None + } + + async fn base_venv(&self, delegate: &dyn DapDelegate) -> Result, String> { + const BINARY_DIR: &str = if cfg!(target_os = "windows") { + "Scripts" + } else { + "bin" + }; + self.python_venv_base + .get_or_init(move || async move { + let venv_base = Self::ensure_venv(delegate) + .await + .map_err(|e| format!("{e}"))?; + let pip_path = venv_base.join(BINARY_DIR).join("pip3"); + let installation_succeeded = util::command::new_smol_command(pip_path.as_path()) + .arg("install") + .arg("debugpy") + .arg("-U") + .output() + .await + .map_err(|e| format!("{e}"))? + .status + .success(); + if !installation_succeeded { + return Err("debugpy installation failed".into()); + } + + Ok(venv_base) + }) + .await + .clone() } async fn get_installed_binary( @@ -146,15 +164,15 @@ impl PythonDebugAdapter { config: &DebugTaskDefinition, user_installed_path: Option, user_args: Option>, - toolchain: Option, + python_from_toolchain: Option, installed_in_venv: bool, ) -> Result { const BINARY_NAMES: [&str; 3] = ["python3", "python", "py"]; let tcp_connection = config.tcp_connection.clone().unwrap_or_default(); let (host, port, timeout) = crate::configure_tcp_connection(tcp_connection).await?; - let python_path = if let Some(toolchain) = toolchain { - Some(toolchain.path.to_string()) + let python_path = if let Some(toolchain) = python_from_toolchain { + Some(toolchain) } else { let mut name = None; @@ -635,25 +653,28 @@ impl DebugAdapter for PythonDebugAdapter { &config, None, user_args, - Some(toolchain.clone()), + Some(toolchain.path.to_string()), true, ) .await; } } } - - if self.checked.set(()).is_ok() { - delegate.output_to_console(format!("Checking latest version of {}...", self.name())); - if let Some(version) = self.fetch_latest_adapter_version(delegate).await.log_err() { - cx.background_spawn(Self::install_binary(self.name(), version, delegate.clone())) - .await - .context("Failed to install debugpy")?; - } - } - - self.get_installed_binary(delegate, &config, None, user_args, toolchain, false) + let toolchain = self + .base_venv(&**delegate) .await + .map_err(|e| anyhow::anyhow!(e))? + .join(Self::PYTHON_ADAPTER_IN_VENV); + + self.get_installed_binary( + delegate, + &config, + None, + user_args, + Some(toolchain.to_string_lossy().into_owned()), + false, + ) + .await } fn label_for_child_session(&self, args: &StartDebuggingRequestArguments) -> Option { @@ -666,24 +687,6 @@ impl DebugAdapter for PythonDebugAdapter { } } -async fn fetch_latest_adapter_version_from_github( - github_repo: GithubRepo, - delegate: &dyn DapDelegate, -) -> Result { - let release = latest_github_release( - &format!("{}/{}", github_repo.repo_owner, github_repo.repo_name), - false, - false, - delegate.http_client(), - ) - .await?; - - Ok(AdapterVersion { - tag_name: release.tag_name, - url: release.tarball_url, - }) -} - #[cfg(test)] mod tests { use super::*; From 6a24b2479cddc96133b9878fd560478004ead1ef Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Fri, 18 Jul 2025 10:28:20 -0400 Subject: [PATCH 0056/1052] Redact license keys in environment variables from log output (#34711) Release Notes: - N/A --- crates/util/src/redact.rs | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/crates/util/src/redact.rs b/crates/util/src/redact.rs index 0b979fb413..6b297dfb58 100644 --- a/crates/util/src/redact.rs +++ b/crates/util/src/redact.rs @@ -1,7 +1,14 @@ /// Whether a given environment variable name should have its value redacted pub fn should_redact(env_var_name: &str) -> bool { - const REDACTED_SUFFIXES: &[&str] = - &["KEY", "TOKEN", "PASSWORD", "SECRET", "PASS", "CREDENTIALS"]; + const REDACTED_SUFFIXES: &[&str] = &[ + "KEY", + "TOKEN", + "PASSWORD", + "SECRET", + "PASS", + "CREDENTIALS", + "LICENSE", + ]; REDACTED_SUFFIXES .iter() .any(|suffix| env_var_name.ends_with(suffix)) From f461290ac352de2cf0a5a00f8a1f9264ad5b29da Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Fri, 18 Jul 2025 10:52:42 -0400 Subject: [PATCH 0057/1052] collab: Add `POST /users/:id/refresh_llm_tokens` endpoint (#34714) This PR adds a new `POST /users/:id/refresh_llm_tokens` endpoint to Collab so that we can refresh LLM tokens from Cloud. Release Notes: - N/A --- crates/collab/src/api.rs | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/crates/collab/src/api.rs b/crates/collab/src/api.rs index 7fca27c5c2..8f1433a26f 100644 --- a/crates/collab/src/api.rs +++ b/crates/collab/src/api.rs @@ -100,6 +100,7 @@ pub fn routes(rpc_server: Arc) -> Router<(), Body> { .route("/user", get(update_or_create_authenticated_user)) .route("/users/look_up", get(look_up_user)) .route("/users/:id/access_tokens", post(create_access_token)) + .route("/users/:id/refresh_llm_tokens", post(refresh_llm_tokens)) .route("/rpc_server_snapshot", get(get_rpc_server_snapshot)) .merge(billing::router()) .merge(contributors::router()) @@ -334,3 +335,15 @@ async fn create_access_token( encrypted_access_token, })) } + +#[derive(Serialize)] +struct RefreshLlmTokensResponse {} + +async fn refresh_llm_tokens( + Path(user_id): Path, + Extension(rpc_server): Extension>, +) -> Result> { + rpc_server.refresh_llm_tokens_for_user(user_id).await; + + Ok(Json(RefreshLlmTokensResponse {})) +} From e421fc7a2dfb044fc118926fcab4aa7e13a9dab5 Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Fri, 18 Jul 2025 09:25:18 -0600 Subject: [PATCH 0058/1052] Update keymap context binding behavior of > and ! (#34664) Now ! means "no ancestors matches this", and > means "any descendent" not "any child". Updates #34570 Co-authored-by: Ben Kunkle Release Notes: - *Breaking change*. The context predicates in the keymap file now handle ! and > differently. Before this change ! meant "this node does not match", now it means "none of these nodes match". Before this change > meant "child of", now it means "descendent of". We do not expect these changes to break many keymaps, but they may cause subtle changes for complex context queries. --------- Co-authored-by: Ben Kunkle --- assets/keymaps/vim.json | 4 +- crates/gpui/src/keymap.rs | 136 ++++++------- crates/gpui/src/keymap/context.rs | 181 +++++++++++++++++- crates/language_tools/src/key_context_view.rs | 9 +- crates/settings_ui/src/keybindings.rs | 2 +- docs/src/key-bindings.md | 19 +- 6 files changed, 261 insertions(+), 90 deletions(-) diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json index 89a71e59e6..2ef282c21e 100644 --- a/assets/keymaps/vim.json +++ b/assets/keymaps/vim.json @@ -724,7 +724,7 @@ } }, { - "context": "AgentPanel || GitPanel || ProjectPanel || CollabPanel || OutlinePanel || ChatPanel || VimControl || EmptyPane || SharedScreen || MarkdownPreview || KeyContextView || DebugPanel", + "context": "VimControl || !Editor && !Terminal", "bindings": { // window related commands (ctrl-w X) "ctrl-w": null, @@ -782,7 +782,7 @@ } }, { - "context": "ChangesList || EmptyPane || SharedScreen || MarkdownPreview || KeyContextView || Welcome", + "context": "!Editor && !Terminal", "bindings": { ":": "command_palette::Toggle", "g /": "pane::DeploySearch" diff --git a/crates/gpui/src/keymap.rs b/crates/gpui/src/keymap.rs index b5dbab15c7..174dbc80f0 100644 --- a/crates/gpui/src/keymap.rs +++ b/crates/gpui/src/keymap.rs @@ -24,7 +24,7 @@ pub struct Keymap { } /// Index of a binding within a keymap. -#[derive(Copy, Clone, Debug, Eq, PartialEq)] +#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)] pub struct BindingIndex(usize); impl Keymap { @@ -167,65 +167,60 @@ impl Keymap { input: &[Keystroke], context_stack: &[KeyContext], ) -> (SmallVec<[(BindingIndex, KeyBinding); 1]>, bool) { - let possibilities = self + let mut possibilities = self .bindings() .enumerate() .rev() .filter_map(|(ix, binding)| { - binding - .match_keystrokes(input) - .map(|pending| (BindingIndex(ix), binding, pending)) - }); + let depth = self.binding_enabled(binding, &context_stack)?; + let pending = binding.match_keystrokes(input)?; + Some((depth, BindingIndex(ix), binding, pending)) + }) + .collect::>(); + possibilities.sort_by(|(depth_a, ix_a, _, _), (depth_b, ix_b, _, _)| { + depth_b.cmp(depth_a).then(ix_b.cmp(ix_a)) + }); let mut bindings: SmallVec<[(BindingIndex, KeyBinding, usize); 1]> = SmallVec::new(); // (pending, is_no_action, depth, keystrokes) let mut pending_info_opt: Option<(bool, bool, usize, &[Keystroke])> = None; - 'outer: for (binding_index, binding, pending) in possibilities { - for depth in (0..=context_stack.len()).rev() { - if self.binding_enabled(binding, &context_stack[0..depth]) { - let is_no_action = is_no_action(&*binding.action); - // We only want to consider a binding pending if it has an action - // This, however, means that if we have both a NoAction binding and a binding - // with an action at the same depth, we should still set is_pending to true. - if let Some(pending_info) = pending_info_opt.as_mut() { - let ( - already_pending, - pending_is_no_action, - pending_depth, - pending_keystrokes, - ) = *pending_info; + 'outer: for (depth, binding_index, binding, pending) in possibilities { + let is_no_action = is_no_action(&*binding.action); + // We only want to consider a binding pending if it has an action + // This, however, means that if we have both a NoAction binding and a binding + // with an action at the same depth, we should still set is_pending to true. + if let Some(pending_info) = pending_info_opt.as_mut() { + let (already_pending, pending_is_no_action, pending_depth, pending_keystrokes) = + *pending_info; - // We only want to change the pending status if it's not already pending AND if - // the existing pending status was set by a NoAction binding. This avoids a NoAction - // binding erroneously setting the pending status to true when a binding with an action - // already set it to false - // - // We also want to change the pending status if the keystrokes don't match, - // meaning it's different keystrokes than the NoAction that set pending to false - if pending - && !already_pending - && pending_is_no_action - && (pending_depth == depth - || pending_keystrokes != binding.keystrokes()) - { - pending_info.0 = !is_no_action; - } - } else { - pending_info_opt = Some(( - pending && !is_no_action, - is_no_action, - depth, - binding.keystrokes(), - )); - } - - if !pending { - bindings.push((binding_index, binding.clone(), depth)); - continue 'outer; - } + // We only want to change the pending status if it's not already pending AND if + // the existing pending status was set by a NoAction binding. This avoids a NoAction + // binding erroneously setting the pending status to true when a binding with an action + // already set it to false + // + // We also want to change the pending status if the keystrokes don't match, + // meaning it's different keystrokes than the NoAction that set pending to false + if pending + && !already_pending + && pending_is_no_action + && (pending_depth == depth || pending_keystrokes != binding.keystrokes()) + { + pending_info.0 = !is_no_action; } + } else { + pending_info_opt = Some(( + pending && !is_no_action, + is_no_action, + depth, + binding.keystrokes(), + )); + } + + if !pending { + bindings.push((binding_index, binding.clone(), depth)); + continue 'outer; } } // sort by descending depth @@ -245,15 +240,13 @@ impl Keymap { } /// Check if the given binding is enabled, given a certain key context. - fn binding_enabled(&self, binding: &KeyBinding, context: &[KeyContext]) -> bool { - // If binding has a context predicate, it must match the current context, + /// Returns the deepest depth at which the binding matches, or None if it doesn't match. + fn binding_enabled(&self, binding: &KeyBinding, contexts: &[KeyContext]) -> Option { if let Some(predicate) = &binding.context_predicate { - if !predicate.eval(context) { - return false; - } + predicate.depth_of(contexts) + } else { + Some(contexts.len()) } - - true } } @@ -280,18 +273,33 @@ mod tests { keymap.add_bindings(bindings.clone()); // global bindings are enabled in all contexts - assert!(keymap.binding_enabled(&bindings[0], &[])); - assert!(keymap.binding_enabled(&bindings[0], &[KeyContext::parse("terminal").unwrap()])); + assert_eq!(keymap.binding_enabled(&bindings[0], &[]), Some(0)); + assert_eq!( + keymap.binding_enabled(&bindings[0], &[KeyContext::parse("terminal").unwrap()]), + Some(1) + ); // contextual bindings are enabled in contexts that match their predicate - assert!(!keymap.binding_enabled(&bindings[1], &[KeyContext::parse("barf x=y").unwrap()])); - assert!(keymap.binding_enabled(&bindings[1], &[KeyContext::parse("pane x=y").unwrap()])); + assert_eq!( + keymap.binding_enabled(&bindings[1], &[KeyContext::parse("barf x=y").unwrap()]), + None + ); + assert_eq!( + keymap.binding_enabled(&bindings[1], &[KeyContext::parse("pane x=y").unwrap()]), + Some(1) + ); - assert!(!keymap.binding_enabled(&bindings[2], &[KeyContext::parse("editor").unwrap()])); - assert!(keymap.binding_enabled( - &bindings[2], - &[KeyContext::parse("editor mode=full").unwrap()] - )); + assert_eq!( + keymap.binding_enabled(&bindings[2], &[KeyContext::parse("editor").unwrap()]), + None + ); + assert_eq!( + keymap.binding_enabled( + &bindings[2], + &[KeyContext::parse("editor mode=full").unwrap()] + ), + Some(1) + ); } #[test] diff --git a/crates/gpui/src/keymap/context.rs b/crates/gpui/src/keymap/context.rs index eaad060982..f4b878ae77 100644 --- a/crates/gpui/src/keymap/context.rs +++ b/crates/gpui/src/keymap/context.rs @@ -178,7 +178,7 @@ pub enum KeyBindingContextPredicate { NotEqual(SharedString, SharedString), /// A predicate that will match a given predicate appearing below another predicate. /// in the element tree - Child( + Descendant( Box, Box, ), @@ -203,7 +203,7 @@ impl fmt::Display for KeyBindingContextPredicate { Self::Equal(left, right) => write!(f, "{} == {}", left, right), Self::NotEqual(left, right) => write!(f, "{} != {}", left, right), Self::Not(pred) => write!(f, "!{}", pred), - Self::Child(parent, child) => write!(f, "{} > {}", parent, child), + Self::Descendant(parent, child) => write!(f, "{} > {}", parent, child), Self::And(left, right) => write!(f, "({} && {})", left, right), Self::Or(left, right) => write!(f, "({} || {})", left, right), } @@ -249,8 +249,25 @@ impl KeyBindingContextPredicate { } } + /// Find the deepest depth at which the predicate matches. + pub fn depth_of(&self, contexts: &[KeyContext]) -> Option { + for depth in (0..=contexts.len()).rev() { + let context_slice = &contexts[0..depth]; + if self.eval_inner(context_slice, contexts) { + return Some(depth); + } + } + None + } + /// Eval a predicate against a set of contexts, arranged from lowest to highest. - pub fn eval(&self, contexts: &[KeyContext]) -> bool { + #[allow(unused)] + pub(crate) fn eval(&self, contexts: &[KeyContext]) -> bool { + self.eval_inner(contexts, contexts) + } + + /// Eval a predicate against a set of contexts, arranged from lowest to highest. + pub fn eval_inner(&self, contexts: &[KeyContext], all_contexts: &[KeyContext]) -> bool { let Some(context) = contexts.last() else { return false; }; @@ -264,12 +281,38 @@ impl KeyBindingContextPredicate { .get(left) .map(|value| value != right) .unwrap_or(true), - Self::Not(pred) => !pred.eval(contexts), - Self::Child(parent, child) => { - parent.eval(&contexts[..contexts.len() - 1]) && child.eval(contexts) + Self::Not(pred) => { + for i in 0..all_contexts.len() { + if pred.eval_inner(&all_contexts[..=i], all_contexts) { + return false; + } + } + return true; + } + // Workspace > Pane > Editor + // + // Pane > (Pane > Editor) // should match? + // (Pane > Pane) > Editor // should not match? + // Pane > !Workspace <-- should match? + // !Workspace <-- shouldn't match? + Self::Descendant(parent, child) => { + for i in 0..contexts.len() - 1 { + // [Workspace > Pane], [Editor] + if parent.eval_inner(&contexts[..=i], all_contexts) { + if !child.eval_inner(&contexts[i + 1..], &contexts[i + 1..]) { + return false; + } + return true; + } + } + return false; + } + Self::And(left, right) => { + left.eval_inner(contexts, all_contexts) && right.eval_inner(contexts, all_contexts) + } + Self::Or(left, right) => { + left.eval_inner(contexts, all_contexts) || right.eval_inner(contexts, all_contexts) } - Self::And(left, right) => left.eval(contexts) && right.eval(contexts), - Self::Or(left, right) => left.eval(contexts) || right.eval(contexts), } } @@ -285,7 +328,7 @@ impl KeyBindingContextPredicate { } match other { - KeyBindingContextPredicate::Child(_, child) => self.is_superset(child), + KeyBindingContextPredicate::Descendant(_, child) => self.is_superset(child), KeyBindingContextPredicate::And(left, right) => { self.is_superset(left) || self.is_superset(right) } @@ -375,7 +418,7 @@ impl KeyBindingContextPredicate { } fn new_child(self, other: Self) -> Result { - Ok(Self::Child(Box::new(self), Box::new(other))) + Ok(Self::Descendant(Box::new(self), Box::new(other))) } fn new_eq(self, other: Self) -> Result { @@ -598,4 +641,122 @@ mod tests { assert_eq!(a.is_superset(&b), result, "({a:?}).is_superset({b:?})"); } } + + #[test] + fn test_child_operator() { + let predicate = KeyBindingContextPredicate::parse("parent > child").unwrap(); + + let parent_context = KeyContext::try_from("parent").unwrap(); + let child_context = KeyContext::try_from("child").unwrap(); + + let contexts = vec![parent_context.clone(), child_context.clone()]; + assert!(predicate.eval(&contexts)); + + let grandparent_context = KeyContext::try_from("grandparent").unwrap(); + + let contexts = vec![ + grandparent_context, + parent_context.clone(), + child_context.clone(), + ]; + assert!(predicate.eval(&contexts)); + + let other_context = KeyContext::try_from("other").unwrap(); + + let contexts = vec![other_context.clone(), child_context.clone()]; + assert!(!predicate.eval(&contexts)); + + let contexts = vec![ + parent_context.clone(), + other_context.clone(), + child_context.clone(), + ]; + assert!(predicate.eval(&contexts)); + + assert!(!predicate.eval(&[])); + assert!(!predicate.eval(&[child_context.clone()])); + assert!(!predicate.eval(&[parent_context])); + + let zany_predicate = KeyBindingContextPredicate::parse("child > child").unwrap(); + assert!(!zany_predicate.eval(&[child_context.clone()])); + assert!(zany_predicate.eval(&[child_context.clone(), child_context.clone()])); + } + + #[test] + fn test_not_operator() { + let not_predicate = KeyBindingContextPredicate::parse("!editor").unwrap(); + let editor_context = KeyContext::try_from("editor").unwrap(); + let workspace_context = KeyContext::try_from("workspace").unwrap(); + let parent_context = KeyContext::try_from("parent").unwrap(); + let child_context = KeyContext::try_from("child").unwrap(); + + assert!(not_predicate.eval(&[workspace_context.clone()])); + assert!(!not_predicate.eval(&[editor_context.clone()])); + assert!(!not_predicate.eval(&[editor_context.clone(), workspace_context.clone()])); + assert!(!not_predicate.eval(&[workspace_context.clone(), editor_context.clone()])); + + let complex_not = KeyBindingContextPredicate::parse("!editor && workspace").unwrap(); + assert!(complex_not.eval(&[workspace_context.clone()])); + assert!(!complex_not.eval(&[editor_context.clone(), workspace_context.clone()])); + + let not_mode_predicate = KeyBindingContextPredicate::parse("!(mode == full)").unwrap(); + let mut mode_context = KeyContext::default(); + mode_context.set("mode", "full"); + assert!(!not_mode_predicate.eval(&[mode_context.clone()])); + + let mut other_mode_context = KeyContext::default(); + other_mode_context.set("mode", "partial"); + assert!(not_mode_predicate.eval(&[other_mode_context])); + + let not_descendant = KeyBindingContextPredicate::parse("!(parent > child)").unwrap(); + assert!(not_descendant.eval(&[parent_context.clone()])); + assert!(not_descendant.eval(&[child_context.clone()])); + assert!(!not_descendant.eval(&[parent_context.clone(), child_context.clone()])); + + let not_descendant = KeyBindingContextPredicate::parse("parent > !child").unwrap(); + assert!(!not_descendant.eval(&[parent_context.clone()])); + assert!(!not_descendant.eval(&[child_context.clone()])); + assert!(!not_descendant.eval(&[parent_context.clone(), child_context.clone()])); + + let double_not = KeyBindingContextPredicate::parse("!!editor").unwrap(); + assert!(double_not.eval(&[editor_context.clone()])); + assert!(!double_not.eval(&[workspace_context.clone()])); + + // Test complex descendant cases + let workspace_context = KeyContext::try_from("Workspace").unwrap(); + let pane_context = KeyContext::try_from("Pane").unwrap(); + let editor_context = KeyContext::try_from("Editor").unwrap(); + + // Workspace > Pane > Editor + let workspace_pane_editor = vec![ + workspace_context.clone(), + pane_context.clone(), + editor_context.clone(), + ]; + + // Pane > (Pane > Editor) - should not match + let pane_pane_editor = KeyBindingContextPredicate::parse("Pane > (Pane > Editor)").unwrap(); + assert!(!pane_pane_editor.eval(&workspace_pane_editor)); + + let workspace_pane_editor_predicate = + KeyBindingContextPredicate::parse("Workspace > Pane > Editor").unwrap(); + assert!(workspace_pane_editor_predicate.eval(&workspace_pane_editor)); + + // (Pane > Pane) > Editor - should not match + let pane_pane_then_editor = + KeyBindingContextPredicate::parse("(Pane > Pane) > Editor").unwrap(); + assert!(!pane_pane_then_editor.eval(&workspace_pane_editor)); + + // Pane > !Workspace - should match + let pane_not_workspace = KeyBindingContextPredicate::parse("Pane > !Workspace").unwrap(); + assert!(pane_not_workspace.eval(&[pane_context.clone(), editor_context.clone()])); + assert!(!pane_not_workspace.eval(&[pane_context.clone(), workspace_context.clone()])); + + // !Workspace - shouldn't match when Workspace is in the context + let not_workspace = KeyBindingContextPredicate::parse("!Workspace").unwrap(); + assert!(!not_workspace.eval(&[workspace_context.clone()])); + assert!(not_workspace.eval(&[pane_context.clone()])); + assert!(not_workspace.eval(&[editor_context.clone()])); + assert!(!not_workspace.eval(&workspace_pane_editor)); + } } diff --git a/crates/language_tools/src/key_context_view.rs b/crates/language_tools/src/key_context_view.rs index c933872d8c..88131781ec 100644 --- a/crates/language_tools/src/key_context_view.rs +++ b/crates/language_tools/src/key_context_view.rs @@ -132,14 +132,7 @@ impl KeyContextView { } fn matches(&self, predicate: &KeyBindingContextPredicate) -> bool { - let mut stack = self.context_stack.clone(); - while !stack.is_empty() { - if predicate.eval(&stack) { - return true; - } - stack.pop(); - } - false + predicate.depth_of(&self.context_stack).is_some() } fn action_matches(&self, a: &Option>, b: &dyn Action) -> bool { diff --git a/crates/settings_ui/src/keybindings.rs b/crates/settings_ui/src/keybindings.rs index 29927c4196..1a5bb7b459 100644 --- a/crates/settings_ui/src/keybindings.rs +++ b/crates/settings_ui/src/keybindings.rs @@ -3008,7 +3008,7 @@ fn collect_contexts_from_assets() -> Vec { contexts.insert(ident_a); contexts.insert(ident_b); } - gpui::KeyBindingContextPredicate::Child(ctx_a, ctx_b) => { + gpui::KeyBindingContextPredicate::Descendant(ctx_a, ctx_b) => { queue.push(*ctx_a); queue.push(*ctx_b); } diff --git a/docs/src/key-bindings.md b/docs/src/key-bindings.md index b2beaf9ffb..90aa400bb4 100644 --- a/docs/src/key-bindings.md +++ b/docs/src/key-bindings.md @@ -24,7 +24,7 @@ The file contains a JSON array of objects with `"bindings"`. If no `"context"` i Within each binding section a [key sequence](#keybinding-syntax) is mapped to an [action](#actions). If conflicts are detected they are resolved as [described below](#precedence). -If you are using a non-QWERTY, Latin-character keyboard, you may want to set `use_layout_keys` to `true`. See [Non-QWERTY keyboards](#non-qwerty-keyboards) for more information. +If you are using a non-QWERTY, Latin-character keyboard, you may want to set `use_key_equivalents` to `true`. See [Non-QWERTY keyboards](#non-qwerty-keyboards) for more information. For example: @@ -87,8 +87,6 @@ If a binding group has a `"context"` key it will be matched against the currentl Zed's contexts make up a tree, with the root being `Workspace`. Workspaces contain Panes and Panels, and Panes contain Editors, etc. The easiest way to see what contexts are active at a given moment is the key context view, which you can get to with `dev: Open Key Context View` in the command palette. -Contexts can contain extra attributes in addition to the name, so that you can (for example) match only in markdown files with `"context": "Editor && extension==md"`. It's worth noting that you can only use attributes at the level they are defined. - For example: ``` @@ -106,9 +104,20 @@ Workspace os=macos Context expressions can contain the following syntax: - `X && Y`, `X || Y` to and/or two conditions -- `!X` to negate a condition +- `!X` to check that a condition is false - `(X)` for grouping -- `X > Y` to match if a parent in the tree matches X and this layer matches Y. +- `X > Y` to match if an ancestor in the tree matches X and this layer matches Y. + +For example: + +- `"context": "Editor"` - matches any editor (including inline inputs) +- `"context": "Editor && mode=full"` - matches the main editors used for editing code +- `"context": "!Editor && !Terminal"` - matches anywhere except where an Editor or Terminal is focused +- `"context": "os=macos > Editor"` - matches any editor on macOS. + +It's worth noting that attributes are only available on the node they are defined on. This means that if you want to (for example) only enable a keybinding when the debugger is stopped in vim normal mode, you need to do `debugger_stopped > vim_mode == normal`. + +Note: Before Zed v0.197.x, the ! operator only looked at one node at a time, and `>` meant "parent" not "ancestor". This meant that `!Editor` would match the context `Workspace > Pane > Editor`, because (confusingly) the Pane matches `!Editor`, and that `os=macos > Editor` did not match the context `Workspace > Pane > Editor` because of the intermediate `Pane` node. If you're using Vim mode, we have information on how [vim modes influence the context](./vim.md#contexts) From 9a20843ba251324150cb072e7dcbd337a40dc7d5 Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Fri, 18 Jul 2025 12:03:08 -0400 Subject: [PATCH 0059/1052] Revert "gpui: Improve path rendering & global multisample anti-aliasing" (#34722) Reverts zed-industries/zed#29718 We've noticed some issues with Zed on Intel-based Macs where typing has become sluggish, and git bisect has seemed to point towards this PR. Reverting for now, until we can understand why it is causing this issue. --- Cargo.lock | 6 +- Cargo.toml | 12 +- crates/gpui/build.rs | 2 +- crates/gpui/examples/painting.rs | 23 +- crates/gpui/src/path_builder.rs | 5 +- crates/gpui/src/platform.rs | 1 + crates/gpui/src/platform/blade/blade_atlas.rs | 80 +++- .../gpui/src/platform/blade/blade_renderer.rs | 372 +++++++-------- crates/gpui/src/platform/blade/shaders.wgsl | 57 ++- crates/gpui/src/platform/mac/metal_atlas.rs | 35 +- .../gpui/src/platform/mac/metal_renderer.rs | 443 +++++++++++------- crates/gpui/src/platform/mac/shaders.metal | 103 ++-- crates/gpui/src/platform/test/window.rs | 2 +- crates/gpui/src/scene.rs | 61 ++- crates/gpui/src/window.rs | 2 +- docs/src/linux.md | 2 +- 16 files changed, 723 insertions(+), 483 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index aad5349a87..8bf2654370 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2162,7 +2162,7 @@ dependencies = [ [[package]] name = "blade-graphics" version = "0.6.0" -source = "git+https://github.com/kvark/blade?rev=416375211bb0b5826b3584dccdb6a43369e499ad#416375211bb0b5826b3584dccdb6a43369e499ad" +source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5" dependencies = [ "ash", "ash-window", @@ -2195,7 +2195,7 @@ dependencies = [ [[package]] name = "blade-macros" version = "0.3.0" -source = "git+https://github.com/kvark/blade?rev=416375211bb0b5826b3584dccdb6a43369e499ad#416375211bb0b5826b3584dccdb6a43369e499ad" +source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5" dependencies = [ "proc-macro2", "quote", @@ -2205,7 +2205,7 @@ dependencies = [ [[package]] name = "blade-util" version = "0.2.0" -source = "git+https://github.com/kvark/blade?rev=416375211bb0b5826b3584dccdb6a43369e499ad#416375211bb0b5826b3584dccdb6a43369e499ad" +source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5" dependencies = [ "blade-graphics", "bytemuck", diff --git a/Cargo.toml b/Cargo.toml index 1be2eb8d77..8d942a4c73 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -436,9 +436,9 @@ aws-smithy-runtime-api = { version = "1.7.4", features = ["http-1x", "client"] } aws-smithy-types = { version = "1.3.0", features = ["http-body-1-x"] } base64 = "0.22" bitflags = "2.6.0" -blade-graphics = { git = "https://github.com/kvark/blade", rev = "416375211bb0b5826b3584dccdb6a43369e499ad" } -blade-macros = { git = "https://github.com/kvark/blade", rev = "416375211bb0b5826b3584dccdb6a43369e499ad" } -blade-util = { git = "https://github.com/kvark/blade", rev = "416375211bb0b5826b3584dccdb6a43369e499ad" } +blade-graphics = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" } +blade-macros = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" } +blade-util = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" } blake3 = "1.5.3" bytes = "1.0" cargo_metadata = "0.19" @@ -491,7 +491,7 @@ json_dotpath = "1.1" jsonschema = "0.30.0" jsonwebtoken = "9.3" jupyter-protocol = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" } -jupyter-websocket-client = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" } +jupyter-websocket-client = { git = "https://github.com/ConradIrwin/runtimed" ,rev = "7130c804216b6914355d15d0b91ea91f6babd734" } libc = "0.2" libsqlite3-sys = { version = "0.30.1", features = ["bundled"] } linkify = "0.10.0" @@ -502,7 +502,7 @@ metal = "0.29" moka = { version = "0.12.10", features = ["sync"] } naga = { version = "25.0", features = ["wgsl-in"] } nanoid = "0.4" -nbformat = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" } +nbformat = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" } nix = "0.29" num-format = "0.4.4" objc = "0.2" @@ -543,7 +543,7 @@ reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "951c77 "stream", ] } rsa = "0.9.6" -runtimelib = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734", default-features = false, features = [ +runtimelib = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734", default-features = false, features = [ "async-dispatcher-runtime", ] } rust-embed = { version = "8.4", features = ["include-exclude"] } diff --git a/crates/gpui/build.rs b/crates/gpui/build.rs index b9496cc014..aed4397440 100644 --- a/crates/gpui/build.rs +++ b/crates/gpui/build.rs @@ -126,7 +126,7 @@ mod macos { "ContentMask".into(), "Uniforms".into(), "AtlasTile".into(), - "PathInputIndex".into(), + "PathRasterizationInputIndex".into(), "PathVertex_ScaledPixels".into(), "ShadowInputIndex".into(), "Shadow".into(), diff --git a/crates/gpui/examples/painting.rs b/crates/gpui/examples/painting.rs index 9ab58cffc9..ff4b64cbda 100644 --- a/crates/gpui/examples/painting.rs +++ b/crates/gpui/examples/painting.rs @@ -1,13 +1,9 @@ use gpui::{ Application, Background, Bounds, ColorSpace, Context, MouseDownEvent, Path, PathBuilder, - PathStyle, Pixels, Point, Render, SharedString, StrokeOptions, Window, WindowBounds, - WindowOptions, canvas, div, linear_color_stop, linear_gradient, point, prelude::*, px, rgb, - size, + PathStyle, Pixels, Point, Render, SharedString, StrokeOptions, Window, WindowOptions, canvas, + div, linear_color_stop, linear_gradient, point, prelude::*, px, rgb, size, }; -const DEFAULT_WINDOW_WIDTH: Pixels = px(1024.0); -const DEFAULT_WINDOW_HEIGHT: Pixels = px(768.0); - struct PaintingViewer { default_lines: Vec<(Path, Background)>, lines: Vec>>, @@ -151,6 +147,8 @@ impl PaintingViewer { px(320.0 + (i as f32 * 10.0).sin() * 40.0), )); } + let path = builder.build().unwrap(); + lines.push((path, gpui::green().into())); Self { default_lines: lines.clone(), @@ -185,13 +183,9 @@ fn button( } impl Render for PaintingViewer { - fn render(&mut self, window: &mut Window, cx: &mut Context) -> impl IntoElement { - window.request_animation_frame(); - + fn render(&mut self, _: &mut Window, cx: &mut Context) -> impl IntoElement { let default_lines = self.default_lines.clone(); let lines = self.lines.clone(); - let window_size = window.bounds().size; - let scale = window_size.width / DEFAULT_WINDOW_WIDTH; let dashed = self.dashed; div() @@ -228,7 +222,7 @@ impl Render for PaintingViewer { move |_, _, _| {}, move |_, _, window, _| { for (path, color) in default_lines { - window.paint_path(path.clone().scale(scale), color); + window.paint_path(path, color); } for points in lines { @@ -304,11 +298,6 @@ fn main() { cx.open_window( WindowOptions { focus: true, - window_bounds: Some(WindowBounds::Windowed(Bounds::centered( - None, - size(DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT), - cx, - ))), ..Default::default() }, |window, cx| cx.new(|cx| PaintingViewer::new(window, cx)), diff --git a/crates/gpui/src/path_builder.rs b/crates/gpui/src/path_builder.rs index 13c168b0bb..6c8cfddd52 100644 --- a/crates/gpui/src/path_builder.rs +++ b/crates/gpui/src/path_builder.rs @@ -336,7 +336,10 @@ impl PathBuilder { let v1 = buf.vertices[i1]; let v2 = buf.vertices[i2]; - path.push_triangle((v0.into(), v1.into(), v2.into())); + path.push_triangle( + (v0.into(), v1.into(), v2.into()), + (point(0., 1.), point(0., 1.), point(0., 1.)), + ); } path diff --git a/crates/gpui/src/platform.rs b/crates/gpui/src/platform.rs index 0250e59a9b..8918fdd28b 100644 --- a/crates/gpui/src/platform.rs +++ b/crates/gpui/src/platform.rs @@ -794,6 +794,7 @@ pub(crate) struct AtlasTextureId { pub(crate) enum AtlasTextureKind { Monochrome = 0, Polychrome = 1, + Path = 2, } #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] diff --git a/crates/gpui/src/platform/blade/blade_atlas.rs b/crates/gpui/src/platform/blade/blade_atlas.rs index 0b119c3910..78ba52056a 100644 --- a/crates/gpui/src/platform/blade/blade_atlas.rs +++ b/crates/gpui/src/platform/blade/blade_atlas.rs @@ -10,6 +10,8 @@ use etagere::BucketedAtlasAllocator; use parking_lot::Mutex; use std::{borrow::Cow, ops, sync::Arc}; +pub(crate) const PATH_TEXTURE_FORMAT: gpu::TextureFormat = gpu::TextureFormat::R16Float; + pub(crate) struct BladeAtlas(Mutex); struct PendingUpload { @@ -25,6 +27,7 @@ struct BladeAtlasState { tiles_by_key: FxHashMap, initializations: Vec, uploads: Vec, + path_sample_count: u32, } #[cfg(gles)] @@ -38,13 +41,13 @@ impl BladeAtlasState { } pub struct BladeTextureInfo { - #[allow(dead_code)] pub size: gpu::Extent, pub raw_view: gpu::TextureView, + pub msaa_view: Option, } impl BladeAtlas { - pub(crate) fn new(gpu: &Arc) -> Self { + pub(crate) fn new(gpu: &Arc, path_sample_count: u32) -> Self { BladeAtlas(Mutex::new(BladeAtlasState { gpu: Arc::clone(gpu), upload_belt: BufferBelt::new(BufferBeltDescriptor { @@ -56,6 +59,7 @@ impl BladeAtlas { tiles_by_key: Default::default(), initializations: Vec::new(), uploads: Vec::new(), + path_sample_count, })) } @@ -63,7 +67,6 @@ impl BladeAtlas { self.0.lock().destroy(); } - #[allow(dead_code)] pub(crate) fn clear_textures(&self, texture_kind: AtlasTextureKind) { let mut lock = self.0.lock(); let textures = &mut lock.storage[texture_kind]; @@ -72,6 +75,19 @@ impl BladeAtlas { } } + /// Allocate a rectangle and make it available for rendering immediately (without waiting for `before_frame`) + pub fn allocate_for_rendering( + &self, + size: Size, + texture_kind: AtlasTextureKind, + gpu_encoder: &mut gpu::CommandEncoder, + ) -> AtlasTile { + let mut lock = self.0.lock(); + let tile = lock.allocate(size, texture_kind); + lock.flush_initializations(gpu_encoder); + tile + } + pub fn before_frame(&self, gpu_encoder: &mut gpu::CommandEncoder) { let mut lock = self.0.lock(); lock.flush(gpu_encoder); @@ -93,6 +109,7 @@ impl BladeAtlas { depth: 1, }, raw_view: texture.raw_view, + msaa_view: texture.msaa_view, } } } @@ -183,8 +200,48 @@ impl BladeAtlasState { format = gpu::TextureFormat::Bgra8UnormSrgb; usage = gpu::TextureUsage::COPY | gpu::TextureUsage::RESOURCE; } + AtlasTextureKind::Path => { + format = PATH_TEXTURE_FORMAT; + usage = gpu::TextureUsage::COPY + | gpu::TextureUsage::RESOURCE + | gpu::TextureUsage::TARGET; + } } + // We currently only enable MSAA for path textures. + let (msaa, msaa_view) = if self.path_sample_count > 1 && kind == AtlasTextureKind::Path { + let msaa = self.gpu.create_texture(gpu::TextureDesc { + name: "msaa path texture", + format, + size: gpu::Extent { + width: size.width.into(), + height: size.height.into(), + depth: 1, + }, + array_layer_count: 1, + mip_level_count: 1, + sample_count: self.path_sample_count, + dimension: gpu::TextureDimension::D2, + usage: gpu::TextureUsage::TARGET, + external: None, + }); + + ( + Some(msaa), + Some(self.gpu.create_texture_view( + msaa, + gpu::TextureViewDesc { + name: "msaa texture view", + format, + dimension: gpu::ViewDimension::D2, + subresources: &Default::default(), + }, + )), + ) + } else { + (None, None) + }; + let raw = self.gpu.create_texture(gpu::TextureDesc { name: "atlas", format, @@ -222,6 +279,8 @@ impl BladeAtlasState { format, raw, raw_view, + msaa, + msaa_view, live_atlas_keys: 0, }; @@ -281,6 +340,7 @@ impl BladeAtlasState { struct BladeAtlasStorage { monochrome_textures: AtlasTextureList, polychrome_textures: AtlasTextureList, + path_textures: AtlasTextureList, } impl ops::Index for BladeAtlasStorage { @@ -289,6 +349,7 @@ impl ops::Index for BladeAtlasStorage { match kind { crate::AtlasTextureKind::Monochrome => &self.monochrome_textures, crate::AtlasTextureKind::Polychrome => &self.polychrome_textures, + crate::AtlasTextureKind::Path => &self.path_textures, } } } @@ -298,6 +359,7 @@ impl ops::IndexMut for BladeAtlasStorage { match kind { crate::AtlasTextureKind::Monochrome => &mut self.monochrome_textures, crate::AtlasTextureKind::Polychrome => &mut self.polychrome_textures, + crate::AtlasTextureKind::Path => &mut self.path_textures, } } } @@ -308,6 +370,7 @@ impl ops::Index for BladeAtlasStorage { let textures = match id.kind { crate::AtlasTextureKind::Monochrome => &self.monochrome_textures, crate::AtlasTextureKind::Polychrome => &self.polychrome_textures, + crate::AtlasTextureKind::Path => &self.path_textures, }; textures[id.index as usize].as_ref().unwrap() } @@ -321,6 +384,9 @@ impl BladeAtlasStorage { for mut texture in self.polychrome_textures.drain().flatten() { texture.destroy(gpu); } + for mut texture in self.path_textures.drain().flatten() { + texture.destroy(gpu); + } } } @@ -329,6 +395,8 @@ struct BladeAtlasTexture { allocator: BucketedAtlasAllocator, raw: gpu::Texture, raw_view: gpu::TextureView, + msaa: Option, + msaa_view: Option, format: gpu::TextureFormat, live_atlas_keys: u32, } @@ -356,6 +424,12 @@ impl BladeAtlasTexture { fn destroy(&mut self, gpu: &gpu::Context) { gpu.destroy_texture(self.raw); gpu.destroy_texture_view(self.raw_view); + if let Some(msaa) = self.msaa { + gpu.destroy_texture(msaa); + } + if let Some(msaa_view) = self.msaa_view { + gpu.destroy_texture_view(msaa_view); + } } fn bytes_per_pixel(&self) -> u8 { diff --git a/crates/gpui/src/platform/blade/blade_renderer.rs b/crates/gpui/src/platform/blade/blade_renderer.rs index 1b9f111b0d..cac47434ae 100644 --- a/crates/gpui/src/platform/blade/blade_renderer.rs +++ b/crates/gpui/src/platform/blade/blade_renderer.rs @@ -1,19 +1,24 @@ // Doing `if let` gives you nice scoping with passes/encoders #![allow(irrefutable_let_patterns)] -use super::{BladeAtlas, BladeContext}; +use super::{BladeAtlas, BladeContext, PATH_TEXTURE_FORMAT}; use crate::{ - Background, Bounds, ContentMask, DevicePixels, GpuSpecs, MonochromeSprite, PathVertex, - PolychromeSprite, PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow, Size, Underline, + AtlasTextureKind, AtlasTile, Background, Bounds, ContentMask, DevicePixels, GpuSpecs, + MonochromeSprite, Path, PathId, PathVertex, PolychromeSprite, PrimitiveBatch, Quad, + ScaledPixels, Scene, Shadow, Size, Underline, }; -use blade_graphics::{self as gpu}; +use blade_graphics as gpu; use blade_util::{BufferBelt, BufferBeltDescriptor}; use bytemuck::{Pod, Zeroable}; +use collections::HashMap; #[cfg(target_os = "macos")] use media::core_video::CVMetalTextureCache; use std::{mem, sync::Arc}; const MAX_FRAME_TIME_MS: u32 = 10000; +// Use 4x MSAA, all devices support it. +// https://developer.apple.com/documentation/metal/mtldevice/1433355-supportstexturesamplecount +const DEFAULT_PATH_SAMPLE_COUNT: u32 = 4; #[repr(C)] #[derive(Clone, Copy, Pod, Zeroable)] @@ -61,9 +66,16 @@ struct ShaderShadowsData { } #[derive(blade_macros::ShaderData)] -struct ShaderPathsData { +struct ShaderPathRasterizationData { globals: GlobalParams, b_path_vertices: gpu::BufferPiece, +} + +#[derive(blade_macros::ShaderData)] +struct ShaderPathsData { + globals: GlobalParams, + t_sprite: gpu::TextureView, + s_sprite: gpu::Sampler, b_path_sprites: gpu::BufferPiece, } @@ -103,27 +115,13 @@ struct ShaderSurfacesData { struct PathSprite { bounds: Bounds, color: Background, -} - -/// Argument buffer layout for `draw_indirect` commands. -#[repr(C)] -#[derive(Copy, Clone, Debug, Default, Pod, Zeroable)] -pub struct DrawIndirectArgs { - /// The number of vertices to draw. - pub vertex_count: u32, - /// The number of instances to draw. - pub instance_count: u32, - /// The Index of the first vertex to draw. - pub first_vertex: u32, - /// The instance ID of the first instance to draw. - /// - /// Has to be 0, unless [`Features::INDIRECT_FIRST_INSTANCE`](crate::Features::INDIRECT_FIRST_INSTANCE) is enabled. - pub first_instance: u32, + tile: AtlasTile, } struct BladePipelines { quads: gpu::RenderPipeline, shadows: gpu::RenderPipeline, + path_rasterization: gpu::RenderPipeline, paths: gpu::RenderPipeline, underlines: gpu::RenderPipeline, mono_sprites: gpu::RenderPipeline, @@ -132,7 +130,7 @@ struct BladePipelines { } impl BladePipelines { - fn new(gpu: &gpu::Context, surface_info: gpu::SurfaceInfo, sample_count: u32) -> Self { + fn new(gpu: &gpu::Context, surface_info: gpu::SurfaceInfo, path_sample_count: u32) -> Self { use gpu::ShaderData as _; log::info!( @@ -180,10 +178,7 @@ impl BladePipelines { depth_stencil: None, fragment: Some(shader.at("fs_quad")), color_targets, - multisample_state: gpu::MultisampleState { - sample_count, - ..Default::default() - }, + multisample_state: gpu::MultisampleState::default(), }), shadows: gpu.create_render_pipeline(gpu::RenderPipelineDesc { name: "shadows", @@ -197,8 +192,26 @@ impl BladePipelines { depth_stencil: None, fragment: Some(shader.at("fs_shadow")), color_targets, + multisample_state: gpu::MultisampleState::default(), + }), + path_rasterization: gpu.create_render_pipeline(gpu::RenderPipelineDesc { + name: "path_rasterization", + data_layouts: &[&ShaderPathRasterizationData::layout()], + vertex: shader.at("vs_path_rasterization"), + vertex_fetches: &[], + primitive: gpu::PrimitiveState { + topology: gpu::PrimitiveTopology::TriangleList, + ..Default::default() + }, + depth_stencil: None, + fragment: Some(shader.at("fs_path_rasterization")), + color_targets: &[gpu::ColorTargetState { + format: PATH_TEXTURE_FORMAT, + blend: Some(gpu::BlendState::ADDITIVE), + write_mask: gpu::ColorWrites::default(), + }], multisample_state: gpu::MultisampleState { - sample_count, + sample_count: path_sample_count, ..Default::default() }, }), @@ -208,16 +221,13 @@ impl BladePipelines { vertex: shader.at("vs_path"), vertex_fetches: &[], primitive: gpu::PrimitiveState { - topology: gpu::PrimitiveTopology::TriangleList, + topology: gpu::PrimitiveTopology::TriangleStrip, ..Default::default() }, depth_stencil: None, fragment: Some(shader.at("fs_path")), color_targets, - multisample_state: gpu::MultisampleState { - sample_count, - ..Default::default() - }, + multisample_state: gpu::MultisampleState::default(), }), underlines: gpu.create_render_pipeline(gpu::RenderPipelineDesc { name: "underlines", @@ -231,10 +241,7 @@ impl BladePipelines { depth_stencil: None, fragment: Some(shader.at("fs_underline")), color_targets, - multisample_state: gpu::MultisampleState { - sample_count, - ..Default::default() - }, + multisample_state: gpu::MultisampleState::default(), }), mono_sprites: gpu.create_render_pipeline(gpu::RenderPipelineDesc { name: "mono-sprites", @@ -248,10 +255,7 @@ impl BladePipelines { depth_stencil: None, fragment: Some(shader.at("fs_mono_sprite")), color_targets, - multisample_state: gpu::MultisampleState { - sample_count, - ..Default::default() - }, + multisample_state: gpu::MultisampleState::default(), }), poly_sprites: gpu.create_render_pipeline(gpu::RenderPipelineDesc { name: "poly-sprites", @@ -265,10 +269,7 @@ impl BladePipelines { depth_stencil: None, fragment: Some(shader.at("fs_poly_sprite")), color_targets, - multisample_state: gpu::MultisampleState { - sample_count, - ..Default::default() - }, + multisample_state: gpu::MultisampleState::default(), }), surfaces: gpu.create_render_pipeline(gpu::RenderPipelineDesc { name: "surfaces", @@ -282,10 +283,7 @@ impl BladePipelines { depth_stencil: None, fragment: Some(shader.at("fs_surface")), color_targets, - multisample_state: gpu::MultisampleState { - sample_count, - ..Default::default() - }, + multisample_state: gpu::MultisampleState::default(), }), } } @@ -293,6 +291,7 @@ impl BladePipelines { fn destroy(&mut self, gpu: &gpu::Context) { gpu.destroy_render_pipeline(&mut self.quads); gpu.destroy_render_pipeline(&mut self.shadows); + gpu.destroy_render_pipeline(&mut self.path_rasterization); gpu.destroy_render_pipeline(&mut self.paths); gpu.destroy_render_pipeline(&mut self.underlines); gpu.destroy_render_pipeline(&mut self.mono_sprites); @@ -318,13 +317,12 @@ pub struct BladeRenderer { last_sync_point: Option, pipelines: BladePipelines, instance_belt: BufferBelt, + path_tiles: HashMap, atlas: Arc, atlas_sampler: gpu::Sampler, #[cfg(target_os = "macos")] core_video_texture_cache: CVMetalTextureCache, - sample_count: u32, - texture_msaa: Option, - texture_view_msaa: Option, + path_sample_count: u32, } impl BladeRenderer { @@ -333,18 +331,6 @@ impl BladeRenderer { window: &I, config: BladeSurfaceConfig, ) -> anyhow::Result { - // workaround for https://github.com/zed-industries/zed/issues/26143 - let sample_count = std::env::var("ZED_SAMPLE_COUNT") - .ok() - .or_else(|| std::env::var("ZED_PATH_SAMPLE_COUNT").ok()) - .and_then(|v| v.parse().ok()) - .or_else(|| { - [4, 2, 1] - .into_iter() - .find(|count| context.gpu.supports_texture_sample_count(*count)) - }) - .unwrap_or(1); - let surface_config = gpu::SurfaceConfig { size: config.size, usage: gpu::TextureUsage::TARGET, @@ -358,27 +344,22 @@ impl BladeRenderer { .create_surface_configured(window, surface_config) .map_err(|err| anyhow::anyhow!("Failed to create surface: {err:?}"))?; - let (texture_msaa, texture_view_msaa) = create_msaa_texture_if_needed( - &context.gpu, - surface.info().format, - config.size.width, - config.size.height, - sample_count, - ) - .unzip(); - let command_encoder = context.gpu.create_command_encoder(gpu::CommandEncoderDesc { name: "main", buffer_count: 2, }); - - let pipelines = BladePipelines::new(&context.gpu, surface.info(), sample_count); + // workaround for https://github.com/zed-industries/zed/issues/26143 + let path_sample_count = std::env::var("ZED_PATH_SAMPLE_COUNT") + .ok() + .and_then(|v| v.parse().ok()) + .unwrap_or(DEFAULT_PATH_SAMPLE_COUNT); + let pipelines = BladePipelines::new(&context.gpu, surface.info(), path_sample_count); let instance_belt = BufferBelt::new(BufferBeltDescriptor { memory: gpu::Memory::Shared, min_chunk_size: 0x1000, alignment: 0x40, // Vulkan `minStorageBufferOffsetAlignment` on Intel Xe }); - let atlas = Arc::new(BladeAtlas::new(&context.gpu)); + let atlas = Arc::new(BladeAtlas::new(&context.gpu, path_sample_count)); let atlas_sampler = context.gpu.create_sampler(gpu::SamplerDesc { name: "atlas", mag_filter: gpu::FilterMode::Linear, @@ -402,13 +383,12 @@ impl BladeRenderer { last_sync_point: None, pipelines, instance_belt, + path_tiles: HashMap::default(), atlas, atlas_sampler, #[cfg(target_os = "macos")] core_video_texture_cache, - sample_count, - texture_msaa, - texture_view_msaa, + path_sample_count, }) } @@ -461,24 +441,6 @@ impl BladeRenderer { self.surface_config.size = gpu_size; self.gpu .reconfigure_surface(&mut self.surface, self.surface_config); - - if let Some(texture_msaa) = self.texture_msaa { - self.gpu.destroy_texture(texture_msaa); - } - if let Some(texture_view_msaa) = self.texture_view_msaa { - self.gpu.destroy_texture_view(texture_view_msaa); - } - - let (texture_msaa, texture_view_msaa) = create_msaa_texture_if_needed( - &self.gpu, - self.surface.info().format, - gpu_size.width, - gpu_size.height, - self.sample_count, - ) - .unzip(); - self.texture_msaa = texture_msaa; - self.texture_view_msaa = texture_view_msaa; } } @@ -489,7 +451,8 @@ impl BladeRenderer { self.gpu .reconfigure_surface(&mut self.surface, self.surface_config); self.pipelines.destroy(&self.gpu); - self.pipelines = BladePipelines::new(&self.gpu, self.surface.info(), self.sample_count); + self.pipelines = + BladePipelines::new(&self.gpu, self.surface.info(), self.path_sample_count); } } @@ -527,6 +490,80 @@ impl BladeRenderer { objc2::rc::Retained::as_ptr(&self.surface.metal_layer()) as *mut _ } + #[profiling::function] + fn rasterize_paths(&mut self, paths: &[Path]) { + self.path_tiles.clear(); + let mut vertices_by_texture_id = HashMap::default(); + + for path in paths { + let clipped_bounds = path + .bounds + .intersect(&path.content_mask.bounds) + .map_origin(|origin| origin.floor()) + .map_size(|size| size.ceil()); + let tile = self.atlas.allocate_for_rendering( + clipped_bounds.size.map(Into::into), + AtlasTextureKind::Path, + &mut self.command_encoder, + ); + vertices_by_texture_id + .entry(tile.texture_id) + .or_insert(Vec::new()) + .extend(path.vertices.iter().map(|vertex| PathVertex { + xy_position: vertex.xy_position - clipped_bounds.origin + + tile.bounds.origin.map(Into::into), + st_position: vertex.st_position, + content_mask: ContentMask { + bounds: tile.bounds.map(Into::into), + }, + })); + self.path_tiles.insert(path.id, tile); + } + + for (texture_id, vertices) in vertices_by_texture_id { + let tex_info = self.atlas.get_texture_info(texture_id); + let globals = GlobalParams { + viewport_size: [tex_info.size.width as f32, tex_info.size.height as f32], + premultiplied_alpha: 0, + pad: 0, + }; + + let vertex_buf = unsafe { self.instance_belt.alloc_typed(&vertices, &self.gpu) }; + let frame_view = tex_info.raw_view; + let color_target = if let Some(msaa_view) = tex_info.msaa_view { + gpu::RenderTarget { + view: msaa_view, + init_op: gpu::InitOp::Clear(gpu::TextureColor::OpaqueBlack), + finish_op: gpu::FinishOp::ResolveTo(frame_view), + } + } else { + gpu::RenderTarget { + view: frame_view, + init_op: gpu::InitOp::Clear(gpu::TextureColor::OpaqueBlack), + finish_op: gpu::FinishOp::Store, + } + }; + + if let mut pass = self.command_encoder.render( + "paths", + gpu::RenderTargetSet { + colors: &[color_target], + depth_stencil: None, + }, + ) { + let mut encoder = pass.with(&self.pipelines.path_rasterization); + encoder.bind( + 0, + &ShaderPathRasterizationData { + globals, + b_path_vertices: vertex_buf, + }, + ); + encoder.draw(0, vertices.len() as u32, 0, 1); + } + } + } + pub fn destroy(&mut self) { self.wait_for_gpu(); self.atlas.destroy(); @@ -535,26 +572,17 @@ impl BladeRenderer { self.gpu.destroy_command_encoder(&mut self.command_encoder); self.pipelines.destroy(&self.gpu); self.gpu.destroy_surface(&mut self.surface); - if let Some(texture_msaa) = self.texture_msaa { - self.gpu.destroy_texture(texture_msaa); - } - if let Some(texture_view_msaa) = self.texture_view_msaa { - self.gpu.destroy_texture_view(texture_view_msaa); - } } pub fn draw(&mut self, scene: &Scene) { self.command_encoder.start(); self.atlas.before_frame(&mut self.command_encoder); + self.rasterize_paths(scene.paths()); let frame = { profiling::scope!("acquire frame"); self.surface.acquire_frame() }; - let frame_view = frame.texture_view(); - if let Some(texture_msaa) = self.texture_msaa { - self.command_encoder.init_texture(texture_msaa); - } self.command_encoder.init_texture(frame.texture()); let globals = GlobalParams { @@ -569,25 +597,14 @@ impl BladeRenderer { pad: 0, }; - let target = if let Some(texture_view_msaa) = self.texture_view_msaa { - gpu::RenderTarget { - view: texture_view_msaa, - init_op: gpu::InitOp::Clear(gpu::TextureColor::TransparentBlack), - finish_op: gpu::FinishOp::ResolveTo(frame_view), - } - } else { - gpu::RenderTarget { - view: frame_view, - init_op: gpu::InitOp::Clear(gpu::TextureColor::TransparentBlack), - finish_op: gpu::FinishOp::Store, - } - }; - - // draw to the target texture if let mut pass = self.command_encoder.render( "main", gpu::RenderTargetSet { - colors: &[target], + colors: &[gpu::RenderTarget { + view: frame.texture_view(), + init_op: gpu::InitOp::Clear(gpu::TextureColor::TransparentBlack), + finish_op: gpu::FinishOp::Store, + }], depth_stencil: None, }, ) { @@ -622,55 +639,32 @@ impl BladeRenderer { } PrimitiveBatch::Paths(paths) => { let mut encoder = pass.with(&self.pipelines.paths); - - let mut vertices = Vec::new(); - let mut sprites = Vec::with_capacity(paths.len()); - let mut draw_indirect_commands = Vec::with_capacity(paths.len()); - let mut first_vertex = 0; - - for (i, path) in paths.iter().enumerate() { - draw_indirect_commands.push(DrawIndirectArgs { - vertex_count: path.vertices.len() as u32, - instance_count: 1, - first_vertex, - first_instance: i as u32, - }); - first_vertex += path.vertices.len() as u32; - - vertices.extend(path.vertices.iter().map(|v| PathVertex { - xy_position: v.xy_position, - content_mask: ContentMask { - bounds: path.content_mask.bounds, + // todo(linux): group by texture ID + for path in paths { + let tile = &self.path_tiles[&path.id]; + let tex_info = self.atlas.get_texture_info(tile.texture_id); + let origin = path.bounds.intersect(&path.content_mask.bounds).origin; + let sprites = [PathSprite { + bounds: Bounds { + origin: origin.map(|p| p.floor()), + size: tile.bounds.size.map(Into::into), }, - })); - - sprites.push(PathSprite { - bounds: path.bounds, color: path.color, - }); - } + tile: (*tile).clone(), + }]; - let b_path_vertices = - unsafe { self.instance_belt.alloc_typed(&vertices, &self.gpu) }; - let instance_buf = - unsafe { self.instance_belt.alloc_typed(&sprites, &self.gpu) }; - let indirect_buf = unsafe { - self.instance_belt - .alloc_typed(&draw_indirect_commands, &self.gpu) - }; - - encoder.bind( - 0, - &ShaderPathsData { - globals, - b_path_vertices, - b_path_sprites: instance_buf, - }, - ); - - for i in 0..paths.len() { - encoder.draw_indirect(indirect_buf.buffer.at(indirect_buf.offset - + (i * mem::size_of::()) as u64)); + let instance_buf = + unsafe { self.instance_belt.alloc_typed(&sprites, &self.gpu) }; + encoder.bind( + 0, + &ShaderPathsData { + globals, + t_sprite: tex_info.raw_view, + s_sprite: self.atlas_sampler, + b_path_sprites: instance_buf, + }, + ); + encoder.draw(0, 4, 0, sprites.len() as u32); } } PrimitiveBatch::Underlines(underlines) => { @@ -823,47 +817,9 @@ impl BladeRenderer { profiling::scope!("finish"); self.instance_belt.flush(&sync_point); self.atlas.after_frame(&sync_point); + self.atlas.clear_textures(AtlasTextureKind::Path); self.wait_for_gpu(); self.last_sync_point = Some(sync_point); } } - -fn create_msaa_texture_if_needed( - gpu: &gpu::Context, - format: gpu::TextureFormat, - width: u32, - height: u32, - sample_count: u32, -) -> Option<(gpu::Texture, gpu::TextureView)> { - if sample_count <= 1 { - return None; - } - - let texture_msaa = gpu.create_texture(gpu::TextureDesc { - name: "msaa", - format, - size: gpu::Extent { - width, - height, - depth: 1, - }, - array_layer_count: 1, - mip_level_count: 1, - sample_count, - dimension: gpu::TextureDimension::D2, - usage: gpu::TextureUsage::TARGET, - external: None, - }); - let texture_view_msaa = gpu.create_texture_view( - texture_msaa, - gpu::TextureViewDesc { - name: "msaa view", - format, - dimension: gpu::ViewDimension::D2, - subresources: &Default::default(), - }, - ); - - Some((texture_msaa, texture_view_msaa)) -} diff --git a/crates/gpui/src/platform/blade/shaders.wgsl b/crates/gpui/src/platform/blade/shaders.wgsl index 00c9d07af7..0b34a0eea3 100644 --- a/crates/gpui/src/platform/blade/shaders.wgsl +++ b/crates/gpui/src/platform/blade/shaders.wgsl @@ -922,23 +922,59 @@ fn fs_shadow(input: ShadowVarying) -> @location(0) vec4 { return blend_color(input.color, alpha); } -// --- paths --- // +// --- path rasterization --- // struct PathVertex { xy_position: vec2, + st_position: vec2, content_mask: Bounds, } +var b_path_vertices: array; + +struct PathRasterizationVarying { + @builtin(position) position: vec4, + @location(0) st_position: vec2, + //TODO: use `clip_distance` once Naga supports it + @location(3) clip_distances: vec4, +} + +@vertex +fn vs_path_rasterization(@builtin(vertex_index) vertex_id: u32) -> PathRasterizationVarying { + let v = b_path_vertices[vertex_id]; + + var out = PathRasterizationVarying(); + out.position = to_device_position_impl(v.xy_position); + out.st_position = v.st_position; + out.clip_distances = distance_from_clip_rect_impl(v.xy_position, v.content_mask); + return out; +} + +@fragment +fn fs_path_rasterization(input: PathRasterizationVarying) -> @location(0) f32 { + let dx = dpdx(input.st_position); + let dy = dpdy(input.st_position); + if (any(input.clip_distances < vec4(0.0))) { + return 0.0; + } + + let gradient = 2.0 * input.st_position.xx * vec2(dx.x, dy.x) - vec2(dx.y, dy.y); + let f = input.st_position.x * input.st_position.x - input.st_position.y; + let distance = f / length(gradient); + return saturate(0.5 - distance); +} + +// --- paths --- // struct PathSprite { bounds: Bounds, color: Background, + tile: AtlasTile, } -var b_path_vertices: array; var b_path_sprites: array; struct PathVarying { @builtin(position) position: vec4, - @location(0) clip_distances: vec4, + @location(0) tile_position: vec2, @location(1) @interpolate(flat) instance_id: u32, @location(2) @interpolate(flat) color_solid: vec4, @location(3) @interpolate(flat) color0: vec4, @@ -947,12 +983,13 @@ struct PathVarying { @vertex fn vs_path(@builtin(vertex_index) vertex_id: u32, @builtin(instance_index) instance_id: u32) -> PathVarying { - let v = b_path_vertices[vertex_id]; + let unit_vertex = vec2(f32(vertex_id & 1u), 0.5 * f32(vertex_id & 2u)); let sprite = b_path_sprites[instance_id]; + // Don't apply content mask because it was already accounted for when rasterizing the path. var out = PathVarying(); - out.position = to_device_position_impl(v.xy_position); - out.clip_distances = distance_from_clip_rect_impl(v.xy_position, v.content_mask); + out.position = to_device_position(unit_vertex, sprite.bounds); + out.tile_position = to_tile_position(unit_vertex, sprite.tile); out.instance_id = instance_id; let gradient = prepare_gradient_color( @@ -969,15 +1006,13 @@ fn vs_path(@builtin(vertex_index) vertex_id: u32, @builtin(instance_index) insta @fragment fn fs_path(input: PathVarying) -> @location(0) vec4 { - if any(input.clip_distances < vec4(0.0)) { - return vec4(0.0); - } - + let sample = textureSample(t_sprite, s_sprite, input.tile_position).r; + let mask = 1.0 - abs(1.0 - sample % 2.0); let sprite = b_path_sprites[input.instance_id]; let background = sprite.color; let color = gradient_color(background, input.position.xy, sprite.bounds, input.color_solid, input.color0, input.color1); - return blend_color(color, 1.0); + return blend_color(color, mask); } // --- underlines --- // diff --git a/crates/gpui/src/platform/mac/metal_atlas.rs b/crates/gpui/src/platform/mac/metal_atlas.rs index 0c8e1d3703..366f2dcc3c 100644 --- a/crates/gpui/src/platform/mac/metal_atlas.rs +++ b/crates/gpui/src/platform/mac/metal_atlas.rs @@ -13,12 +13,14 @@ use std::borrow::Cow; pub(crate) struct MetalAtlas(Mutex); impl MetalAtlas { - pub(crate) fn new(device: Device) -> Self { + pub(crate) fn new(device: Device, path_sample_count: u32) -> Self { MetalAtlas(Mutex::new(MetalAtlasState { device: AssertSend(device), monochrome_textures: Default::default(), polychrome_textures: Default::default(), + path_textures: Default::default(), tiles_by_key: Default::default(), + path_sample_count, })) } @@ -26,7 +28,10 @@ impl MetalAtlas { self.0.lock().texture(id).metal_texture.clone() } - #[allow(dead_code)] + pub(crate) fn msaa_texture(&self, id: AtlasTextureId) -> Option { + self.0.lock().texture(id).msaa_texture.clone() + } + pub(crate) fn allocate( &self, size: Size, @@ -35,12 +40,12 @@ impl MetalAtlas { self.0.lock().allocate(size, texture_kind) } - #[allow(dead_code)] pub(crate) fn clear_textures(&self, texture_kind: AtlasTextureKind) { let mut lock = self.0.lock(); let textures = match texture_kind { AtlasTextureKind::Monochrome => &mut lock.monochrome_textures, AtlasTextureKind::Polychrome => &mut lock.polychrome_textures, + AtlasTextureKind::Path => &mut lock.path_textures, }; for texture in textures.iter_mut() { texture.clear(); @@ -52,7 +57,9 @@ struct MetalAtlasState { device: AssertSend, monochrome_textures: AtlasTextureList, polychrome_textures: AtlasTextureList, + path_textures: AtlasTextureList, tiles_by_key: FxHashMap, + path_sample_count: u32, } impl PlatformAtlas for MetalAtlas { @@ -87,6 +94,7 @@ impl PlatformAtlas for MetalAtlas { let textures = match id.kind { AtlasTextureKind::Monochrome => &mut lock.monochrome_textures, AtlasTextureKind::Polychrome => &mut lock.polychrome_textures, + AtlasTextureKind::Path => &mut lock.polychrome_textures, }; let Some(texture_slot) = textures @@ -120,6 +128,7 @@ impl MetalAtlasState { let textures = match texture_kind { AtlasTextureKind::Monochrome => &mut self.monochrome_textures, AtlasTextureKind::Polychrome => &mut self.polychrome_textures, + AtlasTextureKind::Path => &mut self.path_textures, }; if let Some(tile) = textures @@ -164,14 +173,31 @@ impl MetalAtlasState { pixel_format = metal::MTLPixelFormat::BGRA8Unorm; usage = metal::MTLTextureUsage::ShaderRead; } + AtlasTextureKind::Path => { + pixel_format = metal::MTLPixelFormat::R16Float; + usage = metal::MTLTextureUsage::RenderTarget | metal::MTLTextureUsage::ShaderRead; + } } texture_descriptor.set_pixel_format(pixel_format); texture_descriptor.set_usage(usage); let metal_texture = self.device.new_texture(&texture_descriptor); + // We currently only enable MSAA for path textures. + let msaa_texture = if self.path_sample_count > 1 && kind == AtlasTextureKind::Path { + let mut descriptor = texture_descriptor.clone(); + descriptor.set_texture_type(metal::MTLTextureType::D2Multisample); + descriptor.set_storage_mode(metal::MTLStorageMode::Private); + descriptor.set_sample_count(self.path_sample_count as _); + let msaa_texture = self.device.new_texture(&descriptor); + Some(msaa_texture) + } else { + None + }; + let texture_list = match kind { AtlasTextureKind::Monochrome => &mut self.monochrome_textures, AtlasTextureKind::Polychrome => &mut self.polychrome_textures, + AtlasTextureKind::Path => &mut self.path_textures, }; let index = texture_list.free_list.pop(); @@ -183,6 +209,7 @@ impl MetalAtlasState { }, allocator: etagere::BucketedAtlasAllocator::new(size.into()), metal_texture: AssertSend(metal_texture), + msaa_texture: AssertSend(msaa_texture), live_atlas_keys: 0, }; @@ -199,6 +226,7 @@ impl MetalAtlasState { let textures = match id.kind { crate::AtlasTextureKind::Monochrome => &self.monochrome_textures, crate::AtlasTextureKind::Polychrome => &self.polychrome_textures, + crate::AtlasTextureKind::Path => &self.path_textures, }; textures[id.index as usize].as_ref().unwrap() } @@ -208,6 +236,7 @@ struct MetalAtlasTexture { id: AtlasTextureId, allocator: BucketedAtlasAllocator, metal_texture: AssertSend, + msaa_texture: AssertSend>, live_atlas_keys: u32, } diff --git a/crates/gpui/src/platform/mac/metal_renderer.rs b/crates/gpui/src/platform/mac/metal_renderer.rs index 8936cf242c..3cdc2dd2cf 100644 --- a/crates/gpui/src/platform/mac/metal_renderer.rs +++ b/crates/gpui/src/platform/mac/metal_renderer.rs @@ -1,28 +1,27 @@ use super::metal_atlas::MetalAtlas; use crate::{ - AtlasTextureId, Background, Bounds, ContentMask, DevicePixels, MonochromeSprite, PaintSurface, - Path, PathVertex, PolychromeSprite, PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow, Size, - Surface, Underline, point, size, + AtlasTextureId, AtlasTextureKind, AtlasTile, Background, Bounds, ContentMask, DevicePixels, + MonochromeSprite, PaintSurface, Path, PathId, PathVertex, PolychromeSprite, PrimitiveBatch, + Quad, ScaledPixels, Scene, Shadow, Size, Surface, Underline, point, size, }; -use anyhow::Result; +use anyhow::{Context as _, Result}; use block::ConcreteBlock; use cocoa::{ base::{NO, YES}, foundation::{NSSize, NSUInteger}, quartzcore::AutoresizingMask, }; +use collections::HashMap; use core_foundation::base::TCFType; use core_video::{ metal_texture::CVMetalTextureGetTexture, metal_texture_cache::CVMetalTextureCache, pixel_buffer::kCVPixelFormatType_420YpCbCr8BiPlanarFullRange, }; use foreign_types::{ForeignType, ForeignTypeRef}; -use metal::{ - CAMetalLayer, CommandQueue, MTLDrawPrimitivesIndirectArguments, MTLPixelFormat, - MTLResourceOptions, NSRange, -}; +use metal::{CAMetalLayer, CommandQueue, MTLPixelFormat, MTLResourceOptions, NSRange}; use objc::{self, msg_send, sel, sel_impl}; use parking_lot::Mutex; +use smallvec::SmallVec; use std::{cell::Cell, ffi::c_void, mem, ptr, sync::Arc}; // Exported to metal @@ -32,6 +31,9 @@ pub(crate) type PointF = crate::Point; const SHADERS_METALLIB: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/shaders.metallib")); #[cfg(feature = "runtime_shaders")] const SHADERS_SOURCE_FILE: &str = include_str!(concat!(env!("OUT_DIR"), "/stitched_shaders.metal")); +// Use 4x MSAA, all devices support it. +// https://developer.apple.com/documentation/metal/mtldevice/1433355-supportstexturesamplecount +const PATH_SAMPLE_COUNT: u32 = 4; pub type Context = Arc>; pub type Renderer = MetalRenderer; @@ -96,7 +98,8 @@ pub(crate) struct MetalRenderer { layer: metal::MetalLayer, presents_with_transaction: bool, command_queue: CommandQueue, - path_pipeline_state: metal::RenderPipelineState, + paths_rasterization_pipeline_state: metal::RenderPipelineState, + path_sprites_pipeline_state: metal::RenderPipelineState, shadows_pipeline_state: metal::RenderPipelineState, quads_pipeline_state: metal::RenderPipelineState, underlines_pipeline_state: metal::RenderPipelineState, @@ -108,8 +111,6 @@ pub(crate) struct MetalRenderer { instance_buffer_pool: Arc>, sprite_atlas: Arc, core_video_texture_cache: core_video::metal_texture_cache::CVMetalTextureCache, - sample_count: u64, - msaa_texture: Option, } impl MetalRenderer { @@ -168,19 +169,22 @@ impl MetalRenderer { MTLResourceOptions::StorageModeManaged, ); - let sample_count = [4, 2, 1] - .into_iter() - .find(|count| device.supports_texture_sample_count(*count)) - .unwrap_or(1); - - let path_pipeline_state = build_pipeline_state( + let paths_rasterization_pipeline_state = build_path_rasterization_pipeline_state( &device, &library, - "paths", - "path_vertex", - "path_fragment", + "paths_rasterization", + "path_rasterization_vertex", + "path_rasterization_fragment", + MTLPixelFormat::R16Float, + PATH_SAMPLE_COUNT, + ); + let path_sprites_pipeline_state = build_pipeline_state( + &device, + &library, + "path_sprites", + "path_sprite_vertex", + "path_sprite_fragment", MTLPixelFormat::BGRA8Unorm, - sample_count, ); let shadows_pipeline_state = build_pipeline_state( &device, @@ -189,7 +193,6 @@ impl MetalRenderer { "shadow_vertex", "shadow_fragment", MTLPixelFormat::BGRA8Unorm, - sample_count, ); let quads_pipeline_state = build_pipeline_state( &device, @@ -198,7 +201,6 @@ impl MetalRenderer { "quad_vertex", "quad_fragment", MTLPixelFormat::BGRA8Unorm, - sample_count, ); let underlines_pipeline_state = build_pipeline_state( &device, @@ -207,7 +209,6 @@ impl MetalRenderer { "underline_vertex", "underline_fragment", MTLPixelFormat::BGRA8Unorm, - sample_count, ); let monochrome_sprites_pipeline_state = build_pipeline_state( &device, @@ -216,7 +217,6 @@ impl MetalRenderer { "monochrome_sprite_vertex", "monochrome_sprite_fragment", MTLPixelFormat::BGRA8Unorm, - sample_count, ); let polychrome_sprites_pipeline_state = build_pipeline_state( &device, @@ -225,7 +225,6 @@ impl MetalRenderer { "polychrome_sprite_vertex", "polychrome_sprite_fragment", MTLPixelFormat::BGRA8Unorm, - sample_count, ); let surfaces_pipeline_state = build_pipeline_state( &device, @@ -234,21 +233,20 @@ impl MetalRenderer { "surface_vertex", "surface_fragment", MTLPixelFormat::BGRA8Unorm, - sample_count, ); let command_queue = device.new_command_queue(); - let sprite_atlas = Arc::new(MetalAtlas::new(device.clone())); + let sprite_atlas = Arc::new(MetalAtlas::new(device.clone(), PATH_SAMPLE_COUNT)); let core_video_texture_cache = CVMetalTextureCache::new(None, device.clone(), None).unwrap(); - let msaa_texture = create_msaa_texture(&device, &layer, sample_count); Self { device, layer, presents_with_transaction: false, command_queue, - path_pipeline_state, + paths_rasterization_pipeline_state, + path_sprites_pipeline_state, shadows_pipeline_state, quads_pipeline_state, underlines_pipeline_state, @@ -259,8 +257,6 @@ impl MetalRenderer { instance_buffer_pool, sprite_atlas, core_video_texture_cache, - sample_count, - msaa_texture, } } @@ -293,8 +289,6 @@ impl MetalRenderer { setDrawableSize: size ]; } - - self.msaa_texture = create_msaa_texture(&self.device, &self.layer, self.sample_count); } pub fn update_transparency(&self, _transparent: bool) { @@ -381,23 +375,25 @@ impl MetalRenderer { let command_queue = self.command_queue.clone(); let command_buffer = command_queue.new_command_buffer(); let mut instance_offset = 0; + + let path_tiles = self + .rasterize_paths( + scene.paths(), + instance_buffer, + &mut instance_offset, + command_buffer, + ) + .with_context(|| format!("rasterizing {} paths", scene.paths().len()))?; + let render_pass_descriptor = metal::RenderPassDescriptor::new(); let color_attachment = render_pass_descriptor .color_attachments() .object_at(0) .unwrap(); - if let Some(msaa_texture_ref) = self.msaa_texture.as_deref() { - color_attachment.set_texture(Some(msaa_texture_ref)); - color_attachment.set_load_action(metal::MTLLoadAction::Clear); - color_attachment.set_store_action(metal::MTLStoreAction::MultisampleResolve); - color_attachment.set_resolve_texture(Some(drawable.texture())); - } else { - color_attachment.set_load_action(metal::MTLLoadAction::Clear); - color_attachment.set_texture(Some(drawable.texture())); - color_attachment.set_store_action(metal::MTLStoreAction::Store); - } - + color_attachment.set_texture(Some(drawable.texture())); + color_attachment.set_load_action(metal::MTLLoadAction::Clear); + color_attachment.set_store_action(metal::MTLStoreAction::Store); let alpha = if self.layer.is_opaque() { 1. } else { 0. }; color_attachment.set_clear_color(metal::MTLClearColor::new(0., 0., 0., alpha)); let command_encoder = command_buffer.new_render_command_encoder(render_pass_descriptor); @@ -429,6 +425,7 @@ impl MetalRenderer { ), PrimitiveBatch::Paths(paths) => self.draw_paths( paths, + &path_tiles, instance_buffer, &mut instance_offset, viewport_size, @@ -496,6 +493,106 @@ impl MetalRenderer { Ok(command_buffer.to_owned()) } + fn rasterize_paths( + &self, + paths: &[Path], + instance_buffer: &mut InstanceBuffer, + instance_offset: &mut usize, + command_buffer: &metal::CommandBufferRef, + ) -> Option> { + self.sprite_atlas.clear_textures(AtlasTextureKind::Path); + + let mut tiles = HashMap::default(); + let mut vertices_by_texture_id = HashMap::default(); + for path in paths { + let clipped_bounds = path.bounds.intersect(&path.content_mask.bounds); + + let tile = self + .sprite_atlas + .allocate(clipped_bounds.size.map(Into::into), AtlasTextureKind::Path)?; + vertices_by_texture_id + .entry(tile.texture_id) + .or_insert(Vec::new()) + .extend(path.vertices.iter().map(|vertex| PathVertex { + xy_position: vertex.xy_position - clipped_bounds.origin + + tile.bounds.origin.map(Into::into), + st_position: vertex.st_position, + content_mask: ContentMask { + bounds: tile.bounds.map(Into::into), + }, + })); + tiles.insert(path.id, tile); + } + + for (texture_id, vertices) in vertices_by_texture_id { + align_offset(instance_offset); + let vertices_bytes_len = mem::size_of_val(vertices.as_slice()); + let next_offset = *instance_offset + vertices_bytes_len; + if next_offset > instance_buffer.size { + return None; + } + + let render_pass_descriptor = metal::RenderPassDescriptor::new(); + let color_attachment = render_pass_descriptor + .color_attachments() + .object_at(0) + .unwrap(); + + let texture = self.sprite_atlas.metal_texture(texture_id); + let msaa_texture = self.sprite_atlas.msaa_texture(texture_id); + + if let Some(msaa_texture) = msaa_texture { + color_attachment.set_texture(Some(&msaa_texture)); + color_attachment.set_resolve_texture(Some(&texture)); + color_attachment.set_load_action(metal::MTLLoadAction::Clear); + color_attachment.set_store_action(metal::MTLStoreAction::MultisampleResolve); + } else { + color_attachment.set_texture(Some(&texture)); + color_attachment.set_load_action(metal::MTLLoadAction::Clear); + color_attachment.set_store_action(metal::MTLStoreAction::Store); + } + color_attachment.set_clear_color(metal::MTLClearColor::new(0., 0., 0., 1.)); + + let command_encoder = command_buffer.new_render_command_encoder(render_pass_descriptor); + command_encoder.set_render_pipeline_state(&self.paths_rasterization_pipeline_state); + command_encoder.set_vertex_buffer( + PathRasterizationInputIndex::Vertices as u64, + Some(&instance_buffer.metal_buffer), + *instance_offset as u64, + ); + let texture_size = Size { + width: DevicePixels::from(texture.width()), + height: DevicePixels::from(texture.height()), + }; + command_encoder.set_vertex_bytes( + PathRasterizationInputIndex::AtlasTextureSize as u64, + mem::size_of_val(&texture_size) as u64, + &texture_size as *const Size as *const _, + ); + + let buffer_contents = unsafe { + (instance_buffer.metal_buffer.contents() as *mut u8).add(*instance_offset) + }; + unsafe { + ptr::copy_nonoverlapping( + vertices.as_ptr() as *const u8, + buffer_contents, + vertices_bytes_len, + ); + } + + command_encoder.draw_primitives( + metal::MTLPrimitiveType::Triangle, + 0, + vertices.len() as u64, + ); + command_encoder.end_encoding(); + *instance_offset = next_offset; + } + + Some(tiles) + } + fn draw_shadows( &self, shadows: &[Shadow], @@ -621,6 +718,7 @@ impl MetalRenderer { fn draw_paths( &self, paths: &[Path], + tiles_by_path_id: &HashMap, instance_buffer: &mut InstanceBuffer, instance_offset: &mut usize, viewport_size: Size, @@ -630,108 +728,100 @@ impl MetalRenderer { return true; } - command_encoder.set_render_pipeline_state(&self.path_pipeline_state); + command_encoder.set_render_pipeline_state(&self.path_sprites_pipeline_state); + command_encoder.set_vertex_buffer( + SpriteInputIndex::Vertices as u64, + Some(&self.unit_vertices), + 0, + ); + command_encoder.set_vertex_bytes( + SpriteInputIndex::ViewportSize as u64, + mem::size_of_val(&viewport_size) as u64, + &viewport_size as *const Size as *const _, + ); - unsafe { - let base_addr = instance_buffer.metal_buffer.contents(); - let mut p = (base_addr as *mut u8).add(*instance_offset); - let mut draw_indirect_commands = Vec::with_capacity(paths.len()); + let mut prev_texture_id = None; + let mut sprites = SmallVec::<[_; 1]>::new(); + let mut paths_and_tiles = paths + .iter() + .map(|path| (path, tiles_by_path_id.get(&path.id).unwrap())) + .peekable(); - // copy vertices - let vertices_offset = (p as usize) - (base_addr as usize); - let mut first_vertex = 0; - for (i, path) in paths.iter().enumerate() { - if (p as usize) - (base_addr as usize) - + (mem::size_of::>() * path.vertices.len()) - > instance_buffer.size - { + loop { + if let Some((path, tile)) = paths_and_tiles.peek() { + if prev_texture_id.map_or(true, |texture_id| texture_id == tile.texture_id) { + prev_texture_id = Some(tile.texture_id); + let origin = path.bounds.intersect(&path.content_mask.bounds).origin; + sprites.push(PathSprite { + bounds: Bounds { + origin: origin.map(|p| p.floor()), + size: tile.bounds.size.map(Into::into), + }, + color: path.color, + tile: (*tile).clone(), + }); + paths_and_tiles.next(); + continue; + } + } + + if sprites.is_empty() { + break; + } else { + align_offset(instance_offset); + let texture_id = prev_texture_id.take().unwrap(); + let texture: metal::Texture = self.sprite_atlas.metal_texture(texture_id); + let texture_size = size( + DevicePixels(texture.width() as i32), + DevicePixels(texture.height() as i32), + ); + + command_encoder.set_vertex_buffer( + SpriteInputIndex::Sprites as u64, + Some(&instance_buffer.metal_buffer), + *instance_offset as u64, + ); + command_encoder.set_vertex_bytes( + SpriteInputIndex::AtlasTextureSize as u64, + mem::size_of_val(&texture_size) as u64, + &texture_size as *const Size as *const _, + ); + command_encoder.set_fragment_buffer( + SpriteInputIndex::Sprites as u64, + Some(&instance_buffer.metal_buffer), + *instance_offset as u64, + ); + command_encoder + .set_fragment_texture(SpriteInputIndex::AtlasTexture as u64, Some(&texture)); + + let sprite_bytes_len = mem::size_of_val(sprites.as_slice()); + let next_offset = *instance_offset + sprite_bytes_len; + if next_offset > instance_buffer.size { return false; } - for v in &path.vertices { - *(p as *mut PathVertex) = PathVertex { - xy_position: v.xy_position, - content_mask: ContentMask { - bounds: path.content_mask.bounds, - }, - }; - p = p.add(mem::size_of::>()); + let buffer_contents = unsafe { + (instance_buffer.metal_buffer.contents() as *mut u8).add(*instance_offset) + }; + + unsafe { + ptr::copy_nonoverlapping( + sprites.as_ptr() as *const u8, + buffer_contents, + sprite_bytes_len, + ); } - draw_indirect_commands.push(MTLDrawPrimitivesIndirectArguments { - vertexCount: path.vertices.len() as u32, - instanceCount: 1, - vertexStart: first_vertex, - baseInstance: i as u32, - }); - first_vertex += path.vertices.len() as u32; - } - - // copy sprites - let sprites_offset = (p as u64) - (base_addr as u64); - if (p as usize) - (base_addr as usize) + (mem::size_of::() * paths.len()) - > instance_buffer.size - { - return false; - } - for path in paths { - *(p as *mut PathSprite) = PathSprite { - bounds: path.bounds, - color: path.color, - }; - p = p.add(mem::size_of::()); - } - - // copy indirect commands - let icb_bytes_len = mem::size_of_val(draw_indirect_commands.as_slice()); - let icb_offset = (p as u64) - (base_addr as u64); - if (p as usize) - (base_addr as usize) + icb_bytes_len > instance_buffer.size { - return false; - } - ptr::copy_nonoverlapping( - draw_indirect_commands.as_ptr() as *const u8, - p, - icb_bytes_len, - ); - p = p.add(icb_bytes_len); - - // draw path - command_encoder.set_vertex_buffer( - PathInputIndex::Vertices as u64, - Some(&instance_buffer.metal_buffer), - vertices_offset as u64, - ); - - command_encoder.set_vertex_bytes( - PathInputIndex::ViewportSize as u64, - mem::size_of_val(&viewport_size) as u64, - &viewport_size as *const Size as *const _, - ); - - command_encoder.set_vertex_buffer( - PathInputIndex::Sprites as u64, - Some(&instance_buffer.metal_buffer), - sprites_offset, - ); - - command_encoder.set_fragment_buffer( - PathInputIndex::Sprites as u64, - Some(&instance_buffer.metal_buffer), - sprites_offset, - ); - - for i in 0..paths.len() { - command_encoder.draw_primitives_indirect( + command_encoder.draw_primitives_instanced( metal::MTLPrimitiveType::Triangle, - &instance_buffer.metal_buffer, - icb_offset - + (i * std::mem::size_of::()) as u64, + 0, + 6, + sprites.len() as u64, ); + *instance_offset = next_offset; + sprites.clear(); } - - *instance_offset = (p as usize) - (base_addr as usize); } - true } @@ -1053,7 +1143,6 @@ fn build_pipeline_state( vertex_fn_name: &str, fragment_fn_name: &str, pixel_format: metal::MTLPixelFormat, - sample_count: u64, ) -> metal::RenderPipelineState { let vertex_fn = library .get_function(vertex_fn_name, None) @@ -1066,7 +1155,6 @@ fn build_pipeline_state( descriptor.set_label(label); descriptor.set_vertex_function(Some(vertex_fn.as_ref())); descriptor.set_fragment_function(Some(fragment_fn.as_ref())); - descriptor.set_sample_count(sample_count); let color_attachment = descriptor.color_attachments().object_at(0).unwrap(); color_attachment.set_pixel_format(pixel_format); color_attachment.set_blending_enabled(true); @@ -1082,45 +1170,50 @@ fn build_pipeline_state( .expect("could not create render pipeline state") } +fn build_path_rasterization_pipeline_state( + device: &metal::DeviceRef, + library: &metal::LibraryRef, + label: &str, + vertex_fn_name: &str, + fragment_fn_name: &str, + pixel_format: metal::MTLPixelFormat, + path_sample_count: u32, +) -> metal::RenderPipelineState { + let vertex_fn = library + .get_function(vertex_fn_name, None) + .expect("error locating vertex function"); + let fragment_fn = library + .get_function(fragment_fn_name, None) + .expect("error locating fragment function"); + + let descriptor = metal::RenderPipelineDescriptor::new(); + descriptor.set_label(label); + descriptor.set_vertex_function(Some(vertex_fn.as_ref())); + descriptor.set_fragment_function(Some(fragment_fn.as_ref())); + if path_sample_count > 1 { + descriptor.set_raster_sample_count(path_sample_count as _); + descriptor.set_alpha_to_coverage_enabled(true); + } + let color_attachment = descriptor.color_attachments().object_at(0).unwrap(); + color_attachment.set_pixel_format(pixel_format); + color_attachment.set_blending_enabled(true); + color_attachment.set_rgb_blend_operation(metal::MTLBlendOperation::Add); + color_attachment.set_alpha_blend_operation(metal::MTLBlendOperation::Add); + color_attachment.set_source_rgb_blend_factor(metal::MTLBlendFactor::One); + color_attachment.set_source_alpha_blend_factor(metal::MTLBlendFactor::One); + color_attachment.set_destination_rgb_blend_factor(metal::MTLBlendFactor::One); + color_attachment.set_destination_alpha_blend_factor(metal::MTLBlendFactor::One); + + device + .new_render_pipeline_state(&descriptor) + .expect("could not create render pipeline state") +} + // Align to multiples of 256 make Metal happy. fn align_offset(offset: &mut usize) { *offset = (*offset).div_ceil(256) * 256; } -fn create_msaa_texture( - device: &metal::Device, - layer: &metal::MetalLayer, - sample_count: u64, -) -> Option { - let viewport_size = layer.drawable_size(); - let width = viewport_size.width.ceil() as u64; - let height = viewport_size.height.ceil() as u64; - - if width == 0 || height == 0 { - return None; - } - - if sample_count <= 1 { - return None; - } - - let texture_descriptor = metal::TextureDescriptor::new(); - texture_descriptor.set_texture_type(metal::MTLTextureType::D2Multisample); - - // MTLStorageMode default is `shared` only for Apple silicon GPUs. Use `private` for Apple and Intel GPUs both. - // Reference: https://developer.apple.com/documentation/metal/choosing-a-resource-storage-mode-for-apple-gpus - texture_descriptor.set_storage_mode(metal::MTLStorageMode::Private); - - texture_descriptor.set_width(width); - texture_descriptor.set_height(height); - texture_descriptor.set_pixel_format(layer.pixel_format()); - texture_descriptor.set_usage(metal::MTLTextureUsage::RenderTarget); - texture_descriptor.set_sample_count(sample_count); - - let metal_texture = device.new_texture(&texture_descriptor); - Some(metal_texture) -} - #[repr(C)] enum ShadowInputIndex { Vertices = 0, @@ -1162,10 +1255,9 @@ enum SurfaceInputIndex { } #[repr(C)] -enum PathInputIndex { +enum PathRasterizationInputIndex { Vertices = 0, - ViewportSize = 1, - Sprites = 2, + AtlasTextureSize = 1, } #[derive(Clone, Debug, Eq, PartialEq)] @@ -1173,6 +1265,7 @@ enum PathInputIndex { pub struct PathSprite { pub bounds: Bounds, pub color: Background, + pub tile: AtlasTile, } #[derive(Clone, Debug, Eq, PartialEq)] diff --git a/crates/gpui/src/platform/mac/shaders.metal b/crates/gpui/src/platform/mac/shaders.metal index 5f0dc3323d..64ebb1e22b 100644 --- a/crates/gpui/src/platform/mac/shaders.metal +++ b/crates/gpui/src/platform/mac/shaders.metal @@ -698,27 +698,76 @@ fragment float4 polychrome_sprite_fragment( return color; } -struct PathVertexOutput { +struct PathRasterizationVertexOutput { float4 position [[position]]; + float2 st_position; + float clip_rect_distance [[clip_distance]][4]; +}; + +struct PathRasterizationFragmentInput { + float4 position [[position]]; + float2 st_position; +}; + +vertex PathRasterizationVertexOutput path_rasterization_vertex( + uint vertex_id [[vertex_id]], + constant PathVertex_ScaledPixels *vertices + [[buffer(PathRasterizationInputIndex_Vertices)]], + constant Size_DevicePixels *atlas_size + [[buffer(PathRasterizationInputIndex_AtlasTextureSize)]]) { + PathVertex_ScaledPixels v = vertices[vertex_id]; + float2 vertex_position = float2(v.xy_position.x, v.xy_position.y); + float2 viewport_size = float2(atlas_size->width, atlas_size->height); + return PathRasterizationVertexOutput{ + float4(vertex_position / viewport_size * float2(2., -2.) + + float2(-1., 1.), + 0., 1.), + float2(v.st_position.x, v.st_position.y), + {v.xy_position.x - v.content_mask.bounds.origin.x, + v.content_mask.bounds.origin.x + v.content_mask.bounds.size.width - + v.xy_position.x, + v.xy_position.y - v.content_mask.bounds.origin.y, + v.content_mask.bounds.origin.y + v.content_mask.bounds.size.height - + v.xy_position.y}}; +} + +fragment float4 path_rasterization_fragment(PathRasterizationFragmentInput input + [[stage_in]]) { + float2 dx = dfdx(input.st_position); + float2 dy = dfdy(input.st_position); + float2 gradient = float2((2. * input.st_position.x) * dx.x - dx.y, + (2. * input.st_position.x) * dy.x - dy.y); + float f = (input.st_position.x * input.st_position.x) - input.st_position.y; + float distance = f / length(gradient); + float alpha = saturate(0.5 - distance); + return float4(alpha, 0., 0., 1.); +} + +struct PathSpriteVertexOutput { + float4 position [[position]]; + float2 tile_position; uint sprite_id [[flat]]; float4 solid_color [[flat]]; float4 color0 [[flat]]; float4 color1 [[flat]]; - float4 clip_distance; }; -vertex PathVertexOutput path_vertex( - uint vertex_id [[vertex_id]], - constant PathVertex_ScaledPixels *vertices [[buffer(PathInputIndex_Vertices)]], - uint sprite_id [[instance_id]], - constant PathSprite *sprites [[buffer(PathInputIndex_Sprites)]], - constant Size_DevicePixels *input_viewport_size [[buffer(PathInputIndex_ViewportSize)]]) { - PathVertex_ScaledPixels v = vertices[vertex_id]; - float2 vertex_position = float2(v.xy_position.x, v.xy_position.y); - float2 viewport_size = float2((float)input_viewport_size->width, - (float)input_viewport_size->height); +vertex PathSpriteVertexOutput path_sprite_vertex( + uint unit_vertex_id [[vertex_id]], uint sprite_id [[instance_id]], + constant float2 *unit_vertices [[buffer(SpriteInputIndex_Vertices)]], + constant PathSprite *sprites [[buffer(SpriteInputIndex_Sprites)]], + constant Size_DevicePixels *viewport_size + [[buffer(SpriteInputIndex_ViewportSize)]], + constant Size_DevicePixels *atlas_size + [[buffer(SpriteInputIndex_AtlasTextureSize)]]) { + + float2 unit_vertex = unit_vertices[unit_vertex_id]; PathSprite sprite = sprites[sprite_id]; - float4 device_position = float4(vertex_position / viewport_size * float2(2., -2.) + float2(-1., 1.), 0., 1.); + // Don't apply content mask because it was already accounted for when + // rasterizing the path. + float4 device_position = + to_device_position(unit_vertex, sprite.bounds, viewport_size); + float2 tile_position = to_tile_position(unit_vertex, sprite.tile, atlas_size); GradientColor gradient = prepare_fill_color( sprite.color.tag, @@ -728,32 +777,30 @@ vertex PathVertexOutput path_vertex( sprite.color.colors[1].color ); - return PathVertexOutput{ + return PathSpriteVertexOutput{ device_position, + tile_position, sprite_id, gradient.solid, gradient.color0, - gradient.color1, - {v.xy_position.x - v.content_mask.bounds.origin.x, - v.content_mask.bounds.origin.x + v.content_mask.bounds.size.width - - v.xy_position.x, - v.xy_position.y - v.content_mask.bounds.origin.y, - v.content_mask.bounds.origin.y + v.content_mask.bounds.size.height - - v.xy_position.y} + gradient.color1 }; } -fragment float4 path_fragment( - PathVertexOutput input [[stage_in]], - constant PathSprite *sprites [[buffer(PathInputIndex_Sprites)]]) { - if (any(input.clip_distance < float4(0.0))) { - return float4(0.0); - } - +fragment float4 path_sprite_fragment( + PathSpriteVertexOutput input [[stage_in]], + constant PathSprite *sprites [[buffer(SpriteInputIndex_Sprites)]], + texture2d atlas_texture [[texture(SpriteInputIndex_AtlasTexture)]]) { + constexpr sampler atlas_texture_sampler(mag_filter::linear, + min_filter::linear); + float4 sample = + atlas_texture.sample(atlas_texture_sampler, input.tile_position); + float mask = 1. - abs(1. - fmod(sample.r, 2.)); PathSprite sprite = sprites[input.sprite_id]; Background background = sprite.color; float4 color = fill_color(background, input.position.xy, sprite.bounds, input.solid_color, input.color0, input.color1); + color.a *= mask; return color; } diff --git a/crates/gpui/src/platform/test/window.rs b/crates/gpui/src/platform/test/window.rs index 65ee10a13f..1b88415d3b 100644 --- a/crates/gpui/src/platform/test/window.rs +++ b/crates/gpui/src/platform/test/window.rs @@ -341,7 +341,7 @@ impl PlatformAtlas for TestAtlas { crate::AtlasTile { texture_id: AtlasTextureId { index: texture_id, - kind: crate::AtlasTextureKind::Polychrome, + kind: crate::AtlasTextureKind::Path, }, tile_id: TileId(tile_id), padding: 0, diff --git a/crates/gpui/src/scene.rs b/crates/gpui/src/scene.rs index 681444a473..4eaef64afa 100644 --- a/crates/gpui/src/scene.rs +++ b/crates/gpui/src/scene.rs @@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize}; use crate::{ AtlasTextureId, AtlasTile, Background, Bounds, ContentMask, Corners, Edges, Hsla, Pixels, - Point, Radians, ScaledPixels, Size, bounds_tree::BoundsTree, + Point, Radians, ScaledPixels, Size, bounds_tree::BoundsTree, point, }; use std::{fmt::Debug, iter::Peekable, ops::Range, slice}; @@ -43,7 +43,13 @@ impl Scene { self.surfaces.clear(); } - #[allow(dead_code)] + #[cfg_attr( + all( + any(target_os = "linux", target_os = "freebsd"), + not(any(feature = "x11", feature = "wayland")) + ), + allow(dead_code) + )] pub fn paths(&self) -> &[Path] { &self.paths } @@ -683,7 +689,6 @@ pub struct Path { start: Point

, current: Point

, contour_count: usize, - base_scale: f32, } impl Path { @@ -702,35 +707,25 @@ impl Path { content_mask: Default::default(), color: Default::default(), contour_count: 0, - base_scale: 1.0, } } - /// Set the base scale of the path. - pub fn scale(mut self, factor: f32) -> Self { - self.base_scale = factor; - self - } - - /// Apply a scale to the path. - pub(crate) fn apply_scale(&self, factor: f32) -> Path { + /// Scale this path by the given factor. + pub fn scale(&self, factor: f32) -> Path { Path { id: self.id, order: self.order, - bounds: self.bounds.scale(self.base_scale * factor), - content_mask: self.content_mask.scale(self.base_scale * factor), + bounds: self.bounds.scale(factor), + content_mask: self.content_mask.scale(factor), vertices: self .vertices .iter() - .map(|vertex| vertex.scale(self.base_scale * factor)) + .map(|vertex| vertex.scale(factor)) .collect(), - start: self - .start - .map(|start| start.scale(self.base_scale * factor)), - current: self.current.scale(self.base_scale * factor), + start: self.start.map(|start| start.scale(factor)), + current: self.current.scale(factor), contour_count: self.contour_count, color: self.color, - base_scale: 1.0, } } @@ -745,7 +740,10 @@ impl Path { pub fn line_to(&mut self, to: Point) { self.contour_count += 1; if self.contour_count > 1 { - self.push_triangle((self.start, self.current, to)); + self.push_triangle( + (self.start, self.current, to), + (point(0., 1.), point(0., 1.), point(0., 1.)), + ); } self.current = to; } @@ -754,15 +752,25 @@ impl Path { pub fn curve_to(&mut self, to: Point, ctrl: Point) { self.contour_count += 1; if self.contour_count > 1 { - self.push_triangle((self.start, self.current, to)); + self.push_triangle( + (self.start, self.current, to), + (point(0., 1.), point(0., 1.), point(0., 1.)), + ); } - self.push_triangle((self.current, ctrl, to)); + self.push_triangle( + (self.current, ctrl, to), + (point(0., 0.), point(0.5, 0.), point(1., 1.)), + ); self.current = to; } /// Push a triangle to the Path. - pub fn push_triangle(&mut self, xy: (Point, Point, Point)) { + pub fn push_triangle( + &mut self, + xy: (Point, Point, Point), + st: (Point, Point, Point), + ) { self.bounds = self .bounds .union(&Bounds { @@ -780,14 +788,17 @@ impl Path { self.vertices.push(PathVertex { xy_position: xy.0, + st_position: st.0, content_mask: Default::default(), }); self.vertices.push(PathVertex { xy_position: xy.1, + st_position: st.1, content_mask: Default::default(), }); self.vertices.push(PathVertex { xy_position: xy.2, + st_position: st.2, content_mask: Default::default(), }); } @@ -803,6 +814,7 @@ impl From> for Primitive { #[repr(C)] pub(crate) struct PathVertex { pub(crate) xy_position: Point

, + pub(crate) st_position: Point, pub(crate) content_mask: ContentMask

, } @@ -810,6 +822,7 @@ impl PathVertex { pub fn scale(&self, factor: f32) -> PathVertex { PathVertex { xy_position: self.xy_position.scale(factor), + st_position: self.st_position, content_mask: self.content_mask.scale(factor), } } diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rs index e9145bd9f5..94f1b39ba2 100644 --- a/crates/gpui/src/window.rs +++ b/crates/gpui/src/window.rs @@ -2658,7 +2658,7 @@ impl Window { path.color = color.opacity(opacity); self.next_frame .scene - .insert_primitive(path.apply_scale(scale_factor)); + .insert_primitive(path.scale(scale_factor)); } /// Paint an underline into the scene for the next frame at the current z-index. diff --git a/docs/src/linux.md b/docs/src/linux.md index 896bfdaf3f..ca65da2969 100644 --- a/docs/src/linux.md +++ b/docs/src/linux.md @@ -148,7 +148,7 @@ On some systems the file `/etc/prime-discrete` can be used to enforce the use of On others, you may be able to the environment variable `DRI_PRIME=1` when running Zed to force the use of the discrete GPU. -If you're using an AMD GPU and Zed crashes when selecting long lines, try setting the `ZED_SAMPLE_COUNT=0` environment variable. (See [#26143](https://github.com/zed-industries/zed/issues/26143)) +If you're using an AMD GPU and Zed crashes when selecting long lines, try setting the `ZED_PATH_SAMPLE_COUNT=0` environment variable. (See [#26143](https://github.com/zed-industries/zed/issues/26143)) If you're using an AMD GPU, you might get a 'Broken Pipe' error. Try using the RADV or Mesa drivers. (See [#13880](https://github.com/zed-industries/zed/issues/13880)) From 44768606641ba3c9d40de8b38d96569d0ed69661 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Fri, 18 Jul 2025 13:25:36 -0300 Subject: [PATCH 0060/1052] Add refinements to the AI onboarding flow (#33738) This includes making sure that both the agent panel and Zed's edit prediction have a consistent narrative when it comes to onboarding users into the AI features, considering the possible different plans and conditions (such as being signed in/out, account age, etc.) Release Notes: - N/A --------- Co-authored-by: Bennet Bo Fenner <53836821+bennetbo@users.noreply.github.com> Co-authored-by: Bennet Bo Fenner --- Cargo.lock | 22 +- Cargo.toml | 2 + crates/agent_ui/Cargo.toml | 1 + crates/agent_ui/src/agent_model_selector.rs | 21 +- crates/agent_ui/src/agent_panel.rs | 747 ++++++------------ crates/agent_ui/src/inline_prompt_editor.rs | 2 +- .../agent_ui/src/language_model_selector.rs | 13 +- crates/agent_ui/src/message_editor.rs | 11 +- crates/agent_ui/src/text_thread_editor.rs | 144 +--- crates/agent_ui/src/ui.rs | 2 + crates/agent_ui/src/ui/end_trial_upsell.rs | 112 +++ crates/ai_onboarding/Cargo.toml | 27 + crates/ai_onboarding/LICENSE-GPL | 1 + .../src/agent_panel_onboarding_card.rs | 81 ++ .../src/agent_panel_onboarding_content.rs | 145 ++++ crates/ai_onboarding/src/ai_onboarding.rs | 397 ++++++++++ .../src/edit_prediction_onboarding_content.rs | 73 ++ .../ai_onboarding/src/young_account_banner.rs | 21 + crates/client/src/client.rs | 7 + crates/client/src/user.rs | 10 + crates/client/src/zed_urls.rs | 5 + crates/copilot/src/copilot.rs | 10 +- .../src/inline_completion_button.rs | 93 +-- crates/language_model/src/language_model.rs | 2 +- crates/language_models/Cargo.toml | 1 + crates/language_models/src/provider/cloud.rs | 136 ++-- crates/title_bar/src/title_bar.rs | 9 +- .../ui/src/components/button/button_like.rs | 42 + crates/zed_actions/src/lib.rs | 5 +- crates/zeta/Cargo.toml | 4 +- crates/zeta/src/init.rs | 1 - crates/zeta/src/onboarding_modal.rs | 499 ++---------- crates/zeta/src/zeta.rs | 34 +- 33 files changed, 1465 insertions(+), 1215 deletions(-) create mode 100644 crates/agent_ui/src/ui/end_trial_upsell.rs create mode 100644 crates/ai_onboarding/Cargo.toml create mode 120000 crates/ai_onboarding/LICENSE-GPL create mode 100644 crates/ai_onboarding/src/agent_panel_onboarding_card.rs create mode 100644 crates/ai_onboarding/src/agent_panel_onboarding_content.rs create mode 100644 crates/ai_onboarding/src/ai_onboarding.rs create mode 100644 crates/ai_onboarding/src/edit_prediction_onboarding_content.rs create mode 100644 crates/ai_onboarding/src/young_account_banner.rs diff --git a/Cargo.lock b/Cargo.lock index 8bf2654370..cbed9f5988 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -195,6 +195,7 @@ dependencies = [ "agent_servers", "agent_settings", "agentic-coding-protocol", + "ai_onboarding", "anyhow", "assistant_context", "assistant_slash_command", @@ -329,6 +330,22 @@ dependencies = [ "memchr", ] +[[package]] +name = "ai_onboarding" +version = "0.1.0" +dependencies = [ + "client", + "component", + "gpui", + "language_model", + "proto", + "serde", + "smallvec", + "ui", + "workspace-hack", + "zed_actions", +] + [[package]] name = "alacritty_terminal" version = "0.25.1-dev" @@ -9066,6 +9083,7 @@ dependencies = [ name = "language_models" version = "0.1.0" dependencies = [ + "ai_onboarding", "anthropic", "anyhow", "aws-config", @@ -20510,6 +20528,7 @@ dependencies = [ name = "zeta" version = "0.1.0" dependencies = [ + "ai_onboarding", "anyhow", "arrayvec", "call", @@ -20517,6 +20536,7 @@ dependencies = [ "clock", "collections", "command_palette_hooks", + "copilot", "ctor", "db", "editor", @@ -20531,8 +20551,6 @@ dependencies = [ "language_model", "log", "menu", - "migrator", - "paths", "postage", "project", "proto", diff --git a/Cargo.toml b/Cargo.toml index 8d942a4c73..aa9af9a423 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,6 +6,7 @@ members = [ "crates/agent_ui", "crates/agent", "crates/agent_settings", + "crates/ai_onboarding", "crates/agent_servers", "crates/anthropic", "crates/askpass", @@ -227,6 +228,7 @@ agent_ui = { path = "crates/agent_ui" } agent_settings = { path = "crates/agent_settings" } agent_servers = { path = "crates/agent_servers" } ai = { path = "crates/ai" } +ai_onboarding = { path = "crates/ai_onboarding" } anthropic = { path = "crates/anthropic" } askpass = { path = "crates/askpass" } assets = { path = "crates/assets" } diff --git a/crates/agent_ui/Cargo.toml b/crates/agent_ui/Cargo.toml index d4feceb0b6..e55ae86fb7 100644 --- a/crates/agent_ui/Cargo.toml +++ b/crates/agent_ui/Cargo.toml @@ -21,6 +21,7 @@ agent.workspace = true agentic-coding-protocol.workspace = true agent_settings.workspace = true agent_servers.workspace = true +ai_onboarding.workspace = true anyhow.workspace = true assistant_context.workspace = true assistant_slash_command.workspace = true diff --git a/crates/agent_ui/src/agent_model_selector.rs b/crates/agent_ui/src/agent_model_selector.rs index f7b9157bbb..b989e7bf1e 100644 --- a/crates/agent_ui/src/agent_model_selector.rs +++ b/crates/agent_ui/src/agent_model_selector.rs @@ -1,8 +1,6 @@ use crate::{ ModelUsageContext, - language_model_selector::{ - LanguageModelSelector, ToggleModelSelector, language_model_selector, - }, + language_model_selector::{LanguageModelSelector, language_model_selector}, }; use agent_settings::AgentSettings; use fs::Fs; @@ -12,6 +10,7 @@ use picker::popover_menu::PickerPopoverMenu; use settings::update_settings_file; use std::sync::Arc; use ui::{ButtonLike, PopoverMenuHandle, Tooltip, prelude::*}; +use zed_actions::agent::ToggleModelSelector; pub struct AgentModelSelector { selector: Entity, @@ -96,22 +95,18 @@ impl Render for AgentModelSelector { let model_name = model .as_ref() .map(|model| model.model.name().0) - .unwrap_or_else(|| SharedString::from("No model selected")); - let provider_icon = model - .as_ref() - .map(|model| model.provider.icon()) - .unwrap_or_else(|| IconName::Ai); + .unwrap_or_else(|| SharedString::from("Select a Model")); + + let provider_icon = model.as_ref().map(|model| model.provider.icon()); let focus_handle = self.focus_handle.clone(); PickerPopoverMenu::new( self.selector.clone(), ButtonLike::new("active-model") - .child( - Icon::new(provider_icon) - .color(Color::Muted) - .size(IconSize::XSmall), - ) + .when_some(provider_icon, |this, icon| { + this.child(Icon::new(icon).color(Color::Muted).size(IconSize::XSmall)) + }) .child( Label::new(model_name) .color(Color::Muted) diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 103e439615..7f2fbce189 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -11,7 +11,6 @@ use serde::{Deserialize, Serialize}; use crate::NewExternalAgentThread; use crate::agent_diff::AgentDiffThread; -use crate::language_model_selector::ToggleModelSelector; use crate::{ AddContextServer, AgentDiffPane, ContinueThread, ContinueWithBurnMode, DeleteRecentlyOpenThread, ExpandMessageEditor, Follow, InlineAssistant, NewTextThread, @@ -28,7 +27,7 @@ use crate::{ render_remaining_tokens, }, thread_history::{HistoryEntryElement, ThreadHistory}, - ui::AgentOnboardingModal, + ui::{AgentOnboardingModal, EndTrialUpsell}, }; use agent::{ Thread, ThreadError, ThreadEvent, ThreadId, ThreadSummary, TokenUsageRatio, @@ -37,6 +36,7 @@ use agent::{ thread_store::{TextThreadStore, ThreadStore}, }; use agent_settings::{AgentDockPosition, AgentSettings, CompletionMode, DefaultView}; +use ai_onboarding::AgentPanelOnboarding; use anyhow::{Result, anyhow}; use assistant_context::{AssistantContext, ContextEvent, ContextSummary}; use assistant_slash_command::SlashCommandWorkingSet; @@ -48,13 +48,12 @@ use fs::Fs; use gpui::{ Action, Animation, AnimationExt as _, AnyElement, App, AsyncWindowContext, ClipboardItem, Corner, DismissEvent, Entity, EventEmitter, ExternalPaths, FocusHandle, Focusable, Hsla, - KeyContext, Pixels, Subscription, Task, UpdateGlobal, WeakEntity, linear_color_stop, - linear_gradient, prelude::*, pulsating_between, + KeyContext, Pixels, Subscription, Task, UpdateGlobal, WeakEntity, prelude::*, + pulsating_between, }; use language::LanguageRegistry; use language_model::{ ConfigurationError, ConfiguredModel, LanguageModelProviderTosView, LanguageModelRegistry, - ZED_CLOUD_PROVIDER_ID, }; use project::{Project, ProjectPath, Worktree}; use prompt_store::{PromptBuilder, PromptStore, UserPromptId}; @@ -66,9 +65,8 @@ use theme::ThemeSettings; use time::UtcOffset; use ui::utils::WithRemSize; use ui::{ - Banner, Button, Callout, CheckboxWithLabel, ContextMenu, ElevationIndex, IconPosition, - KeyBinding, PopoverMenu, PopoverMenuHandle, ProgressBar, Tab, Tooltip, Vector, VectorName, - prelude::*, + Banner, Callout, ContextMenu, ElevationIndex, KeyBinding, PopoverMenu, PopoverMenuHandle, + ProgressBar, Tab, Tooltip, prelude::*, }; use util::ResultExt as _; use workspace::{ @@ -77,7 +75,7 @@ use workspace::{ }; use zed_actions::{ DecreaseBufferFontSize, IncreaseBufferFontSize, ResetBufferFontSize, - agent::{OpenConfiguration, OpenOnboardingModal, ResetOnboarding}, + agent::{OpenConfiguration, OpenOnboardingModal, ResetOnboarding, ToggleModelSelector}, assistant::{OpenRulesLibrary, ToggleFocus}, }; use zed_llm_client::{CompletionIntent, UsageLimit}; @@ -188,7 +186,7 @@ pub fn init(cx: &mut App) { window.refresh(); }) .register_action(|_workspace, _: &ResetTrialUpsell, _window, cx| { - Upsell::set_dismissed(false, cx); + OnboardingUpsell::set_dismissed(false, cx); }) .register_action(|_workspace, _: &ResetTrialEndUpsell, _window, cx| { TrialEndUpsell::set_dismissed(false, cx); @@ -453,7 +451,7 @@ pub struct AgentPanel { height: Option, zoomed: bool, pending_serialization: Option>>, - hide_upsell: bool, + onboarding: Entity, } impl AgentPanel { @@ -555,6 +553,7 @@ impl AgentPanel { let user_store = workspace.app_state().user_store.clone(); let project = workspace.project(); let language_registry = project.read(cx).languages().clone(); + let client = workspace.client().clone(); let workspace = workspace.weak_handle(); let weak_self = cx.entity().downgrade(); @@ -688,6 +687,17 @@ impl AgentPanel { }, ); + let onboarding = cx.new(|cx| { + AgentPanelOnboarding::new( + user_store.clone(), + client, + |_window, cx| { + OnboardingUpsell::set_dismissed(true, cx); + }, + cx, + ) + }); + Self { active_view, workspace, @@ -719,7 +729,7 @@ impl AgentPanel { height: None, zoomed: false, pending_serialization: None, - hide_upsell: false, + onboarding, } } @@ -2178,191 +2188,78 @@ impl AgentPanel { return false; } + match &self.active_view { + ActiveView::Thread { thread, .. } => { + if thread + .read(cx) + .thread() + .read(cx) + .configured_model() + .map_or(false, |model| { + model.provider.id() != language_model::ZED_CLOUD_PROVIDER_ID + }) + { + return false; + } + } + ActiveView::TextThread { .. } => { + if LanguageModelRegistry::global(cx) + .read(cx) + .default_model() + .map_or(false, |model| { + model.provider.id() != language_model::ZED_CLOUD_PROVIDER_ID + }) + { + return false; + } + } + ActiveView::ExternalAgentThread { .. } + | ActiveView::History + | ActiveView::Configuration => return false, + } + let plan = self.user_store.read(cx).current_plan(); let has_previous_trial = self.user_store.read(cx).trial_started_at().is_some(); matches!(plan, Some(Plan::Free)) && has_previous_trial } - fn should_render_upsell(&self, cx: &mut Context) -> bool { + fn should_render_onboarding(&self, cx: &mut Context) -> bool { + if OnboardingUpsell::dismissed() { + return false; + } + match &self.active_view { - ActiveView::Thread { thread, .. } => { - let is_using_zed_provider = thread - .read(cx) - .thread() - .read(cx) - .configured_model() - .map_or(false, |model| model.provider.id() == ZED_CLOUD_PROVIDER_ID); - - if !is_using_zed_provider { - return false; - } - } - ActiveView::ExternalAgentThread { .. } => { - return false; - } - ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => { - return false; - } - }; - - if self.hide_upsell || Upsell::dismissed() { - return false; + ActiveView::Thread { thread, .. } => thread + .read(cx) + .thread() + .read(cx) + .configured_model() + .map_or(true, |model| { + model.provider.id() == language_model::ZED_CLOUD_PROVIDER_ID + }), + ActiveView::TextThread { .. } => LanguageModelRegistry::global(cx) + .read(cx) + .default_model() + .map_or(true, |model| { + model.provider.id() == language_model::ZED_CLOUD_PROVIDER_ID + }), + ActiveView::ExternalAgentThread { .. } + | ActiveView::History + | ActiveView::Configuration => false, } - - let plan = self.user_store.read(cx).current_plan(); - if matches!(plan, Some(Plan::ZedPro | Plan::ZedProTrial)) { - return false; - } - - let has_previous_trial = self.user_store.read(cx).trial_started_at().is_some(); - if has_previous_trial { - return false; - } - - true } - fn render_upsell( + fn render_onboarding( &self, _window: &mut Window, cx: &mut Context, ) -> Option { - if !self.should_render_upsell(cx) { + if !self.should_render_onboarding(cx) { return None; } - if self.user_store.read(cx).account_too_young() { - Some(self.render_young_account_upsell(cx).into_any_element()) - } else { - Some(self.render_trial_upsell(cx).into_any_element()) - } - } - - fn render_young_account_upsell(&self, cx: &mut Context) -> impl IntoElement { - let checkbox = CheckboxWithLabel::new( - "dont-show-again", - Label::new("Don't show again").color(Color::Muted), - ToggleState::Unselected, - move |toggle_state, _window, cx| { - let toggle_state_bool = toggle_state.selected(); - - Upsell::set_dismissed(toggle_state_bool, cx); - }, - ); - - let contents = div() - .size_full() - .gap_2() - .flex() - .flex_col() - .child(Headline::new("Build better with Zed Pro").size(HeadlineSize::Small)) - .child( - Label::new("Your GitHub account was created less than 30 days ago, so we can't offer you a free trial.") - .size(LabelSize::Small), - ) - .child( - Label::new( - "Use your own API keys, upgrade to Zed Pro or send an email to billing-support@zed.dev.", - ) - .color(Color::Muted), - ) - .child( - h_flex() - .w_full() - .px_neg_1() - .justify_between() - .items_center() - .child(h_flex().items_center().gap_1().child(checkbox)) - .child( - h_flex() - .gap_2() - .child( - Button::new("dismiss-button", "Not Now") - .style(ButtonStyle::Transparent) - .color(Color::Muted) - .on_click({ - let agent_panel = cx.entity(); - move |_, _, cx| { - agent_panel.update(cx, |this, cx| { - this.hide_upsell = true; - cx.notify(); - }); - } - }), - ) - .child( - Button::new("cta-button", "Upgrade to Zed Pro") - .style(ButtonStyle::Transparent) - .on_click(|_, _, cx| cx.open_url(&zed_urls::account_url(cx))), - ), - ), - ); - - self.render_upsell_container(cx, contents) - } - - fn render_trial_upsell(&self, cx: &mut Context) -> impl IntoElement { - let checkbox = CheckboxWithLabel::new( - "dont-show-again", - Label::new("Don't show again").color(Color::Muted), - ToggleState::Unselected, - move |toggle_state, _window, cx| { - let toggle_state_bool = toggle_state.selected(); - - Upsell::set_dismissed(toggle_state_bool, cx); - }, - ); - - let contents = div() - .size_full() - .gap_2() - .flex() - .flex_col() - .child(Headline::new("Build better with Zed Pro").size(HeadlineSize::Small)) - .child( - Label::new("Try Zed Pro for free for 14 days - no credit card required.") - .size(LabelSize::Small), - ) - .child( - Label::new( - "Use your own API keys or enable usage-based billing once you hit the cap.", - ) - .color(Color::Muted), - ) - .child( - h_flex() - .w_full() - .px_neg_1() - .justify_between() - .items_center() - .child(h_flex().items_center().gap_1().child(checkbox)) - .child( - h_flex() - .gap_2() - .child( - Button::new("dismiss-button", "Not Now") - .style(ButtonStyle::Transparent) - .color(Color::Muted) - .on_click({ - let agent_panel = cx.entity(); - move |_, _, cx| { - agent_panel.update(cx, |this, cx| { - this.hide_upsell = true; - cx.notify(); - }); - } - }), - ) - .child( - Button::new("cta-button", "Start Trial") - .style(ButtonStyle::Transparent) - .on_click(|_, _, cx| cx.open_url(&zed_urls::account_url(cx))), - ), - ), - ); - - self.render_upsell_container(cx, contents) + Some(div().size_full().child(self.onboarding.clone())) } fn render_trial_end_upsell( @@ -2374,141 +2271,15 @@ impl AgentPanel { return None; } - Some( - self.render_upsell_container( - cx, - div() - .size_full() - .gap_2() - .flex() - .flex_col() - .child( - Headline::new("Your Zed Pro trial has expired.").size(HeadlineSize::Small), - ) - .child( - Label::new("You've been automatically reset to the free plan.") - .size(LabelSize::Small), - ) - .child( - h_flex() - .w_full() - .px_neg_1() - .justify_between() - .items_center() - .child(div()) - .child( - h_flex() - .gap_2() - .child( - Button::new("dismiss-button", "Stay on Free") - .style(ButtonStyle::Transparent) - .color(Color::Muted) - .on_click({ - let agent_panel = cx.entity(); - move |_, _, cx| { - agent_panel.update(cx, |_this, cx| { - TrialEndUpsell::set_dismissed(true, cx); - cx.notify(); - }); - } - }), - ) - .child( - Button::new("cta-button", "Upgrade to Zed Pro") - .style(ButtonStyle::Transparent) - .on_click(|_, _, cx| { - cx.open_url(&zed_urls::account_url(cx)) - }), - ), - ), - ), - ), - ) - } - - fn render_upsell_container(&self, cx: &mut Context, content: Div) -> Div { - div().p_2().child( - v_flex() - .w_full() - .elevation_2(cx) - .rounded(px(8.)) - .bg(cx.theme().colors().background.alpha(0.5)) - .p(px(3.)) - .child( - div() - .gap_2() - .flex() - .flex_col() - .size_full() - .border_1() - .rounded(px(5.)) - .border_color(cx.theme().colors().text.alpha(0.1)) - .overflow_hidden() - .relative() - .bg(cx.theme().colors().panel_background) - .px_4() - .py_3() - .child( - div() - .absolute() - .top_0() - .right(px(-1.0)) - .w(px(441.)) - .h(px(167.)) - .child( - Vector::new( - VectorName::Grid, - rems_from_px(441.), - rems_from_px(167.), - ) - .color(ui::Color::Custom(cx.theme().colors().text.alpha(0.1))), - ), - ) - .child( - div() - .absolute() - .top(px(-8.0)) - .right_0() - .w(px(400.)) - .h(px(92.)) - .child( - Vector::new( - VectorName::AiGrid, - rems_from_px(400.), - rems_from_px(92.), - ) - .color(ui::Color::Custom(cx.theme().colors().text.alpha(0.32))), - ), - ) - // .child( - // div() - // .absolute() - // .top_0() - // .right(px(360.)) - // .size(px(401.)) - // .overflow_hidden() - // .bg(cx.theme().colors().panel_background) - // ) - .child( - div() - .absolute() - .top_0() - .right_0() - .w(px(660.)) - .h(px(401.)) - .overflow_hidden() - .bg(linear_gradient( - 75., - linear_color_stop( - cx.theme().colors().panel_background.alpha(0.01), - 1.0, - ), - linear_color_stop(cx.theme().colors().panel_background, 0.45), - )), - ) - .child(content), - ), - ) + Some(EndTrialUpsell::new(Arc::new({ + let this = cx.entity(); + move |_, cx| { + this.update(cx, |_this, cx| { + TrialEndUpsell::set_dismissed(true, cx); + cx.notify(); + }); + } + }))) } fn render_thread_empty_state( @@ -2521,8 +2292,10 @@ impl AgentPanel { .update(cx, |this, cx| this.recent_entries(6, cx)); let model_registry = LanguageModelRegistry::read_global(cx); + let configuration_error = model_registry.configuration_error(model_registry.default_model(), cx); + let no_error = configuration_error.is_none(); let focus_handle = self.focus_handle(cx); @@ -2530,11 +2303,9 @@ impl AgentPanel { .size_full() .bg(cx.theme().colors().panel_background) .when(recent_history.is_empty(), |this| { - let configuration_error_ref = &configuration_error; this.child( v_flex() .size_full() - .max_w_80() .mx_auto() .justify_center() .items_center() @@ -2542,137 +2313,91 @@ impl AgentPanel { .child(h_flex().child(Headline::new("Welcome to the Agent Panel"))) .when(no_error, |parent| { parent + .child(h_flex().child( + Label::new("Ask and build anything.").color(Color::Muted), + )) .child( - h_flex().child( - Label::new("Ask and build anything.") - .color(Color::Muted) - .mb_2p5(), - ), - ) - .child( - Button::new("new-thread", "Start New Thread") - .icon(IconName::Plus) - .icon_position(IconPosition::Start) - .icon_size(IconSize::Small) - .icon_color(Color::Muted) - .full_width() - .key_binding(KeyBinding::for_action_in( - &NewThread::default(), - &focus_handle, - window, - cx, - )) - .on_click(|_event, window, cx| { - window.dispatch_action( - NewThread::default().boxed_clone(), - cx, - ) - }), - ) - .child( - Button::new("context", "Add Context") - .icon(IconName::FileCode) - .icon_position(IconPosition::Start) - .icon_size(IconSize::Small) - .icon_color(Color::Muted) - .full_width() - .key_binding(KeyBinding::for_action_in( - &ToggleContextPicker, - &focus_handle, - window, - cx, - )) - .on_click(|_event, window, cx| { - window.dispatch_action( - ToggleContextPicker.boxed_clone(), - cx, - ) - }), - ) - .child( - Button::new("mode", "Switch Model") - .icon(IconName::DatabaseZap) - .icon_position(IconPosition::Start) - .icon_size(IconSize::Small) - .icon_color(Color::Muted) - .full_width() - .key_binding(KeyBinding::for_action_in( - &ToggleModelSelector, - &focus_handle, - window, - cx, - )) - .on_click(|_event, window, cx| { - window.dispatch_action( - ToggleModelSelector.boxed_clone(), - cx, - ) - }), - ) - .child( - Button::new("settings", "View Settings") - .icon(IconName::Settings) - .icon_position(IconPosition::Start) - .icon_size(IconSize::Small) - .icon_color(Color::Muted) - .full_width() - .key_binding(KeyBinding::for_action_in( - &OpenConfiguration, - &focus_handle, - window, - cx, - )) - .on_click(|_event, window, cx| { - window.dispatch_action( - OpenConfiguration.boxed_clone(), - cx, - ) - }), + v_flex() + .mt_2() + .gap_1() + .max_w_48() + .child( + Button::new("context", "Add Context") + .label_size(LabelSize::Small) + .icon(IconName::FileCode) + .icon_position(IconPosition::Start) + .icon_size(IconSize::Small) + .icon_color(Color::Muted) + .full_width() + .key_binding(KeyBinding::for_action_in( + &ToggleContextPicker, + &focus_handle, + window, + cx, + )) + .on_click(|_event, window, cx| { + window.dispatch_action( + ToggleContextPicker.boxed_clone(), + cx, + ) + }), + ) + .child( + Button::new("mode", "Switch Model") + .label_size(LabelSize::Small) + .icon(IconName::DatabaseZap) + .icon_position(IconPosition::Start) + .icon_size(IconSize::Small) + .icon_color(Color::Muted) + .full_width() + .key_binding(KeyBinding::for_action_in( + &ToggleModelSelector, + &focus_handle, + window, + cx, + )) + .on_click(|_event, window, cx| { + window.dispatch_action( + ToggleModelSelector.boxed_clone(), + cx, + ) + }), + ) + .child( + Button::new("settings", "View Settings") + .label_size(LabelSize::Small) + .icon(IconName::Settings) + .icon_position(IconPosition::Start) + .icon_size(IconSize::Small) + .icon_color(Color::Muted) + .full_width() + .key_binding(KeyBinding::for_action_in( + &OpenConfiguration, + &focus_handle, + window, + cx, + )) + .on_click(|_event, window, cx| { + window.dispatch_action( + OpenConfiguration.boxed_clone(), + cx, + ) + }), + ), ) }) - .map(|parent| match configuration_error_ref { - Some( - err @ (ConfigurationError::ModelNotFound - | ConfigurationError::ProviderNotAuthenticated(_) - | ConfigurationError::NoProvider), - ) => parent - .child(h_flex().child( - Label::new(err.to_string()).color(Color::Muted).mb_2p5(), - )) - .child( - Button::new("settings", "Configure a Provider") - .icon(IconName::Settings) - .icon_position(IconPosition::Start) - .icon_size(IconSize::Small) - .icon_color(Color::Muted) - .full_width() - .key_binding(KeyBinding::for_action_in( - &OpenConfiguration, - &focus_handle, - window, - cx, - )) - .on_click(|_event, window, cx| { - window.dispatch_action( - OpenConfiguration.boxed_clone(), - cx, - ) - }), - ), - Some(ConfigurationError::ProviderPendingTermsAcceptance(provider)) => { - parent.children(provider.render_accept_terms( - LanguageModelProviderTosView::ThreadFreshStart, - cx, - )) - } - None => parent, + .when_some(configuration_error.as_ref(), |this, err| { + this.child(self.render_configuration_error( + err, + &focus_handle, + window, + cx, + )) }), ) }) .when(!recent_history.is_empty(), |parent| { let focus_handle = focus_handle.clone(); - let configuration_error_ref = &configuration_error; - parent .overflow_hidden() .p_1p5() @@ -2735,49 +2460,55 @@ impl AgentPanel { }, )), ) - .map(|parent| match configuration_error_ref { - Some( - err @ (ConfigurationError::ModelNotFound - | ConfigurationError::ProviderNotAuthenticated(_) - | ConfigurationError::NoProvider), - ) => parent.child( - Banner::new() - .severity(ui::Severity::Warning) - .child(Label::new(err.to_string()).size(LabelSize::Small)) - .action_slot( - Button::new("settings", "Configure Provider") - .style(ButtonStyle::Tinted(ui::TintColor::Warning)) - .label_size(LabelSize::Small) - .key_binding( - KeyBinding::for_action_in( - &OpenConfiguration, - &focus_handle, - window, - cx, - ) - .map(|kb| kb.size(rems_from_px(12.))), - ) - .on_click(|_event, window, cx| { - window.dispatch_action( - OpenConfiguration.boxed_clone(), - cx, - ) - }), - ), - ), - Some(ConfigurationError::ProviderPendingTermsAcceptance(provider)) => { - parent.child(Banner::new().severity(ui::Severity::Warning).child( - h_flex().w_full().children(provider.render_accept_terms( - LanguageModelProviderTosView::ThreadEmptyState, - cx, - )), - )) - } - None => parent, + .when_some(configuration_error.as_ref(), |this, err| { + this.child(self.render_configuration_error(err, &focus_handle, window, cx)) }) }) } + fn render_configuration_error( + &self, + configuration_error: &ConfigurationError, + focus_handle: &FocusHandle, + window: &mut Window, + cx: &mut App, + ) -> impl IntoElement { + match configuration_error { + ConfigurationError::ModelNotFound + | ConfigurationError::ProviderNotAuthenticated(_) + | ConfigurationError::NoProvider => Banner::new() + .severity(ui::Severity::Warning) + .child(Label::new(configuration_error.to_string())) + .action_slot( + Button::new("settings", "Configure Provider") + .style(ButtonStyle::Tinted(ui::TintColor::Warning)) + .label_size(LabelSize::Small) + .key_binding( + KeyBinding::for_action_in( + &OpenConfiguration, + &focus_handle, + window, + cx, + ) + .map(|kb| kb.size(rems_from_px(12.))), + ) + .on_click(|_event, window, cx| { + window.dispatch_action(OpenConfiguration.boxed_clone(), cx) + }), + ), + ConfigurationError::ProviderPendingTermsAcceptance(provider) => { + Banner::new().severity(ui::Severity::Warning).child( + h_flex().w_full().children( + provider.render_accept_terms( + LanguageModelProviderTosView::ThreadEmptyState, + cx, + ), + ), + ) + } + } + } + fn render_tool_use_limit_reached( &self, window: &mut Window, @@ -2910,7 +2641,7 @@ impl AgentPanel { this.clear_last_error(); }); - cx.open_url(&zed_urls::account_url(cx)); + cx.open_url(&zed_urls::upgrade_to_zed_pro_url(cx)); cx.notify(); } })) @@ -3300,7 +3031,7 @@ impl Render for AgentPanel { })) .on_action(cx.listener(Self::toggle_burn_mode)) .child(self.render_toolbar(window, cx)) - .children(self.render_upsell(window, cx)) + .children(self.render_onboarding(window, cx)) .children(self.render_trial_end_upsell(window, cx)) .map(|parent| match &self.active_view { ActiveView::Thread { @@ -3309,12 +3040,14 @@ impl Render for AgentPanel { .. } => parent .relative() - .child(if thread.read(cx).is_empty() { - self.render_thread_empty_state(window, cx) - .into_any_element() - } else { - thread.clone().into_any_element() - }) + .child( + if thread.read(cx).is_empty() && !self.should_render_onboarding(cx) { + self.render_thread_empty_state(window, cx) + .into_any_element() + } else { + thread.clone().into_any_element() + }, + ) .children(self.render_tool_use_limit_reached(window, cx)) .when_some(thread.read(cx).last_error(), |this, last_error| { this.child( @@ -3352,12 +3085,36 @@ impl Render for AgentPanel { context_editor, buffer_search_bar, .. - } => parent.child(self.render_prompt_editor( - context_editor, - buffer_search_bar, - window, - cx, - )), + } => { + let model_registry = LanguageModelRegistry::read_global(cx); + let configuration_error = + model_registry.configuration_error(model_registry.default_model(), cx); + parent + .map(|this| { + if !self.should_render_onboarding(cx) + && let Some(err) = configuration_error.as_ref() + { + this.child( + div().bg(cx.theme().colors().editor_background).p_2().child( + self.render_configuration_error( + err, + &self.focus_handle(cx), + window, + cx, + ), + ), + ) + } else { + this + } + }) + .child(self.render_prompt_editor( + context_editor, + buffer_search_bar, + window, + cx, + )) + } ActiveView::Configuration => parent.children(self.configuration.clone()), }); @@ -3526,9 +3283,9 @@ impl AgentPanelDelegate for ConcreteAssistantPanelDelegate { } } -struct Upsell; +struct OnboardingUpsell; -impl Dismissable for Upsell { +impl Dismissable for OnboardingUpsell { const KEY: &'static str = "dismissed-trial-upsell"; } diff --git a/crates/agent_ui/src/inline_prompt_editor.rs b/crates/agent_ui/src/inline_prompt_editor.rs index 7a61eef748..ade7a5e13d 100644 --- a/crates/agent_ui/src/inline_prompt_editor.rs +++ b/crates/agent_ui/src/inline_prompt_editor.rs @@ -2,7 +2,6 @@ use crate::agent_model_selector::AgentModelSelector; use crate::buffer_codegen::BufferCodegen; use crate::context_picker::{ContextPicker, ContextPickerCompletionProvider}; use crate::context_strip::{ContextStrip, ContextStripEvent, SuggestContextKind}; -use crate::language_model_selector::ToggleModelSelector; use crate::message_editor::{ContextCreasesAddon, extract_message_creases, insert_message_creases}; use crate::terminal_codegen::TerminalCodegen; use crate::{CycleNextInlineAssist, CyclePreviousInlineAssist, ModelUsageContext}; @@ -38,6 +37,7 @@ use ui::{ CheckboxWithLabel, IconButtonShape, KeyBinding, Popover, PopoverMenuHandle, Tooltip, prelude::*, }; use workspace::Workspace; +use zed_actions::agent::ToggleModelSelector; pub struct PromptEditor { pub editor: Entity, diff --git a/crates/agent_ui/src/language_model_selector.rs b/crates/agent_ui/src/language_model_selector.rs index ff18a95f3f..655e87d7cd 100644 --- a/crates/agent_ui/src/language_model_selector.rs +++ b/crates/agent_ui/src/language_model_selector.rs @@ -3,9 +3,7 @@ use std::{cmp::Reverse, sync::Arc}; use collections::{HashSet, IndexMap}; use feature_flags::ZedProFeatureFlag; use fuzzy::{StringMatch, StringMatchCandidate, match_strings}; -use gpui::{ - Action, AnyElement, App, BackgroundExecutor, DismissEvent, Subscription, Task, actions, -}; +use gpui::{Action, AnyElement, App, BackgroundExecutor, DismissEvent, Subscription, Task}; use language_model::{ AuthenticateError, ConfiguredModel, LanguageModel, LanguageModelProviderId, LanguageModelRegistry, @@ -15,15 +13,6 @@ use picker::{Picker, PickerDelegate}; use proto::Plan; use ui::{ListItem, ListItemSpacing, prelude::*}; -actions!( - agent, - [ - /// Toggles the language model selector dropdown. - #[action(deprecated_aliases = ["assistant::ToggleModelSelector", "assistant2::ToggleModelSelector"])] - ToggleModelSelector - ] -); - const TRY_ZED_PRO_URL: &str = "https://zed.dev/pro"; type OnModelChanged = Arc, &mut App) + 'static>; diff --git a/crates/agent_ui/src/message_editor.rs b/crates/agent_ui/src/message_editor.rs index d2b136f274..6967c8ab3e 100644 --- a/crates/agent_ui/src/message_editor.rs +++ b/crates/agent_ui/src/message_editor.rs @@ -4,7 +4,6 @@ use std::sync::Arc; use crate::agent_diff::AgentDiffThread; use crate::agent_model_selector::AgentModelSelector; -use crate::language_model_selector::ToggleModelSelector; use crate::tool_compatibility::{IncompatibleToolsState, IncompatibleToolsTooltip}; use crate::ui::{ MaxModeTooltip, @@ -49,6 +48,7 @@ use ui::{ use util::ResultExt as _; use workspace::{CollaboratorId, Workspace}; use zed_actions::agent::Chat; +use zed_actions::agent::ToggleModelSelector; use zed_llm_client::CompletionIntent; use crate::context_picker::{ContextPicker, ContextPickerCompletionProvider, crease_for_mention}; @@ -609,7 +609,11 @@ impl MessageEditor { ) } - fn render_follow_toggle(&self, cx: &mut Context) -> impl IntoElement { + fn render_follow_toggle( + &self, + is_model_selected: bool, + cx: &mut Context, + ) -> impl IntoElement { let following = self .workspace .read_with(cx, |workspace, _| { @@ -618,6 +622,7 @@ impl MessageEditor { .unwrap_or(false); IconButton::new("follow-agent", IconName::Crosshair) + .disabled(is_model_selected) .icon_size(IconSize::Small) .icon_color(Color::Muted) .toggle_state(following) @@ -786,7 +791,7 @@ impl MessageEditor { .justify_between() .child( h_flex() - .child(self.render_follow_toggle(cx)) + .child(self.render_follow_toggle(is_model_selected, cx)) .children(self.render_burn_mode_toggle(cx)), ) .child( diff --git a/crates/agent_ui/src/text_thread_editor.rs b/crates/agent_ui/src/text_thread_editor.rs index 2941da1965..3df0a48aa4 100644 --- a/crates/agent_ui/src/text_thread_editor.rs +++ b/crates/agent_ui/src/text_thread_editor.rs @@ -1,8 +1,6 @@ use crate::{ burn_mode_tooltip::BurnModeTooltip, - language_model_selector::{ - LanguageModelSelector, ToggleModelSelector, language_model_selector, - }, + language_model_selector::{LanguageModelSelector, language_model_selector}, }; use agent_settings::{AgentSettings, CompletionMode}; use anyhow::Result; @@ -38,8 +36,7 @@ use language::{ language_settings::{SoftWrap, all_language_settings}, }; use language_model::{ - ConfigurationError, LanguageModelExt, LanguageModelImage, LanguageModelProviderTosView, - LanguageModelRegistry, Role, + ConfigurationError, LanguageModelExt, LanguageModelImage, LanguageModelRegistry, Role, }; use multi_buffer::MultiBufferRow; use picker::{Picker, popover_menu::PickerPopoverMenu}; @@ -74,6 +71,7 @@ use workspace::{ pane, searchable::{SearchEvent, SearchableItem}, }; +use zed_actions::agent::ToggleModelSelector; use crate::{slash_command::SlashCommandCompletionProvider, slash_command_picker}; use assistant_context::{ @@ -1895,108 +1893,6 @@ impl TextThreadEditor { .update(cx, |context, cx| context.summarize(true, cx)); } - fn render_notice(&self, cx: &mut Context) -> Option { - // This was previously gated behind the `zed-pro` feature flag. Since we - // aren't planning to ship that right now, we're just hard-coding this - // value to not show the nudge. - let nudge = Some(false); - - let model_registry = LanguageModelRegistry::read_global(cx); - - if nudge.map_or(false, |value| value) { - Some( - h_flex() - .p_3() - .border_b_1() - .border_color(cx.theme().colors().border_variant) - .bg(cx.theme().colors().editor_background) - .justify_between() - .child( - h_flex() - .gap_3() - .child(Icon::new(IconName::ZedAssistant).color(Color::Accent)) - .child(Label::new("Zed AI is here! Get started by signing in →")), - ) - .child( - Button::new("sign-in", "Sign in") - .size(ButtonSize::Compact) - .style(ButtonStyle::Filled) - .on_click(cx.listener(|this, _event, _window, cx| { - let client = this - .workspace - .read_with(cx, |workspace, _| workspace.client().clone()) - .log_err(); - - if let Some(client) = client { - cx.spawn(async move |context_editor, cx| { - match client.authenticate_and_connect(true, cx).await { - util::ConnectionResult::Timeout => { - log::error!("Authentication timeout") - } - util::ConnectionResult::ConnectionReset => { - log::error!("Connection reset") - } - util::ConnectionResult::Result(r) => { - if r.log_err().is_some() { - context_editor - .update(cx, |_, cx| cx.notify()) - .ok(); - } - } - } - }) - .detach() - } - })), - ) - .into_any_element(), - ) - } else if let Some(configuration_error) = - model_registry.configuration_error(model_registry.default_model(), cx) - { - Some( - h_flex() - .px_3() - .py_2() - .border_b_1() - .border_color(cx.theme().colors().border_variant) - .bg(cx.theme().colors().editor_background) - .justify_between() - .child( - h_flex() - .gap_3() - .child( - Icon::new(IconName::Warning) - .size(IconSize::Small) - .color(Color::Warning), - ) - .child(Label::new(configuration_error.to_string())), - ) - .child( - Button::new("open-configuration", "Configure Providers") - .size(ButtonSize::Compact) - .icon(Some(IconName::SlidersVertical)) - .icon_size(IconSize::Small) - .icon_position(IconPosition::Start) - .style(ButtonStyle::Filled) - .on_click({ - let focus_handle = self.focus_handle(cx).clone(); - move |_event, window, cx| { - focus_handle.dispatch_action( - &zed_actions::agent::OpenConfiguration, - window, - cx, - ); - } - }), - ) - .into_any_element(), - ) - } else { - None - } - } - fn render_send_button(&self, window: &mut Window, cx: &mut Context) -> impl IntoElement { let focus_handle = self.focus_handle(cx).clone(); @@ -2128,12 +2024,13 @@ impl TextThreadEditor { .map(|default| default.model); let model_name = match active_model { Some(model) => model.name().0, - None => SharedString::from("No model selected"), + None => SharedString::from("Select Model"), }; let active_provider = LanguageModelRegistry::read_global(cx) .default_model() .map(|default| default.provider); + let provider_icon = match active_provider { Some(provider) => provider.icon(), None => IconName::Ai, @@ -2581,20 +2478,7 @@ impl EventEmitter for TextThreadEditor {} impl Render for TextThreadEditor { fn render(&mut self, window: &mut Window, cx: &mut Context) -> impl IntoElement { - let provider = LanguageModelRegistry::read_global(cx) - .default_model() - .map(|default| default.provider); - - let accept_terms = if self.show_accept_terms { - provider.as_ref().and_then(|provider| { - provider.render_accept_terms(LanguageModelProviderTosView::PromptEditorPopup, cx) - }) - } else { - None - }; - let language_model_selector = self.language_model_selector_menu_handle.clone(); - let burn_mode_toggle = self.render_burn_mode_toggle(cx); v_flex() .key_context("ContextEditor") @@ -2611,28 +2495,12 @@ impl Render for TextThreadEditor { language_model_selector.toggle(window, cx); }) .size_full() - .children(self.render_notice(cx)) .child( div() .flex_grow() .bg(cx.theme().colors().editor_background) .child(self.editor.clone()), ) - .when_some(accept_terms, |this, element| { - this.child( - div() - .absolute() - .right_3() - .bottom_12() - .max_w_96() - .py_2() - .px_3() - .elevation_2(cx) - .bg(cx.theme().colors().surface_background) - .occlude() - .child(element), - ) - }) .children(self.render_last_error(cx)) .child( h_flex() @@ -2649,7 +2517,7 @@ impl Render for TextThreadEditor { h_flex() .gap_0p5() .child(self.render_inject_context_menu(cx)) - .when_some(burn_mode_toggle, |this, element| this.child(element)), + .children(self.render_burn_mode_toggle(cx)), ) .child( h_flex() diff --git a/crates/agent_ui/src/ui.rs b/crates/agent_ui/src/ui.rs index 43cd0f5e89..6398f64abb 100644 --- a/crates/agent_ui/src/ui.rs +++ b/crates/agent_ui/src/ui.rs @@ -1,6 +1,7 @@ mod agent_notification; mod burn_mode_tooltip; mod context_pill; +mod end_trial_upsell; mod onboarding_modal; pub mod preview; mod upsell; @@ -8,4 +9,5 @@ mod upsell; pub use agent_notification::*; pub use burn_mode_tooltip::*; pub use context_pill::*; +pub use end_trial_upsell::*; pub use onboarding_modal::*; diff --git a/crates/agent_ui/src/ui/end_trial_upsell.rs b/crates/agent_ui/src/ui/end_trial_upsell.rs new file mode 100644 index 0000000000..9c2dd98d20 --- /dev/null +++ b/crates/agent_ui/src/ui/end_trial_upsell.rs @@ -0,0 +1,112 @@ +use std::sync::Arc; + +use ai_onboarding::{AgentPanelOnboardingCard, BulletItem}; +use client::zed_urls; +use gpui::{AnyElement, App, IntoElement, RenderOnce, Window}; +use ui::{Divider, List, prelude::*}; + +#[derive(IntoElement, RegisterComponent)] +pub struct EndTrialUpsell { + dismiss_upsell: Arc, +} + +impl EndTrialUpsell { + pub fn new(dismiss_upsell: Arc) -> Self { + Self { dismiss_upsell } + } +} + +impl RenderOnce for EndTrialUpsell { + fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement { + let pro_section = v_flex() + .gap_1() + .child( + h_flex() + .gap_2() + .child( + Label::new("Pro") + .size(LabelSize::Small) + .color(Color::Accent) + .buffer_font(cx), + ) + .child(Divider::horizontal()), + ) + .child( + List::new() + .child(BulletItem::new("500 prompts per month with Claude models")) + .child(BulletItem::new("Unlimited edit predictions")), + ) + .child( + Button::new("cta-button", "Upgrade to Zed Pro") + .full_width() + .style(ButtonStyle::Tinted(ui::TintColor::Accent)) + .on_click(|_, _, cx| cx.open_url(&zed_urls::upgrade_to_zed_pro_url(cx))), + ); + + let free_section = v_flex() + .mt_1p5() + .gap_1() + .child( + h_flex() + .gap_2() + .child( + Label::new("Free") + .size(LabelSize::Small) + .color(Color::Muted) + .buffer_font(cx), + ) + .child(Divider::horizontal()), + ) + .child( + List::new() + .child(BulletItem::new( + "50 prompts per month with the Claude models", + )) + .child(BulletItem::new( + "2000 accepted edit predictions using our open-source Zeta model", + )), + ) + .child( + Button::new("dismiss-button", "Stay on Free") + .full_width() + .style(ButtonStyle::Outlined) + .on_click({ + let callback = self.dismiss_upsell.clone(); + move |_, window, cx| callback(window, cx) + }), + ); + + AgentPanelOnboardingCard::new() + .child(Headline::new("Your Zed Pro trial has expired.")) + .child( + Label::new("You've been automatically reset to the Free plan.") + .size(LabelSize::Small) + .color(Color::Muted) + .mb_1(), + ) + .child(pro_section) + .child(free_section) + } +} + +impl Component for EndTrialUpsell { + fn scope() -> ComponentScope { + ComponentScope::Agent + } + + fn sort_name() -> &'static str { + "AgentEndTrialUpsell" + } + + fn preview(_window: &mut Window, _cx: &mut App) -> Option { + Some( + v_flex() + .p_4() + .gap_4() + .child(EndTrialUpsell { + dismiss_upsell: Arc::new(|_, _| {}), + }) + .into_any_element(), + ) + } +} diff --git a/crates/ai_onboarding/Cargo.toml b/crates/ai_onboarding/Cargo.toml new file mode 100644 index 0000000000..e9208a7248 --- /dev/null +++ b/crates/ai_onboarding/Cargo.toml @@ -0,0 +1,27 @@ +[package] +name = "ai_onboarding" +version = "0.1.0" +edition.workspace = true +publish.workspace = true +license = "GPL-3.0-or-later" + +[lints] +workspace = true + +[lib] +path = "src/ai_onboarding.rs" + +[features] +default = [] + +[dependencies] +client.workspace = true +component.workspace = true +gpui.workspace = true +language_model.workspace = true +proto.workspace = true +serde.workspace = true +smallvec.workspace = true +ui.workspace = true +workspace-hack.workspace = true +zed_actions.workspace = true diff --git a/crates/ai_onboarding/LICENSE-GPL b/crates/ai_onboarding/LICENSE-GPL new file mode 120000 index 0000000000..89e542f750 --- /dev/null +++ b/crates/ai_onboarding/LICENSE-GPL @@ -0,0 +1 @@ +../../LICENSE-GPL \ No newline at end of file diff --git a/crates/ai_onboarding/src/agent_panel_onboarding_card.rs b/crates/ai_onboarding/src/agent_panel_onboarding_card.rs new file mode 100644 index 0000000000..8ec9ccfe22 --- /dev/null +++ b/crates/ai_onboarding/src/agent_panel_onboarding_card.rs @@ -0,0 +1,81 @@ +use gpui::{AnyElement, IntoElement, ParentElement, linear_color_stop, linear_gradient}; +use smallvec::SmallVec; +use ui::{Vector, VectorName, prelude::*}; + +#[derive(IntoElement)] +pub struct AgentPanelOnboardingCard { + children: SmallVec<[AnyElement; 2]>, +} + +impl AgentPanelOnboardingCard { + pub fn new() -> Self { + Self { + children: SmallVec::new(), + } + } +} + +impl ParentElement for AgentPanelOnboardingCard { + fn extend(&mut self, elements: impl IntoIterator) { + self.children.extend(elements) + } +} + +impl RenderOnce for AgentPanelOnboardingCard { + fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement { + div() + .m_4() + .p(px(3.)) + .elevation_2(cx) + .rounded_lg() + .bg(cx.theme().colors().background.alpha(0.5)) + .child( + v_flex() + .relative() + .size_full() + .px_4() + .py_3() + .gap_2() + .border_1() + .rounded(px(5.)) + .border_color(cx.theme().colors().text.alpha(0.1)) + .overflow_hidden() + .bg(cx.theme().colors().panel_background) + .child( + div() + .opacity(0.5) + .absolute() + .top(px(-8.0)) + .right_0() + .w(px(400.)) + .h(px(92.)) + .child( + Vector::new( + VectorName::AiGrid, + rems_from_px(400.), + rems_from_px(92.), + ) + .color(Color::Custom(cx.theme().colors().text.alpha(0.32))), + ), + ) + .child( + div() + .absolute() + .top_0() + .right_0() + .w(px(660.)) + .h(px(401.)) + .overflow_hidden() + .bg(linear_gradient( + 75., + linear_color_stop( + cx.theme().colors().panel_background.alpha(0.01), + 1.0, + ), + linear_color_stop(cx.theme().colors().panel_background, 0.45), + )), + ) + .children(self.children), + ) + } +} diff --git a/crates/ai_onboarding/src/agent_panel_onboarding_content.rs b/crates/ai_onboarding/src/agent_panel_onboarding_content.rs new file mode 100644 index 0000000000..f3f7d6c3d7 --- /dev/null +++ b/crates/ai_onboarding/src/agent_panel_onboarding_content.rs @@ -0,0 +1,145 @@ +use std::sync::Arc; + +use client::{Client, UserStore}; +use gpui::{Action, ClickEvent, Entity, IntoElement, ParentElement}; +use language_model::{LanguageModelRegistry, ZED_CLOUD_PROVIDER_ID}; +use ui::{Divider, List, prelude::*}; +use zed_actions::agent::{OpenConfiguration, ToggleModelSelector}; + +use crate::{AgentPanelOnboardingCard, BulletItem, ZedAiOnboarding}; + +pub struct AgentPanelOnboarding { + user_store: Entity, + client: Arc, + configured_providers: Vec<(IconName, SharedString)>, + continue_with_zed_ai: Arc, +} + +impl AgentPanelOnboarding { + pub fn new( + user_store: Entity, + client: Arc, + continue_with_zed_ai: impl Fn(&mut Window, &mut App) + 'static, + cx: &mut Context, + ) -> Self { + cx.subscribe( + &LanguageModelRegistry::global(cx), + |this: &mut Self, _registry, event: &language_model::Event, cx| match event { + language_model::Event::ProviderStateChanged + | language_model::Event::AddedProvider(_) + | language_model::Event::RemovedProvider(_) => { + this.configured_providers = Self::compute_available_providers(cx) + } + _ => {} + }, + ) + .detach(); + + Self { + user_store, + client, + configured_providers: Self::compute_available_providers(cx), + continue_with_zed_ai: Arc::new(continue_with_zed_ai), + } + } + + fn compute_available_providers(cx: &App) -> Vec<(IconName, SharedString)> { + LanguageModelRegistry::read_global(cx) + .providers() + .iter() + .filter(|provider| { + provider.is_authenticated(cx) && provider.id() != ZED_CLOUD_PROVIDER_ID + }) + .map(|provider| (provider.icon(), provider.name().0.clone())) + .collect() + } + + fn configure_providers(&mut self, _: &ClickEvent, window: &mut Window, cx: &mut Context) { + window.dispatch_action(OpenConfiguration.boxed_clone(), cx); + cx.notify(); + } + + fn render_api_keys_section(&mut self, cx: &mut Context) -> impl IntoElement { + let has_existing_providers = self.configured_providers.len() > 0; + let configure_provider_label = if has_existing_providers { + "Configure Other Provider" + } else { + "Configure Providers" + }; + + let content = if has_existing_providers { + List::new() + .child(BulletItem::new( + "Or start now using API keys from your environment for the following providers:" + )) + .child( + h_flex() + .px_5() + .gap_2() + .flex_wrap() + .children(self.configured_providers.iter().cloned().map(|(icon, name)| + h_flex() + .gap_1p5() + .child(Icon::new(icon).size(IconSize::Small).color(Color::Muted)) + .child(Label::new(name)) + )) + ) + .child(BulletItem::new( + "No need for any of the plans or even to sign in", + )) + } else { + List::new() + .child(BulletItem::new( + "You can also use AI in Zed by bringing your own API keys", + )) + .child(BulletItem::new( + "No need for any of the plans or even to sign in", + )) + }; + + v_flex() + .mt_2() + .gap_1() + .child( + h_flex() + .gap_2() + .child( + Label::new("API Keys") + .size(LabelSize::Small) + .color(Color::Muted) + .buffer_font(cx), + ) + .child(Divider::horizontal()), + ) + .child(content) + .when(has_existing_providers, |this| { + this.child( + Button::new("pick-model", "Choose Model") + .full_width() + .style(ButtonStyle::Outlined) + .on_click(|_event, window, cx| { + window.dispatch_action(ToggleModelSelector.boxed_clone(), cx) + }), + ) + }) + .child( + Button::new("configure-providers", configure_provider_label) + .full_width() + .style(ButtonStyle::Outlined) + .on_click(cx.listener(Self::configure_providers)), + ) + } +} + +impl Render for AgentPanelOnboarding { + fn render(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement { + AgentPanelOnboardingCard::new() + .child(ZedAiOnboarding::new( + self.client.clone(), + &self.user_store, + self.continue_with_zed_ai.clone(), + cx, + )) + .child(self.render_api_keys_section(cx)) + } +} diff --git a/crates/ai_onboarding/src/ai_onboarding.rs b/crates/ai_onboarding/src/ai_onboarding.rs new file mode 100644 index 0000000000..131d385e78 --- /dev/null +++ b/crates/ai_onboarding/src/ai_onboarding.rs @@ -0,0 +1,397 @@ +mod agent_panel_onboarding_card; +mod agent_panel_onboarding_content; +mod edit_prediction_onboarding_content; +mod young_account_banner; + +pub use agent_panel_onboarding_card::AgentPanelOnboardingCard; +pub use agent_panel_onboarding_content::AgentPanelOnboarding; +pub use edit_prediction_onboarding_content::EditPredictionOnboarding; +pub use young_account_banner::YoungAccountBanner; + +use std::sync::Arc; + +use client::{Client, UserStore, zed_urls}; +use gpui::{AnyElement, Entity, IntoElement, ParentElement, SharedString}; +use ui::{Divider, List, ListItem, RegisterComponent, TintColor, prelude::*}; + +pub struct BulletItem { + label: SharedString, +} + +impl BulletItem { + pub fn new(label: impl Into) -> Self { + Self { + label: label.into(), + } + } +} + +impl IntoElement for BulletItem { + type Element = AnyElement; + + fn into_element(self) -> Self::Element { + ListItem::new("list-item") + .selectable(false) + .start_slot( + Icon::new(IconName::Dash) + .size(IconSize::XSmall) + .color(Color::Hidden), + ) + .child(div().w_full().child(Label::new(self.label))) + .into_any_element() + } +} + +pub enum SignInStatus { + SignedIn, + SigningIn, + SignedOut, +} + +impl From for SignInStatus { + fn from(status: client::Status) -> Self { + if status.is_signing_in() { + Self::SigningIn + } else if status.is_signed_out() { + Self::SignedOut + } else { + Self::SignedIn + } + } +} + +#[derive(RegisterComponent, IntoElement)] +pub struct ZedAiOnboarding { + pub sign_in_status: SignInStatus, + pub has_accepted_terms_of_service: bool, + pub plan: Option, + pub account_too_young: bool, + pub continue_with_zed_ai: Arc, + pub sign_in: Arc, + pub accept_terms_of_service: Arc, +} + +impl ZedAiOnboarding { + pub fn new( + client: Arc, + user_store: &Entity, + continue_with_zed_ai: Arc, + cx: &mut App, + ) -> Self { + let store = user_store.read(cx); + let status = *client.status().borrow(); + Self { + sign_in_status: status.into(), + has_accepted_terms_of_service: store.current_user_has_accepted_terms().unwrap_or(false), + plan: store.current_plan(), + account_too_young: store.account_too_young(), + continue_with_zed_ai, + accept_terms_of_service: Arc::new({ + let store = user_store.clone(); + move |_window, cx| { + let task = store.update(cx, |store, cx| store.accept_terms_of_service(cx)); + task.detach_and_log_err(cx); + } + }), + sign_in: Arc::new(move |_window, cx| { + cx.spawn({ + let client = client.clone(); + async move |cx| { + client.authenticate_and_connect(true, cx).await; + } + }) + .detach(); + }), + } + } + + fn render_free_plan_section(&self, cx: &mut App) -> impl IntoElement { + v_flex() + .mt_2() + .gap_1() + .when(self.account_too_young, |this| this.opacity(0.4)) + .child( + h_flex() + .gap_2() + .child( + Label::new("Free") + .size(LabelSize::Small) + .color(Color::Muted) + .buffer_font(cx), + ) + .child(Divider::horizontal()), + ) + .child( + List::new() + .child(BulletItem::new( + "50 prompts per month with the Claude models", + )) + .child(BulletItem::new( + "2000 accepted edit predictions using our open-source Zeta model", + )), + ) + .child( + Button::new("continue", "Continue Free") + .disabled(self.account_too_young) + .full_width() + .style(ButtonStyle::Outlined) + .on_click({ + let callback = self.continue_with_zed_ai.clone(); + move |_, window, cx| callback(window, cx) + }), + ) + } + + fn render_pro_plan_section(&self, cx: &mut App) -> impl IntoElement { + let (button_label, button_url) = if self.account_too_young { + ("Start with Pro", zed_urls::upgrade_to_zed_pro_url(cx)) + } else { + ("Start Pro Trial", zed_urls::account_url(cx)) + }; + + v_flex() + .mt_2() + .gap_1() + .child( + h_flex() + .gap_2() + .child( + Label::new("Pro") + .size(LabelSize::Small) + .color(Color::Accent) + .buffer_font(cx), + ) + .child(Divider::horizontal()), + ) + .child( + List::new() + .child(BulletItem::new("500 prompts per month with Claude models")) + .child(BulletItem::new("Unlimited edit predictions")) + .when(!self.account_too_young, |this| { + this.child(BulletItem::new( + "Try it out for 14 days with no charge, no credit card required", + )) + }), + ) + .child( + Button::new("pro", button_label) + .full_width() + .style(ButtonStyle::Tinted(ui::TintColor::Accent)) + .on_click(move |_, _window, cx| cx.open_url(&button_url)), + ) + } + + fn render_accept_terms_of_service(&self) -> Div { + v_flex() + .w_full() + .gap_1() + .child(Headline::new("Before starting…")) + .child(Label::new( + "Make sure you have read and accepted Zed AI's terms of service.", + )) + .child( + Button::new("terms_of_service", "View and Read the Terms of Service") + .full_width() + .style(ButtonStyle::Outlined) + .icon(IconName::ArrowUpRight) + .icon_color(Color::Muted) + .icon_size(IconSize::XSmall) + .on_click(move |_, _window, cx| { + cx.open_url("https://zed.dev/terms-of-service") + }), + ) + .child( + Button::new("accept_terms", "I've read it and accept it") + .full_width() + .style(ButtonStyle::Tinted(TintColor::Accent)) + .on_click({ + let callback = self.accept_terms_of_service.clone(); + move |_, window, cx| (callback)(window, cx) + }), + ) + } + + fn render_sign_in_disclaimer(&self, _cx: &mut App) -> Div { + const SIGN_IN_DISCLAIMER: &str = + "To start using AI in Zed with our hosted models, sign in and subscribe to a plan."; + let signing_in = matches!(self.sign_in_status, SignInStatus::SigningIn); + + v_flex() + .gap_2() + .child(Headline::new("Welcome to Zed AI")) + .child(div().w_full().child(Label::new(SIGN_IN_DISCLAIMER))) + .child( + Button::new("sign_in", "Sign In with GitHub") + .icon(IconName::Github) + .icon_position(IconPosition::Start) + .icon_size(IconSize::Small) + .icon_color(Color::Muted) + .disabled(signing_in) + .full_width() + .style(ButtonStyle::Tinted(ui::TintColor::Accent)) + .on_click({ + let callback = self.sign_in.clone(); + move |_, window, cx| callback(window, cx) + }), + ) + } + + fn render_free_plan_onboarding(&self, cx: &mut App) -> Div { + const PLANS_DESCRIPTION: &str = "Choose how you want to start."; + let young_account_banner = YoungAccountBanner; + + v_flex() + .child(Headline::new("Welcome to Zed AI")) + .child( + Label::new(PLANS_DESCRIPTION) + .size(LabelSize::Small) + .color(Color::Muted) + .mt_1() + .mb_3(), + ) + .when(self.account_too_young, |this| { + this.child(young_account_banner) + }) + .child(self.render_free_plan_section(cx)) + .child(self.render_pro_plan_section(cx)) + } + + fn render_trial_onboarding(&self, _cx: &mut App) -> Div { + v_flex() + .child(Headline::new("Welcome to the trial of Zed Pro")) + .child( + Label::new("Here's what you get for the next 14 days:") + .size(LabelSize::Small) + .color(Color::Muted) + .mt_1(), + ) + .child( + List::new() + .child(BulletItem::new("150 prompts with Claude models")) + .child(BulletItem::new( + "Unlimited edit predictions with Zeta, our open-source model", + )), + ) + .child( + Button::new("trial", "Start Trial") + .full_width() + .style(ButtonStyle::Outlined) + .on_click({ + let callback = self.continue_with_zed_ai.clone(); + move |_, window, cx| callback(window, cx) + }), + ) + } + + fn render_pro_plan_onboarding(&self, _cx: &mut App) -> Div { + v_flex() + .child(Headline::new("Welcome to Zed Pro")) + .child( + Label::new("Here's what you get:") + .size(LabelSize::Small) + .color(Color::Muted) + .mt_1(), + ) + .child( + List::new() + .child(BulletItem::new("500 prompts with Claude models")) + .child(BulletItem::new("Unlimited edit predictions")), + ) + .child( + Button::new("pro", "Continue with Zed Pro") + .full_width() + .style(ButtonStyle::Outlined) + .on_click({ + let callback = self.continue_with_zed_ai.clone(); + move |_, window, cx| callback(window, cx) + }), + ) + } +} + +impl RenderOnce for ZedAiOnboarding { + fn render(self, _window: &mut ui::Window, cx: &mut App) -> impl IntoElement { + if matches!(self.sign_in_status, SignInStatus::SignedIn) { + if self.has_accepted_terms_of_service { + match self.plan { + None | Some(proto::Plan::Free) => self.render_free_plan_onboarding(cx), + Some(proto::Plan::ZedProTrial) => self.render_trial_onboarding(cx), + Some(proto::Plan::ZedPro) => self.render_pro_plan_onboarding(cx), + } + } else { + self.render_accept_terms_of_service() + } + } else { + self.render_sign_in_disclaimer(cx) + } + } +} + +impl Component for ZedAiOnboarding { + fn scope() -> ComponentScope { + ComponentScope::Agent + } + + fn preview(_window: &mut Window, _cx: &mut App) -> Option { + fn onboarding( + sign_in_status: SignInStatus, + has_accepted_terms_of_service: bool, + plan: Option, + account_too_young: bool, + ) -> AnyElement { + ZedAiOnboarding { + sign_in_status, + has_accepted_terms_of_service, + plan, + account_too_young, + continue_with_zed_ai: Arc::new(|_, _| {}), + sign_in: Arc::new(|_, _| {}), + accept_terms_of_service: Arc::new(|_, _| {}), + } + .into_any_element() + } + + Some( + v_flex() + .p_4() + .gap_4() + .children(vec![ + single_example( + "Not Signed-in", + onboarding(SignInStatus::SignedOut, false, None, false), + ), + single_example( + "Not Accepted ToS", + onboarding(SignInStatus::SignedIn, false, None, false), + ), + single_example( + "Account too young", + onboarding(SignInStatus::SignedIn, false, None, true), + ), + single_example( + "Free Plan", + onboarding(SignInStatus::SignedIn, true, Some(proto::Plan::Free), false), + ), + single_example( + "Pro Trial", + onboarding( + SignInStatus::SignedIn, + true, + Some(proto::Plan::ZedProTrial), + false, + ), + ), + single_example( + "Pro Plan", + onboarding( + SignInStatus::SignedIn, + true, + Some(proto::Plan::ZedPro), + false, + ), + ), + ]) + .into_any_element(), + ) + } +} diff --git a/crates/ai_onboarding/src/edit_prediction_onboarding_content.rs b/crates/ai_onboarding/src/edit_prediction_onboarding_content.rs new file mode 100644 index 0000000000..e883d8da8c --- /dev/null +++ b/crates/ai_onboarding/src/edit_prediction_onboarding_content.rs @@ -0,0 +1,73 @@ +use std::sync::Arc; + +use client::{Client, UserStore}; +use gpui::{Entity, IntoElement, ParentElement}; +use ui::prelude::*; + +use crate::ZedAiOnboarding; + +pub struct EditPredictionOnboarding { + user_store: Entity, + client: Arc, + copilot_is_configured: bool, + continue_with_zed_ai: Arc, + continue_with_copilot: Arc, +} + +impl EditPredictionOnboarding { + pub fn new( + user_store: Entity, + client: Arc, + copilot_is_configured: bool, + continue_with_zed_ai: Arc, + continue_with_copilot: Arc, + _cx: &mut Context, + ) -> Self { + Self { + user_store, + copilot_is_configured, + client, + continue_with_zed_ai, + continue_with_copilot, + } + } +} + +impl Render for EditPredictionOnboarding { + fn render(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement { + let github_copilot = v_flex() + .gap_1() + .child(Label::new(if self.copilot_is_configured { + "Alternatively, you can continue to use GitHub Copilot as that's already set up." + } else { + "Alternatively, you can use GitHub Copilot as your edit prediction provider." + })) + .child( + Button::new( + "configure-copilot", + if self.copilot_is_configured { + "Use Copilot" + } else { + "Configure Copilot" + }, + ) + .full_width() + .style(ButtonStyle::Outlined) + .on_click({ + let callback = self.continue_with_copilot.clone(); + move |_, window, cx| callback(window, cx) + }), + ); + + v_flex() + .gap_2() + .child(ZedAiOnboarding::new( + self.client.clone(), + &self.user_store, + self.continue_with_zed_ai.clone(), + cx, + )) + .child(ui::Divider::horizontal()) + .child(github_copilot) + } +} diff --git a/crates/ai_onboarding/src/young_account_banner.rs b/crates/ai_onboarding/src/young_account_banner.rs new file mode 100644 index 0000000000..f6e1446fd0 --- /dev/null +++ b/crates/ai_onboarding/src/young_account_banner.rs @@ -0,0 +1,21 @@ +use gpui::{IntoElement, ParentElement}; +use ui::{Banner, prelude::*}; + +#[derive(IntoElement)] +pub struct YoungAccountBanner; + +impl RenderOnce for YoungAccountBanner { + fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement { + const YOUNG_ACCOUNT_DISCLAIMER: &str = "Given your GitHub account was created less than 30 days ago, we cannot put you in the Free plan or offer you a free trial of the Pro plan. We hope you'll understand, as this is unfortunately required to prevent abuse of our service. To continue, upgrade to Pro or use your own API keys for other providers."; + + let label = div() + .w_full() + .text_sm() + .text_color(cx.theme().colors().text_muted) + .child(YOUNG_ACCOUNT_DISCLAIMER); + + div() + .my_1() + .child(Banner::new().severity(ui::Severity::Warning).child(label)) + } +} diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs index c4211f72c8..1be8ffdb55 100644 --- a/crates/client/src/client.rs +++ b/crates/client/src/client.rs @@ -301,6 +301,13 @@ impl Status { matches!(self, Self::Connected { .. }) } + pub fn is_signing_in(&self) -> bool { + matches!( + self, + Self::Authenticating | Self::Reauthenticating | Self::Connecting | Self::Reconnecting + ) + } + pub fn is_signed_out(&self) -> bool { matches!(self, Self::SignedOut | Self::UpgradeRequired) } diff --git a/crates/client/src/user.rs b/crates/client/src/user.rs index 61e3064eb4..f5213fbcb6 100644 --- a/crates/client/src/user.rs +++ b/crates/client/src/user.rs @@ -764,6 +764,16 @@ impl UserStore { } pub fn current_plan(&self) -> Option { + #[cfg(debug_assertions)] + if let Ok(plan) = std::env::var("ZED_SIMULATE_ZED_PRO_PLAN").as_ref() { + return match plan.as_str() { + "free" => Some(proto::Plan::Free), + "trial" => Some(proto::Plan::ZedProTrial), + "pro" => Some(proto::Plan::ZedPro), + _ => None, + }; + } + self.current_plan } diff --git a/crates/client/src/zed_urls.rs b/crates/client/src/zed_urls.rs index bfdae468fb..442875b451 100644 --- a/crates/client/src/zed_urls.rs +++ b/crates/client/src/zed_urls.rs @@ -17,3 +17,8 @@ fn server_url(cx: &App) -> &str { pub fn account_url(cx: &App) -> String { format!("{server_url}/account", server_url = server_url(cx)) } + +/// Returns the URL to the upgrade page on zed.dev. +pub fn upgrade_to_zed_pro_url(cx: &App) -> String { + format!("{server_url}/account/upgrade", server_url = server_url(cx)) +} diff --git a/crates/copilot/src/copilot.rs b/crates/copilot/src/copilot.rs index e4370d2e67..1966d1a389 100644 --- a/crates/copilot/src/copilot.rs +++ b/crates/copilot/src/copilot.rs @@ -209,8 +209,14 @@ impl Status { matches!(self, Status::Authorized) } - pub fn is_disabled(&self) -> bool { - matches!(self, Status::Disabled) + pub fn is_configured(&self) -> bool { + matches!( + self, + Status::Starting { .. } + | Status::Error(_) + | Status::SigningIn { .. } + | Status::Authorized + ) } } diff --git a/crates/inline_completion_button/src/inline_completion_button.rs b/crates/inline_completion_button/src/inline_completion_button.rs index 7e6b77b93d..8a8eacdc6a 100644 --- a/crates/inline_completion_button/src/inline_completion_button.rs +++ b/crates/inline_completion_button/src/inline_completion_button.rs @@ -46,6 +46,7 @@ actions!( ); const COPILOT_SETTINGS_URL: &str = "https://github.com/settings/copilot"; +const PRIVACY_DOCS: &str = "https://zed.dev/docs/ai/privacy-and-security"; struct CopilotErrorToast; @@ -193,13 +194,13 @@ impl Render for InlineCompletionButton { cx.open_url(activate_url.as_str()) }) .entry( - "Use Copilot", + "Use Zed AI", None, move |_, cx| { set_completion_provider( fs.clone(), cx, - EditPredictionProvider::Copilot, + EditPredictionProvider::Zed, ) }, ) @@ -239,22 +240,13 @@ impl Render for InlineCompletionButton { IconName::ZedPredictDisabled }; - let current_user_terms_accepted = - self.user_store.read(cx).current_user_has_accepted_terms(); - let has_subscription = self.user_store.read(cx).current_plan().is_some() - && self.user_store.read(cx).subscription_period().is_some(); - - if !has_subscription || !current_user_terms_accepted.unwrap_or(false) { - let signed_in = current_user_terms_accepted.is_some(); - let tooltip_meta = if signed_in { - if has_subscription { - "Read Terms of Service" - } else { - "Choose a Plan" - } - } else { - "Sign in to use" - }; + if zeta::should_show_upsell_modal(&self.user_store, cx) { + let tooltip_meta = + match self.user_store.read(cx).current_user_has_accepted_terms() { + Some(true) => "Choose a Plan", + Some(false) => "Accept the Terms of Service", + None => "Sign In", + }; return div().child( IconButton::new("zed-predict-pending-button", zeta_icon) @@ -403,15 +395,16 @@ impl InlineCompletionButton { ) -> Entity { let fs = self.fs.clone(); ContextMenu::build(window, cx, |menu, _, _| { - menu.entry("Sign In", None, copilot::initiate_sign_in) + menu.entry("Sign In to Copilot", None, copilot::initiate_sign_in) .entry("Disable Copilot", None, { let fs = fs.clone(); move |_window, cx| hide_copilot(fs.clone(), cx) }) - .entry("Use Supermaven", None, { + .separator() + .entry("Use Zed AI", None, { let fs = fs.clone(); move |_window, cx| { - set_completion_provider(fs.clone(), cx, EditPredictionProvider::Supermaven) + set_completion_provider(fs.clone(), cx, EditPredictionProvider::Zed) } }) }) @@ -518,7 +511,7 @@ impl InlineCompletionButton { ); } - menu = menu.separator().header("Privacy Settings"); + menu = menu.separator().header("Privacy"); if let Some(provider) = &self.edit_prediction_provider { let data_collection = provider.data_collection_state(cx); if data_collection.is_supported() { @@ -569,13 +562,15 @@ impl InlineCompletionButton { .child( Label::new(indoc!{ "Help us improve our open dataset model by sharing data from open source repositories. \ - Zed must detect a license file in your repo for this setting to take effect." + Zed must detect a license file in your repo for this setting to take effect. \ + Files with sensitive data and secrets are excluded by default." }) ) .child( h_flex() .items_start() .pt_2() + .pr_1() .flex_1() .gap_1p5() .border_t_1() @@ -635,6 +630,13 @@ impl InlineCompletionButton { .detach_and_log_err(cx); } }), + ).item( + ContextMenuEntry::new("View Documentation") + .icon(IconName::FileGeneric) + .icon_color(Color::Muted) + .handler(move |_, cx| { + cx.open_url(PRIVACY_DOCS); + }) ); if !self.editor_enabled.unwrap_or(true) { @@ -672,6 +674,13 @@ impl InlineCompletionButton { ) -> Entity { ContextMenu::build(window, cx, |menu, window, cx| { self.build_language_settings_menu(menu, window, cx) + .separator() + .entry("Use Zed AI instead", None, { + let fs = self.fs.clone(); + move |_window, cx| { + set_completion_provider(fs.clone(), cx, EditPredictionProvider::Zed) + } + }) .separator() .link( "Go to Copilot Settings", @@ -750,44 +759,24 @@ impl InlineCompletionButton { menu = menu .custom_entry( |_window, _cx| { - h_flex() - .gap_1() - .child( - Icon::new(IconName::Warning) - .size(IconSize::Small) - .color(Color::Warning), - ) - .child( - Label::new("Your GitHub account is less than 30 days old") - .size(LabelSize::Small) - .color(Color::Warning), - ) + Label::new("Your GitHub account is less than 30 days old.") + .size(LabelSize::Small) + .color(Color::Warning) .into_any_element() }, |_window, cx| cx.open_url(&zed_urls::account_url(cx)), ) - .entry( - "You need to upgrade to Zed Pro or contact us.", - None, - |_window, cx| cx.open_url(&zed_urls::account_url(cx)), - ) + .entry("Upgrade to Zed Pro or contact us.", None, |_window, cx| { + cx.open_url(&zed_urls::account_url(cx)) + }) .separator(); } else if self.user_store.read(cx).has_overdue_invoices() { menu = menu .custom_entry( |_window, _cx| { - h_flex() - .gap_1() - .child( - Icon::new(IconName::Warning) - .size(IconSize::Small) - .color(Color::Warning), - ) - .child( - Label::new("You have an outstanding invoice") - .size(LabelSize::Small) - .color(Color::Warning), - ) + Label::new("You have an outstanding invoice") + .size(LabelSize::Small) + .color(Color::Warning) .into_any_element() }, |_window, cx| { diff --git a/crates/language_model/src/language_model.rs b/crates/language_model/src/language_model.rs index 6bd33fcdf5..72455b3821 100644 --- a/crates/language_model/src/language_model.rs +++ b/crates/language_model/src/language_model.rs @@ -654,7 +654,7 @@ pub enum LanguageModelProviderTosView { ThreadEmptyState, /// When there are no past interactions in the Agent Panel. ThreadFreshStart, - PromptEditorPopup, + TextThreadPopup, Configuration, } diff --git a/crates/language_models/Cargo.toml b/crates/language_models/Cargo.toml index 5d158e84f4..ed38ac7660 100644 --- a/crates/language_models/Cargo.toml +++ b/crates/language_models/Cargo.toml @@ -12,6 +12,7 @@ workspace = true path = "src/language_models.rs" [dependencies] +ai_onboarding.workspace = true anthropic = { workspace = true, features = ["schemars"] } anyhow.workspace = true aws-config = { workspace = true, features = ["behavior-version-latest"] } diff --git a/crates/language_models/src/provider/cloud.rs b/crates/language_models/src/provider/cloud.rs index 6aea576258..736107570b 100644 --- a/crates/language_models/src/provider/cloud.rs +++ b/crates/language_models/src/provider/cloud.rs @@ -1,3 +1,4 @@ +use ai_onboarding::YoungAccountBanner; use anthropic::AnthropicModelMode; use anyhow::{Context as _, Result, anyhow}; use chrono::{DateTime, Utc}; @@ -500,7 +501,7 @@ fn render_accept_terms( ) .child({ match view_kind { - LanguageModelProviderTosView::PromptEditorPopup => { + LanguageModelProviderTosView::TextThreadPopup => { button_container.w_full().justify_end() } LanguageModelProviderTosView::Configuration => { @@ -1126,6 +1127,7 @@ struct ZedAiConfiguration { subscription_period: Option<(DateTime, DateTime)>, eligible_for_trial: bool, has_accepted_terms_of_service: bool, + account_too_young: bool, accept_terms_of_service_in_progress: bool, accept_terms_of_service_callback: Arc, sign_in_callback: Arc, @@ -1133,18 +1135,18 @@ struct ZedAiConfiguration { impl RenderOnce for ZedAiConfiguration { fn render(self, _window: &mut Window, _cx: &mut App) -> impl IntoElement { - const ZED_PRICING_URL: &str = "https://zed.dev/pricing"; + let young_account_banner = YoungAccountBanner; let is_pro = self.plan == Some(proto::Plan::ZedPro); let subscription_text = match (self.plan, self.subscription_period) { (Some(proto::Plan::ZedPro), Some(_)) => { - "You have access to Zed's hosted LLMs through your Zed Pro subscription." + "You have access to Zed's hosted LLMs through your Pro subscription." } (Some(proto::Plan::ZedProTrial), Some(_)) => { - "You have access to Zed's hosted LLMs through your Zed Pro trial." + "You have access to Zed's hosted LLMs through your Pro trial." } (Some(proto::Plan::Free), Some(_)) => { - "You have basic access to Zed's hosted LLMs through your Zed Free subscription." + "You have basic access to Zed's hosted LLMs through the Free plan." } _ => { if self.eligible_for_trial { @@ -1154,68 +1156,76 @@ impl RenderOnce for ZedAiConfiguration { } } }; + let manage_subscription_buttons = if is_pro { - h_flex().child( - Button::new("manage_settings", "Manage Subscription") - .style(ButtonStyle::Tinted(TintColor::Accent)) - .on_click(|_, _, cx| cx.open_url(&zed_urls::account_url(cx))), - ) + Button::new("manage_settings", "Manage Subscription") + .style(ButtonStyle::Tinted(TintColor::Accent)) + .on_click(|_, _, cx| cx.open_url(&zed_urls::account_url(cx))) + .into_any_element() + } else if self.plan.is_none() || self.eligible_for_trial { + Button::new("start_trial", "Start 14-day Free Pro Trial") + .style(ui::ButtonStyle::Tinted(ui::TintColor::Accent)) + .full_width() + .on_click(|_, _, cx| cx.open_url(&zed_urls::account_url(cx))) + .into_any_element() } else { - h_flex() - .gap_2() - .child( - Button::new("learn_more", "Learn more") - .style(ButtonStyle::Subtle) - .on_click(|_, _, cx| cx.open_url(ZED_PRICING_URL)), - ) - .child( - Button::new( - "upgrade", - if self.plan.is_none() && self.eligible_for_trial { - "Start Trial" - } else { - "Upgrade" - }, - ) - .style(ButtonStyle::Subtle) - .color(Color::Accent) - .on_click(|_, _, cx| cx.open_url(&zed_urls::account_url(cx))), - ) + Button::new("upgrade", "Upgrade to Pro") + .style(ui::ButtonStyle::Tinted(ui::TintColor::Accent)) + .full_width() + .on_click(|_, _, cx| cx.open_url(&zed_urls::upgrade_to_zed_pro_url(cx))) + .into_any_element() }; - if self.is_connected { - v_flex() - .gap_3() - .w_full() - .when(!self.has_accepted_terms_of_service, |this| { - this.child(render_accept_terms( - LanguageModelProviderTosView::Configuration, - self.accept_terms_of_service_in_progress, - { - let callback = self.accept_terms_of_service_callback.clone(); - move |window, cx| (callback)(window, cx) - }, - )) - }) - .when(self.has_accepted_terms_of_service, |this| { - this.child(subscription_text) - .child(manage_subscription_buttons) - }) - } else { - v_flex() + if !self.is_connected { + return v_flex() .gap_2() - .child(Label::new("Use Zed AI to access hosted language models.")) + .child(Label::new("Sign in to have access to Zed's complete agentic experience with hosted models.")) .child( - Button::new("sign_in", "Sign In") + Button::new("sign_in", "Sign In to use Zed AI") .icon_color(Color::Muted) .icon(IconName::Github) + .icon_size(IconSize::Small) .icon_position(IconPosition::Start) + .full_width() .on_click({ let callback = self.sign_in_callback.clone(); move |_, window, cx| (callback)(window, cx) }), - ) + ); } + + v_flex() + .gap_2() + .w_full() + .when(!self.has_accepted_terms_of_service, |this| { + this.child(render_accept_terms( + LanguageModelProviderTosView::Configuration, + self.accept_terms_of_service_in_progress, + { + let callback = self.accept_terms_of_service_callback.clone(); + move |window, cx| (callback)(window, cx) + }, + )) + }) + .map(|this| { + if self.has_accepted_terms_of_service && self.account_too_young { + this.child(young_account_banner).child( + Button::new("upgrade", "Upgrade to Pro") + .style(ui::ButtonStyle::Tinted(ui::TintColor::Accent)) + .full_width() + .on_click(|_, _, cx| { + cx.open_url(&zed_urls::upgrade_to_zed_pro_url(cx)) + }), + ) + } else if self.has_accepted_terms_of_service { + this.text_sm() + .child(subscription_text) + .child(manage_subscription_buttons) + } else { + this + } + }) + .when(self.has_accepted_terms_of_service, |this| this) } } @@ -1264,6 +1274,7 @@ impl Render for ConfigurationView { subscription_period: user_store.subscription_period(), eligible_for_trial: user_store.trial_started_at().is_none(), has_accepted_terms_of_service: state.has_accepted_terms_of_service(cx), + account_too_young: user_store.account_too_young(), accept_terms_of_service_in_progress: state.accept_terms_of_service_task.is_some(), accept_terms_of_service_callback: self.accept_terms_of_service_callback.clone(), sign_in_callback: self.sign_in_callback.clone(), @@ -1281,6 +1292,7 @@ impl Component for ZedAiConfiguration { is_connected: bool, plan: Option, eligible_for_trial: bool, + account_too_young: bool, has_accepted_terms_of_service: bool, ) -> AnyElement { ZedAiConfiguration { @@ -1291,6 +1303,7 @@ impl Component for ZedAiConfiguration { .then(|| (Utc::now(), Utc::now() + chrono::Duration::days(7))), eligible_for_trial, has_accepted_terms_of_service, + account_too_young, accept_terms_of_service_in_progress: false, accept_terms_of_service_callback: Arc::new(|_, _| {}), sign_in_callback: Arc::new(|_, _| {}), @@ -1303,30 +1316,33 @@ impl Component for ZedAiConfiguration { .p_4() .gap_4() .children(vec![ - single_example("Not connected", configuration(false, None, false, true)), + single_example( + "Not connected", + configuration(false, None, false, false, true), + ), single_example( "Accept Terms of Service", - configuration(true, None, true, false), + configuration(true, None, true, false, false), ), single_example( "No Plan - Not eligible for trial", - configuration(true, None, false, true), + configuration(true, None, false, false, true), ), single_example( "No Plan - Eligible for trial", - configuration(true, None, true, true), + configuration(true, None, true, false, true), ), single_example( "Free Plan", - configuration(true, Some(proto::Plan::Free), true, true), + configuration(true, Some(proto::Plan::Free), true, false, true), ), single_example( "Zed Pro Trial Plan", - configuration(true, Some(proto::Plan::ZedProTrial), true, true), + configuration(true, Some(proto::Plan::ZedProTrial), true, false, true), ), single_example( "Zed Pro Plan", - configuration(true, Some(proto::Plan::ZedPro), true, true), + configuration(true, Some(proto::Plan::ZedPro), true, false, true), ), ]) .into_any_element(), diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs index 977b5c3ecd..c4fdb16f4f 100644 --- a/crates/title_bar/src/title_bar.rs +++ b/crates/title_bar/src/title_bar.rs @@ -20,7 +20,7 @@ use crate::application_menu::{ use auto_update::AutoUpdateStatus; use call::ActiveCall; -use client::{Client, UserStore}; +use client::{Client, UserStore, zed_urls}; use gpui::{ Action, AnyElement, App, Context, Corner, Element, Entity, Focusable, InteractiveElement, IntoElement, MouseButton, ParentElement, Render, StatefulInteractiveElement, Styled, @@ -656,8 +656,9 @@ impl TitleBar { let user_login = user.github_login.clone(); let (plan_name, label_color, bg_color) = match plan { - None => ("None", Color::Default, free_chip_bg), - Some(proto::Plan::Free) => ("Free", Color::Default, free_chip_bg), + None | Some(proto::Plan::Free) => { + ("Free", Color::Default, free_chip_bg) + } Some(proto::Plan::ZedProTrial) => { ("Pro Trial", Color::Accent, pro_chip_bg) } @@ -680,7 +681,7 @@ impl TitleBar { .into_any_element() }, move |_, cx| { - cx.open_url("https://zed.dev/account"); + cx.open_url(&zed_urls::account_url(cx)); }, ) .separator() diff --git a/crates/ui/src/components/button/button_like.rs b/crates/ui/src/components/button/button_like.rs index a0158b2fe7..135ecdfe62 100644 --- a/crates/ui/src/components/button/button_like.rs +++ b/crates/ui/src/components/button/button_like.rs @@ -126,6 +126,10 @@ pub enum ButtonStyle { /// coloring like an error or success button. Tinted(TintColor), + /// Usually used as a secondary action that should have more emphasis than + /// a fully transparent button. + Outlined, + /// The default button style, used for most buttons. Has a transparent background, /// but has a background color to indicate states like hover and active. #[default] @@ -180,6 +184,12 @@ impl ButtonStyle { icon_color: Color::Default.color(cx), }, ButtonStyle::Tinted(tint) => tint.button_like_style(cx), + ButtonStyle::Outlined => ButtonLikeStyles { + background: element_bg_from_elevation(elevation, cx), + border_color: cx.theme().colors().border_variant, + label_color: Color::Default.color(cx), + icon_color: Color::Default.color(cx), + }, ButtonStyle::Subtle => ButtonLikeStyles { background: cx.theme().colors().ghost_element_background, border_color: transparent_black(), @@ -219,6 +229,12 @@ impl ButtonStyle { styles.background = theme.darken(styles.background, 0.05, 0.2); styles } + ButtonStyle::Outlined => ButtonLikeStyles { + background: cx.theme().colors().ghost_element_hover, + border_color: cx.theme().colors().border, + label_color: Color::Default.color(cx), + icon_color: Color::Default.color(cx), + }, ButtonStyle::Subtle => ButtonLikeStyles { background: cx.theme().colors().ghost_element_hover, border_color: transparent_black(), @@ -251,6 +267,12 @@ impl ButtonStyle { label_color: Color::Default.color(cx), icon_color: Color::Default.color(cx), }, + ButtonStyle::Outlined => ButtonLikeStyles { + background: cx.theme().colors().element_active, + border_color: cx.theme().colors().border_variant, + label_color: Color::Default.color(cx), + icon_color: Color::Default.color(cx), + }, ButtonStyle::Transparent => ButtonLikeStyles { background: transparent_black(), border_color: transparent_black(), @@ -278,6 +300,12 @@ impl ButtonStyle { label_color: Color::Default.color(cx), icon_color: Color::Default.color(cx), }, + ButtonStyle::Outlined => ButtonLikeStyles { + background: cx.theme().colors().ghost_element_background, + border_color: cx.theme().colors().border, + label_color: Color::Default.color(cx), + icon_color: Color::Default.color(cx), + }, ButtonStyle::Transparent => ButtonLikeStyles { background: transparent_black(), border_color: cx.theme().colors().border_focused, @@ -308,6 +336,12 @@ impl ButtonStyle { label_color: Color::Disabled.color(cx), icon_color: Color::Disabled.color(cx), }, + ButtonStyle::Outlined => ButtonLikeStyles { + background: cx.theme().colors().element_disabled, + border_color: cx.theme().colors().border_disabled, + label_color: Color::Default.color(cx), + icon_color: Color::Default.color(cx), + }, ButtonStyle::Transparent => ButtonLikeStyles { background: transparent_black(), border_color: transparent_black(), @@ -525,6 +559,13 @@ impl RenderOnce for ButtonLike { .when_some(self.width, |this, width| { this.w(width).justify_center().text_center() }) + .when( + match self.style { + ButtonStyle::Outlined => true, + _ => false, + }, + |this| this.border_1(), + ) .when_some(self.rounding, |this, rounding| match rounding { ButtonLikeRounding::All => this.rounded_sm(), ButtonLikeRounding::Left => this.rounded_l_sm(), @@ -538,6 +579,7 @@ impl RenderOnce for ButtonLike { } ButtonSize::None => this, }) + .border_color(style.enabled(self.layer, cx).border_color) .bg(style.enabled(self.layer, cx).background) .when(self.disabled, |this| { if self.cursor_style == CursorStyle::PointingHand { diff --git a/crates/zed_actions/src/lib.rs b/crates/zed_actions/src/lib.rs index fc7d98178e..4b4bf016c4 100644 --- a/crates/zed_actions/src/lib.rs +++ b/crates/zed_actions/src/lib.rs @@ -277,7 +277,10 @@ pub mod agent { /// Displays the previous message in the history. PreviousHistoryMessage, /// Displays the next message in the history. - NextHistoryMessage + NextHistoryMessage, + /// Toggles the language model selector dropdown. + #[action(deprecated_aliases = ["assistant::ToggleModelSelector", "assistant2::ToggleModelSelector"])] + ToggleModelSelector ] ); } diff --git a/crates/zeta/Cargo.toml b/crates/zeta/Cargo.toml index 1609773339..c2b1de08ae 100644 --- a/crates/zeta/Cargo.toml +++ b/crates/zeta/Cargo.toml @@ -17,11 +17,13 @@ doctest = false test-support = [] [dependencies] +ai_onboarding.workspace = true anyhow.workspace = true arrayvec.workspace = true client.workspace = true collections.workspace = true command_palette_hooks.workspace = true +copilot.workspace = true db.workspace = true editor.workspace = true feature_flags.workspace = true @@ -35,8 +37,6 @@ language.workspace = true language_model.workspace = true log.workspace = true menu.workspace = true -migrator.workspace = true -paths.workspace = true postage.workspace = true project.workspace = true proto.workspace = true diff --git a/crates/zeta/src/init.rs b/crates/zeta/src/init.rs index 6411e423a4..4bcd50df88 100644 --- a/crates/zeta/src/init.rs +++ b/crates/zeta/src/init.rs @@ -34,7 +34,6 @@ pub fn init(cx: &mut App) { workspace, workspace.user_store().clone(), workspace.client().clone(), - workspace.app_state().fs.clone(), window, cx, ) diff --git a/crates/zeta/src/onboarding_modal.rs b/crates/zeta/src/onboarding_modal.rs index c123d76c53..1d59f36b05 100644 --- a/crates/zeta/src/onboarding_modal.rs +++ b/crates/zeta/src/onboarding_modal.rs @@ -1,40 +1,33 @@ -use std::{sync::Arc, time::Duration}; +use std::sync::Arc; -use crate::{ZED_PREDICT_DATA_COLLECTION_CHOICE, onboarding_event}; -use anyhow::Context as _; +use crate::{ZedPredictUpsell, onboarding_event}; +use ai_onboarding::EditPredictionOnboarding; use client::{Client, UserStore}; -use db::kvp::KEY_VALUE_STORE; +use db::kvp::Dismissable; use fs::Fs; use gpui::{ - Animation, AnimationExt as _, ClickEvent, DismissEvent, Entity, EventEmitter, FocusHandle, - Focusable, MouseDownEvent, Render, ease_in_out, svg, + ClickEvent, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, MouseDownEvent, Render, + linear_color_stop, linear_gradient, }; use language::language_settings::{AllLanguageSettings, EditPredictionProvider}; -use settings::{Settings, update_settings_file}; -use ui::{Checkbox, TintColor, prelude::*}; -use util::ResultExt; -use workspace::{ModalView, Workspace, notifications::NotifyTaskExt}; +use settings::update_settings_file; +use ui::{Vector, VectorName, prelude::*}; +use workspace::{ModalView, Workspace}; /// Introduces user to Zed's Edit Prediction feature and terms of service pub struct ZedPredictModal { - user_store: Entity, - client: Arc, - fs: Arc, + onboarding: Entity, focus_handle: FocusHandle, - sign_in_status: SignInStatus, - terms_of_service: bool, - data_collection_expanded: bool, - data_collection_opted_in: bool, } -#[derive(PartialEq, Eq)] -enum SignInStatus { - /// Signed out or signed in but not from this modal - Idle, - /// Authentication triggered from this modal - Waiting, - /// Signed in after authentication from this modal - SignedIn, +pub(crate) fn set_edit_prediction_provider(provider: EditPredictionProvider, cx: &mut App) { + let fs = ::global(cx); + update_settings_file::(fs, cx, move |settings, _| { + settings + .features + .get_or_insert(Default::default()) + .edit_prediction_provider = Some(provider); + }); } impl ZedPredictModal { @@ -42,127 +35,45 @@ impl ZedPredictModal { workspace: &mut Workspace, user_store: Entity, client: Arc, - fs: Arc, window: &mut Window, cx: &mut Context, ) { - workspace.toggle_modal(window, cx, |_window, cx| Self { - user_store, - client, - fs, - focus_handle: cx.focus_handle(), - sign_in_status: SignInStatus::Idle, - terms_of_service: false, - data_collection_expanded: false, - data_collection_opted_in: false, + workspace.toggle_modal(window, cx, |_window, cx| { + let weak_entity = cx.weak_entity(); + Self { + onboarding: cx.new(|cx| { + EditPredictionOnboarding::new( + user_store.clone(), + client.clone(), + copilot::Copilot::global(cx) + .map_or(false, |copilot| copilot.read(cx).status().is_configured()), + Arc::new({ + let this = weak_entity.clone(); + move |_window, cx| { + ZedPredictUpsell::set_dismissed(true, cx); + set_edit_prediction_provider(EditPredictionProvider::Zed, cx); + this.update(cx, |_, cx| cx.emit(DismissEvent)).ok(); + } + }), + Arc::new({ + let this = weak_entity.clone(); + move |window, cx| { + ZedPredictUpsell::set_dismissed(true, cx); + set_edit_prediction_provider(EditPredictionProvider::Copilot, cx); + this.update(cx, |_, cx| cx.emit(DismissEvent)).ok(); + copilot::initiate_sign_in(window, cx); + } + }), + cx, + ) + }), + focus_handle: cx.focus_handle(), + } }); } - fn view_terms(&mut self, _: &ClickEvent, _: &mut Window, cx: &mut Context) { - cx.open_url("https://zed.dev/terms-of-service"); - cx.notify(); - - onboarding_event!("ToS Link Clicked"); - } - - fn view_blog(&mut self, _: &ClickEvent, _: &mut Window, cx: &mut Context) { - cx.open_url("https://zed.dev/blog/edit-prediction"); - cx.notify(); - - onboarding_event!("Blog Link clicked"); - } - - fn inline_completions_doc(&mut self, _: &ClickEvent, _: &mut Window, cx: &mut Context) { - cx.open_url("https://zed.dev/docs/configuring-zed#disabled-globs"); - cx.notify(); - - onboarding_event!("Docs Link Clicked"); - } - - fn accept_and_enable(&mut self, _: &ClickEvent, window: &mut Window, cx: &mut Context) { - let task = self - .user_store - .update(cx, |this, cx| this.accept_terms_of_service(cx)); - let fs = self.fs.clone(); - - cx.spawn(async move |this, cx| { - task.await?; - - let mut data_collection_opted_in = false; - this.update(cx, |this, _cx| { - data_collection_opted_in = this.data_collection_opted_in; - }) - .ok(); - - KEY_VALUE_STORE - .write_kvp( - ZED_PREDICT_DATA_COLLECTION_CHOICE.into(), - data_collection_opted_in.to_string(), - ) - .await - .log_err(); - - // Make sure edit prediction provider setting is using the new key - let settings_path = paths::settings_file().as_path(); - let settings_path = fs.canonicalize(settings_path).await.with_context(|| { - format!("Failed to canonicalize settings path {:?}", settings_path) - })?; - - if let Some(settings) = fs.load(&settings_path).await.log_err() { - if let Some(new_settings) = - migrator::migrate_edit_prediction_provider_settings(&settings)? - { - fs.atomic_write(settings_path, new_settings).await?; - } - } - - this.update(cx, |this, cx| { - update_settings_file::(this.fs.clone(), cx, move |file, _| { - file.features - .get_or_insert(Default::default()) - .edit_prediction_provider = Some(EditPredictionProvider::Zed); - }); - - cx.emit(DismissEvent); - }) - }) - .detach_and_notify_err(window, cx); - - onboarding_event!( - "Enable Clicked", - data_collection_opted_in = self.data_collection_opted_in, - ); - } - - fn sign_in(&mut self, _: &ClickEvent, window: &mut Window, cx: &mut Context) { - let client = self.client.clone(); - self.sign_in_status = SignInStatus::Waiting; - - cx.spawn(async move |this, cx| { - let result = client - .authenticate_and_connect(true, &cx) - .await - .into_response(); - - let status = match result { - Ok(_) => SignInStatus::SignedIn, - Err(_) => SignInStatus::Idle, - }; - - this.update(cx, |this, cx| { - this.sign_in_status = status; - onboarding_event!("Signed In"); - cx.notify() - })?; - - result - }) - .detach_and_notify_err(window, cx); - - onboarding_event!("Sign In Clicked"); - } - fn cancel(&mut self, _: &menu::Cancel, _: &mut Window, cx: &mut Context) { + ZedPredictUpsell::set_dismissed(true, cx); cx.emit(DismissEvent); } } @@ -177,85 +88,12 @@ impl Focusable for ZedPredictModal { impl ModalView for ZedPredictModal {} -impl ZedPredictModal { - fn render_data_collection_explanation(&self, cx: &Context) -> impl IntoElement { - fn label_item(label_text: impl Into) -> impl Element { - Label::new(label_text).color(Color::Muted).into_element() - } - - fn info_item(label_text: impl Into) -> impl Element { - h_flex() - .items_start() - .gap_2() - .child( - div() - .mt_1p5() - .child(Icon::new(IconName::Check).size(IconSize::XSmall)), - ) - .child(div().w_full().child(label_item(label_text))) - } - - fn multiline_info_item, E2: IntoElement>( - first_line: E1, - second_line: E2, - ) -> impl Element { - v_flex() - .child(info_item(first_line)) - .child(div().pl_5().child(second_line)) - } - - v_flex() - .mt_2() - .p_2() - .rounded_sm() - .bg(cx.theme().colors().editor_background.opacity(0.5)) - .border_1() - .border_color(cx.theme().colors().border_variant) - .child( - div().child( - Label::new("To improve edit predictions, please consider contributing to our open dataset based on your interactions within open source repositories.") - .mb_1() - ) - ) - .child(info_item( - "We collect data exclusively from open source projects.", - )) - .child(info_item( - "Zed automatically detects if your project is open source.", - )) - .child(info_item("Toggle participation at any time via the status bar menu.")) - .child(multiline_info_item( - "If turned on, this setting applies for all open source repositories", - label_item("you open in Zed.") - )) - .child(multiline_info_item( - "Files with sensitive data, like `.env`, are excluded by default", - h_flex() - .w_full() - .flex_wrap() - .child(label_item("via the")) - .child( - Button::new("doc-link", "disabled_globs").on_click( - cx.listener(Self::inline_completions_doc), - ), - ) - .child(label_item("setting.")), - )) - } -} - impl Render for ZedPredictModal { fn render(&mut self, window: &mut Window, cx: &mut Context) -> impl IntoElement { let window_height = window.viewport_size().height; let max_height = window_height - px(200.); - let has_subscription_period = self.user_store.read(cx).subscription_period().is_some(); - let plan = self.user_store.read(cx).current_plan().filter(|_| { - // Since the user might be on the legacy free plan we filter based on whether we have a subscription period. - has_subscription_period - }); - - let base = v_flex() + v_flex() .id("edit-prediction-onboarding") .key_context("ZedPredictModal") .relative() @@ -264,14 +102,9 @@ impl Render for ZedPredictModal { .max_h(max_height) .p_4() .gap_2() - .when(self.data_collection_expanded, |element| { - element.overflow_y_scroll() - }) - .when(!self.data_collection_expanded, |element| { - element.overflow_hidden() - }) .elevation_3(cx) .track_focus(&self.focus_handle(cx)) + .overflow_hidden() .on_action(cx.listener(Self::cancel)) .on_action(cx.listener(|_, _: &menu::Cancel, _window, cx| { onboarding_event!("Cancelled", trigger = "Action"); @@ -282,77 +115,30 @@ impl Render for ZedPredictModal { })) .child( div() - .p_1p5() + .opacity(0.5) .absolute() - .top_1() - .left_1() + .top(px(-8.0)) .right_0() - .h(px(200.)) + .w(px(400.)) + .h(px(92.)) .child( - svg() - .path("icons/zed_predict_bg.svg") - .text_color(cx.theme().colors().icon_disabled) - .w(px(530.)) - .h(px(128.)) - .overflow_hidden(), + Vector::new(VectorName::AiGrid, rems_from_px(400.), rems_from_px(92.)) + .color(Color::Custom(cx.theme().colors().text.alpha(0.32))), ), ) .child( - h_flex() - .w_full() - .mb_2() - .justify_between() - .child( - v_flex() - .gap_1() - .child( - Label::new("Introducing Zed AI's") - .size(LabelSize::Small) - .color(Color::Muted), - ) - .child(Headline::new("Edit Prediction").size(HeadlineSize::Large)), - ) - .child({ - let tab = |n: usize| { - let text_color = cx.theme().colors().text; - let border_color = cx.theme().colors().text_accent.opacity(0.4); - - h_flex().child( - h_flex() - .px_4() - .py_0p5() - .bg(cx.theme().colors().editor_background) - .border_1() - .border_color(border_color) - .rounded_sm() - .font(theme::ThemeSettings::get_global(cx).buffer_font.clone()) - .text_size(TextSize::XSmall.rems(cx)) - .text_color(text_color) - .child("tab") - .with_animation( - n, - Animation::new(Duration::from_secs(2)).repeat(), - move |tab, delta| { - let delta = (delta - 0.15 * n as f32) / 0.7; - let delta = 1.0 - (0.5 - delta).abs() * 2.; - let delta = ease_in_out(delta.clamp(0., 1.)); - let delta = 0.1 + 0.9 * delta; - - tab.border_color(border_color.opacity(delta)) - .text_color(text_color.opacity(delta)) - }, - ), - ) - }; - - v_flex() - .gap_2() - .items_center() - .pr_2p5() - .child(tab(0).ml_neg_20()) - .child(tab(1)) - .child(tab(2).ml_20()) - }), + div() + .absolute() + .top_0() + .right_0() + .w(px(660.)) + .h(px(401.)) + .overflow_hidden() + .bg(linear_gradient( + 75., + linear_color_stop(cx.theme().colors().panel_background.alpha(0.01), 1.0), + linear_color_stop(cx.theme().colors().panel_background, 0.45), + )), ) .child(h_flex().absolute().top_2().right_2().child( IconButton::new("cancel", IconName::X).on_click(cx.listener( @@ -361,148 +147,7 @@ impl Render for ZedPredictModal { cx.emit(DismissEvent); }, )), - )); - - let blog_post_button = Button::new("view-blog", "Read the Blog Post") - .full_width() - .icon(IconName::ArrowUpRight) - .icon_size(IconSize::Indicator) - .icon_color(Color::Muted) - .on_click(cx.listener(Self::view_blog)); - - if self.user_store.read(cx).current_user().is_some() { - let copy = match self.sign_in_status { - SignInStatus::Idle => { - "Zed can now predict your next edit on every keystroke. Powered by Zeta, our open-source, open-dataset language model." - } - SignInStatus::SignedIn => "Almost there! Ensure you:", - SignInStatus::Waiting => unreachable!(), - }; - - let accordion_icons = if self.data_collection_expanded { - (IconName::ChevronUp, IconName::ChevronDown) - } else { - (IconName::ChevronDown, IconName::ChevronUp) - }; - let plan = plan.unwrap_or(proto::Plan::Free); - - base.child(Label::new(copy).color(Color::Muted)) - .child( - h_flex().child( - Checkbox::new("plan", ToggleState::Selected) - .fill() - .disabled(true) - .label(format!( - "You get {} edit predictions through your {}.", - if plan == proto::Plan::Free { - "2,000" - } else { - "unlimited" - }, - match plan { - proto::Plan::Free => "Zed Free plan", - proto::Plan::ZedPro => "Zed Pro plan", - proto::Plan::ZedProTrial => "Zed Pro trial", - } - )), - ), - ) - .child( - h_flex() - .child( - Checkbox::new("tos-checkbox", self.terms_of_service.into()) - .fill() - .label("I have read and accept the") - .on_click(cx.listener(move |this, state, _window, cx| { - this.terms_of_service = *state == ToggleState::Selected; - cx.notify(); - })), - ) - .child( - Button::new("view-tos", "Terms of Service") - .icon(IconName::ArrowUpRight) - .icon_size(IconSize::Indicator) - .icon_color(Color::Muted) - .on_click(cx.listener(Self::view_terms)), - ), - ) - .child( - v_flex() - .child( - h_flex() - .flex_wrap() - .child( - Checkbox::new( - "training-data-checkbox", - self.data_collection_opted_in.into(), - ) - .label( - "Contribute to the open dataset when editing open source.", - ) - .fill() - .on_click(cx.listener( - move |this, state, _window, cx| { - this.data_collection_opted_in = - *state == ToggleState::Selected; - cx.notify() - }, - )), - ) - .child( - Button::new("learn-more", "Learn More") - .icon(accordion_icons.0) - .icon_size(IconSize::Indicator) - .icon_color(Color::Muted) - .on_click(cx.listener(|this, _, _, cx| { - this.data_collection_expanded = - !this.data_collection_expanded; - cx.notify(); - - if this.data_collection_expanded { - onboarding_event!( - "Data Collection Learn More Clicked" - ); - } - })), - ), - ) - .when(self.data_collection_expanded, |element| { - element.child(self.render_data_collection_explanation(cx)) - }), - ) - .child( - v_flex() - .mt_2() - .gap_2() - .w_full() - .child( - Button::new("accept-tos", "Enable Edit Prediction") - .disabled(!self.terms_of_service) - .style(ButtonStyle::Tinted(TintColor::Accent)) - .full_width() - .on_click(cx.listener(Self::accept_and_enable)), - ) - .child(blog_post_button), - ) - } else { - base.child( - Label::new("To set Zed as your edit prediction provider, please sign in.") - .color(Color::Muted), - ) - .child( - v_flex() - .mt_2() - .gap_2() - .w_full() - .child( - Button::new("accept-tos", "Sign in with GitHub") - .disabled(self.sign_in_status == SignInStatus::Waiting) - .style(ButtonStyle::Tinted(TintColor::Accent)) - .full_width() - .on_click(cx.listener(Self::sign_in)), - ) - .child(blog_post_button), - ) - } + )) + .child(self.onboarding.clone()) } } diff --git a/crates/zeta/src/zeta.rs b/crates/zeta/src/zeta.rs index 87cd1e604c..d6f033899d 100644 --- a/crates/zeta/src/zeta.rs +++ b/crates/zeta/src/zeta.rs @@ -7,7 +7,7 @@ mod onboarding_telemetry; mod rate_completion_modal; pub(crate) use completion_diff_element::*; -use db::kvp::KEY_VALUE_STORE; +use db::kvp::{Dismissable, KEY_VALUE_STORE}; pub use init::*; use inline_completion::DataCollectionState; use license_detection::LICENSE_FILES_TO_CHECK; @@ -95,6 +95,38 @@ impl std::fmt::Display for InlineCompletionId { } } +struct ZedPredictUpsell; + +impl Dismissable for ZedPredictUpsell { + const KEY: &'static str = "dismissed-edit-predict-upsell"; + + fn dismissed() -> bool { + // To make this backwards compatible with older versions of Zed, we + // check if the user has seen the previous Edit Prediction Onboarding + // before, by checking the data collection choice which was written to + // the database once the user clicked on "Accept and Enable" + if KEY_VALUE_STORE + .read_kvp(ZED_PREDICT_DATA_COLLECTION_CHOICE) + .log_err() + .map_or(false, |s| s.is_some()) + { + return true; + } + + KEY_VALUE_STORE + .read_kvp(Self::KEY) + .log_err() + .map_or(false, |s| s.is_some()) + } +} + +pub fn should_show_upsell_modal(user_store: &Entity, cx: &App) -> bool { + match user_store.read(cx).current_user_has_accepted_terms() { + Some(true) => !ZedPredictUpsell::dismissed(), + Some(false) | None => true, + } +} + #[derive(Clone)] struct ZetaGlobal(Entity); From 750ceeb760fb6e74d6c5b0503c2b8b34ab911efa Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Fri, 18 Jul 2025 12:28:58 -0400 Subject: [PATCH 0061/1052] collab: Don't use `screen-capture` feature from `gpui` (#34725) This PR removes the `screen-capture` feature from `gpui` when depending on it in `collab`. Release Notes: - N/A --- crates/collab/Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/collab/Cargo.toml b/crates/collab/Cargo.toml index 242694d963..d3b5048283 100644 --- a/crates/collab/Cargo.toml +++ b/crates/collab/Cargo.toml @@ -35,7 +35,7 @@ dashmap.workspace = true derive_more.workspace = true envy = "0.4.2" futures.workspace = true -gpui = { workspace = true, features = ["screen-capture"] } +gpui.workspace = true hex.workspace = true http_client.workspace = true jsonwebtoken.workspace = true From 8bc8d61fa6991cf0f1a675088a2a5e6356d16a6a Mon Sep 17 00:00:00 2001 From: Finn Evers Date: Fri, 18 Jul 2025 18:55:03 +0200 Subject: [PATCH 0062/1052] theme_importer: Add missing color imports for the minimap thumb (#34724) These should have been part of https://github.com/zed-industries/zed/pull/30785 but I forgot to add them there. Release Notes: - N/A --- crates/theme_importer/src/vscode/converter.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/crates/theme_importer/src/vscode/converter.rs b/crates/theme_importer/src/vscode/converter.rs index 9a17a4cdd2..0249bdc7c9 100644 --- a/crates/theme_importer/src/vscode/converter.rs +++ b/crates/theme_importer/src/vscode/converter.rs @@ -175,6 +175,8 @@ impl VsCodeThemeConverter { scrollbar_track_background: vscode_editor_background.clone(), scrollbar_track_border: vscode_colors.editor_overview_ruler.border.clone(), minimap_thumb_background: vscode_colors.minimap_slider.background.clone(), + minimap_thumb_hover_background: vscode_colors.minimap_slider.hover_background.clone(), + minimap_thumb_active_background: vscode_colors.minimap_slider.active_background.clone(), editor_foreground: vscode_editor_foreground .clone() .or(vscode_token_colors_foreground.clone()), From 1dd470ca48fef83e920972f175f232f9ea252b44 Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Fri, 18 Jul 2025 22:39:00 +0530 Subject: [PATCH 0063/1052] editor: Fix double $ sign on completion accept in PHP (#34726) Closes #33510 https://github.com/zed-extensions/php/issues/29 If certain language servers do not provide an insert/replace range, we use `surrounding_word` as a fallback for that range, which internally uses `word_characters`. It makes sense to use `completion_query_characters` instead of `word_characters` to get that range, because we use `completion_query_characters` to query completions in the first place. That means, for some hypothetical reason (e.g., if the Tailwind server stops providing insert/replace ranges), we would correctly fall back to the range "bg-blue-200^" instead of "200^", because `completion_query_characters` includes "-" in this case. For this particular fix, right now the default PHP language server `phpactor` does not provide an insert/replace range, and hence completion query character is used, which is `$` in this case. Note that `$` isn't in word characters for reasons mentioned here: https://github.com/zed-extensions/php/issues/14 Release Notes: - Fixed an issue where accepting variable completion in PHP would result in a double $ sign in the prefix. --- crates/editor/src/editor.rs | 8 ++++---- crates/language/src/buffer.rs | 10 ++++++++-- crates/project/src/lsp_command.rs | 4 ++-- 3 files changed, 14 insertions(+), 8 deletions(-) diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index c3187f6b51..b8dcdd35e0 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -5451,7 +5451,7 @@ impl Editor { }; let (word_replace_range, word_to_exclude) = if let (word_range, Some(CharKind::Word)) = - buffer_snapshot.surrounding_word(buffer_position) + buffer_snapshot.surrounding_word(buffer_position, false) { let word_to_exclude = buffer_snapshot .text_for_range(word_range.clone()) @@ -6605,8 +6605,8 @@ impl Editor { } let snapshot = cursor_buffer.read(cx).snapshot(); - let (start_word_range, _) = snapshot.surrounding_word(cursor_buffer_position); - let (end_word_range, _) = snapshot.surrounding_word(tail_buffer_position); + let (start_word_range, _) = snapshot.surrounding_word(cursor_buffer_position, false); + let (end_word_range, _) = snapshot.surrounding_word(tail_buffer_position, false); if start_word_range != end_word_range { self.document_highlights_task.take(); self.clear_background_highlights::(cx); @@ -22137,7 +22137,7 @@ impl SemanticsProvider for Entity { // Fallback on using TreeSitter info to determine identifier range buffer.read_with(cx, |buffer, _| { let snapshot = buffer.snapshot(); - let (range, kind) = snapshot.surrounding_word(position); + let (range, kind) = snapshot.surrounding_word(position, false); if kind != Some(CharKind::Word) { return None; } diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs index ae0184b22a..59aa63ff38 100644 --- a/crates/language/src/buffer.rs +++ b/crates/language/src/buffer.rs @@ -3364,13 +3364,19 @@ impl BufferSnapshot { /// Returns a tuple of the range and character kind of the word /// surrounding the given position. - pub fn surrounding_word(&self, start: T) -> (Range, Option) { + pub fn surrounding_word( + &self, + start: T, + for_completion: bool, + ) -> (Range, Option) { let mut start = start.to_offset(self); let mut end = start; let mut next_chars = self.chars_at(start).take(128).peekable(); let mut prev_chars = self.reversed_chars_at(start).take(128).peekable(); - let classifier = self.char_classifier_at(start); + let classifier = self + .char_classifier_at(start) + .for_completion(for_completion); let word_kind = cmp::max( prev_chars.peek().copied().map(|c| classifier.kind(c)), next_chars.peek().copied().map(|c| classifier.kind(c)), diff --git a/crates/project/src/lsp_command.rs b/crates/project/src/lsp_command.rs index 4538dc4cda..a2f6de44c9 100644 --- a/crates/project/src/lsp_command.rs +++ b/crates/project/src/lsp_command.rs @@ -350,7 +350,7 @@ impl LspCommand for PrepareRename { } Some(lsp::PrepareRenameResponse::DefaultBehavior { .. }) => { let snapshot = buffer.snapshot(); - let (range, _) = snapshot.surrounding_word(self.position); + let (range, _) = snapshot.surrounding_word(self.position, false); let range = snapshot.anchor_after(range.start)..snapshot.anchor_before(range.end); Ok(PrepareRenameResponse::Success(range)) } @@ -2297,7 +2297,7 @@ impl LspCommand for GetCompletions { range_for_token .get_or_insert_with(|| { let offset = self.position.to_offset(&snapshot); - let (range, kind) = snapshot.surrounding_word(offset); + let (range, kind) = snapshot.surrounding_word(offset, true); let range = if kind == Some(CharKind::Word) { range } else { From 5b18ce79abb0242ed91573994414160c44ed716c Mon Sep 17 00:00:00 2001 From: Finn Evers Date: Fri, 18 Jul 2025 19:16:31 +0200 Subject: [PATCH 0064/1052] editor: Ensure topmost buffer header can be properly folded (#34721) This PR fixes an issue where the topmost header in a multibuffer would jump when the corresponding buffer was folded. The issue arose because for the topmost header, the offset within the scroll anchor is negative, as the corresponding buffer only starts below the header itself and thus the offset for the scroll position has to be negative. However, upon collapsing that buffer, we end up with a negative vertical scroll position, which causes all kinds of different problems. The issue has been present for a long time, but became more visible after https://github.com/zed-industries/zed/pull/34295 landed, as that change removed the case distinction for buffers scrolled all the way to the top. This PR fixes this by clamping just the vertical scroll position upon return, which ensures the negative offset works as expected when the buffer is expanded, but the vertical scroll position does not turn negative once the buffer is folded. Release Notes: - Fixed an issue where folding the topmost buffer in a multibuffer would cause the header to jump slightly. --- crates/editor/src/scroll.rs | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/crates/editor/src/scroll.rs b/crates/editor/src/scroll.rs index 7310d6d3c0..ecaf7c11e4 100644 --- a/crates/editor/src/scroll.rs +++ b/crates/editor/src/scroll.rs @@ -12,7 +12,7 @@ use crate::{ }; pub use autoscroll::{Autoscroll, AutoscrollStrategy}; use core::fmt::Debug; -use gpui::{App, Axis, Context, Global, Pixels, Task, Window, point, px}; +use gpui::{Along, App, Axis, Context, Global, Pixels, Task, Window, point, px}; use language::language_settings::{AllLanguageSettings, SoftWrap}; use language::{Bias, Point}; pub use scroll_amount::ScrollAmount; @@ -49,14 +49,14 @@ impl ScrollAnchor { } pub fn scroll_position(&self, snapshot: &DisplaySnapshot) -> gpui::Point { - let mut scroll_position = self.offset; - if self.anchor == Anchor::min() { - scroll_position.y = 0.; - } else { - let scroll_top = self.anchor.to_display_point(snapshot).row().as_f32(); - scroll_position.y += scroll_top; - } - scroll_position + self.offset.apply_along(Axis::Vertical, |offset| { + if self.anchor == Anchor::min() { + 0. + } else { + let scroll_top = self.anchor.to_display_point(snapshot).row().as_f32(); + (offset + scroll_top).max(0.) + } + }) } pub fn top_row(&self, buffer: &MultiBufferSnapshot) -> u32 { From 87555d3f0bb4e19895ad68bb3538978007f6d9e8 Mon Sep 17 00:00:00 2001 From: tidely <43219534+tidely@users.noreply.github.com> Date: Fri, 18 Jul 2025 20:41:12 +0300 Subject: [PATCH 0065/1052] project: Remove clones from git blame serialization (#34727) Release Notes: - N/A --- crates/project/src/git_store.rs | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rs index 5f07bafe5b..6e3d27deff 100644 --- a/crates/project/src/git_store.rs +++ b/crates/project/src/git_store.rs @@ -4397,17 +4397,17 @@ fn serialize_blame_buffer_response(blame: Option) -> proto::B start_line: entry.range.start, end_line: entry.range.end, original_line_number: entry.original_line_number, - author: entry.author.clone(), - author_mail: entry.author_mail.clone(), + author: entry.author, + author_mail: entry.author_mail, author_time: entry.author_time, - author_tz: entry.author_tz.clone(), - committer: entry.committer_name.clone(), - committer_mail: entry.committer_email.clone(), + author_tz: entry.author_tz, + committer: entry.committer_name, + committer_mail: entry.committer_email, committer_time: entry.committer_time, - committer_tz: entry.committer_tz.clone(), - summary: entry.summary.clone(), - previous: entry.previous.clone(), - filename: entry.filename.clone(), + committer_tz: entry.committer_tz, + summary: entry.summary, + previous: entry.previous, + filename: entry.filename, }) .collect::>(); From 64ce696aae27ff5afc44301035a21f40c8ca634f Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Fri, 18 Jul 2025 15:03:14 -0300 Subject: [PATCH 0066/1052] ui: Add the `SwitchField` component (#34713) This will be useful for both the current agent panel and some other onboarding stuff we're working on. Also ended up removing the `SwitchWithLabel` as it was unused. Release Notes: - N/A --- crates/ui/src/components/toggle.rs | 166 ++++++++++++++++++++++++----- 1 file changed, 142 insertions(+), 24 deletions(-) diff --git a/crates/ui/src/components/toggle.rs b/crates/ui/src/components/toggle.rs index 4672a0cfc2..759b225434 100644 --- a/crates/ui/src/components/toggle.rs +++ b/crates/ui/src/components/toggle.rs @@ -543,28 +543,48 @@ impl RenderOnce for Switch { } } -/// A [`Switch`] that has a [`Label`]. -#[derive(IntoElement)] -pub struct SwitchWithLabel { +/// # SwitchField +/// +/// A field component that combines a label, description, and switch into one reusable component. +/// +/// # Examples +/// +/// ``` +/// use ui::prelude::*; +/// +/// SwitchField::new( +/// "feature-toggle", +/// "Enable feature", +/// "This feature adds new functionality to the app.", +/// ToggleState::Unselected, +/// |state, window, cx| { +/// // Logic here +/// } +/// ); +/// ``` +#[derive(IntoElement, RegisterComponent)] +pub struct SwitchField { id: ElementId, - label: Label, + label: SharedString, + description: SharedString, toggle_state: ToggleState, on_click: Arc, disabled: bool, color: SwitchColor, } -impl SwitchWithLabel { - /// Creates a switch with an attached label. +impl SwitchField { pub fn new( id: impl Into, - label: Label, + label: impl Into, + description: impl Into, toggle_state: impl Into, on_click: impl Fn(&ToggleState, &mut Window, &mut App) + 'static, ) -> Self { Self { id: id.into(), - label, + label: label.into(), + description: description.into(), toggle_state: toggle_state.into(), on_click: Arc::new(on_click), disabled: false, @@ -572,43 +592,141 @@ impl SwitchWithLabel { } } - /// Sets the disabled state of the [`SwitchWithLabel`]. pub fn disabled(mut self, disabled: bool) -> Self { self.disabled = disabled; self } /// Sets the color of the switch using the specified [`SwitchColor`]. + /// This changes the color scheme of the switch when it's in the "on" state. pub fn color(mut self, color: SwitchColor) -> Self { self.color = color; self } } -impl RenderOnce for SwitchWithLabel { - fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement { +impl RenderOnce for SwitchField { + fn render(self, _window: &mut Window, _cx: &mut App) -> impl IntoElement { h_flex() .id(SharedString::from(format!("{}-container", self.id))) - .gap(DynamicSpacing::Base08.rems(cx)) + .w_full() + .gap_4() + .justify_between() + .flex_wrap() .child( - Switch::new(self.id.clone(), self.toggle_state) - .disabled(self.disabled) - .color(self.color) - .on_click({ - let on_click = self.on_click.clone(); - move |checked, window, cx| { - (on_click)(checked, window, cx); - } - }), + v_flex() + .gap_0p5() + .max_w_5_6() + .child(Label::new(self.label)) + .child(Label::new(self.description).color(Color::Muted)), ) .child( - div() - .id(SharedString::from(format!("{}-label", self.id))) - .child(self.label), + Switch::new( + SharedString::from(format!("{}-switch", self.id)), + self.toggle_state, + ) + .color(self.color) + .disabled(self.disabled) + .on_click({ + let on_click = self.on_click.clone(); + move |state, window, cx| { + (on_click)(state, window, cx); + } + }), ) } } +impl Component for SwitchField { + fn scope() -> ComponentScope { + ComponentScope::Input + } + + fn description() -> Option<&'static str> { + Some("A field component that combines a label, description, and switch") + } + + fn preview(_window: &mut Window, _cx: &mut App) -> Option { + Some( + v_flex() + .gap_6() + .children(vec![ + example_group_with_title( + "States", + vec![ + single_example( + "Unselected", + SwitchField::new( + "switch_field_unselected", + "Enable notifications", + "Receive notifications when new messages arrive.", + ToggleState::Unselected, + |_, _, _| {}, + ) + .into_any_element(), + ), + single_example( + "Selected", + SwitchField::new( + "switch_field_selected", + "Enable notifications", + "Receive notifications when new messages arrive.", + ToggleState::Selected, + |_, _, _| {}, + ) + .into_any_element(), + ), + ], + ), + example_group_with_title( + "Colors", + vec![ + single_example( + "Default", + SwitchField::new( + "switch_field_default", + "Default color", + "This uses the default switch color.", + ToggleState::Selected, + |_, _, _| {}, + ) + .into_any_element(), + ), + single_example( + "Accent", + SwitchField::new( + "switch_field_accent", + "Accent color", + "This uses the accent color scheme.", + ToggleState::Selected, + |_, _, _| {}, + ) + .color(SwitchColor::Accent) + .into_any_element(), + ), + ], + ), + example_group_with_title( + "Disabled", + vec![single_example( + "Disabled", + SwitchField::new( + "switch_field_disabled", + "Disabled field", + "This field is disabled and cannot be toggled.", + ToggleState::Selected, + |_, _, _| {}, + ) + .disabled(true) + .into_any_element(), + )], + ), + ]) + .into_any_element(), + ) + } +} + impl Component for Checkbox { fn scope() -> ComponentScope { ComponentScope::Input From e1d28ff957dbc16c39e4a8e061e79526f181849a Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Fri, 18 Jul 2025 15:03:31 -0300 Subject: [PATCH 0067/1052] agent: Add `use_modifier_to_send` setting (#34709) When `use_modifier_to_send` is turned on, holding `cmd`/`ctrl` is necessary to send a message in the agent panel. Text threads already use `cmd-enter` by default to submit a message, and it was done this way to have the usual text editing bindings not taken over when writing a prompt, sort of stimulating more thoughtful writing. While `enter` to send is still somewhat a huge pattern in chat-like LLM UIs, it still makes sense to allow this for the new agent panel... hence the existence of this setting now! Release Notes: - agent: Added the `use_modifier_to_send` setting, which makes holding a modifier (`cmd`/`ctrl`), together with `enter`, required to send a new message. --- assets/keymaps/default-linux.json | 13 ++++++++- assets/keymaps/default-macos.json | 14 +++++++++- crates/agent_settings/src/agent_settings.rs | 13 +++++++++ crates/agent_ui/src/message_editor.rs | 30 +++++++++++++++++++-- 4 files changed, 66 insertions(+), 4 deletions(-) diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index b859d2d84c..8e67031485 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -277,7 +277,7 @@ } }, { - "context": "MessageEditor > Editor", + "context": "MessageEditor > Editor && !use_modifier_to_send", "bindings": { "enter": "agent::Chat", "ctrl-enter": "agent::ChatWithFollow", @@ -287,6 +287,17 @@ "ctrl-shift-n": "agent::RejectAll" } }, + { + "context": "MessageEditor > Editor && use_modifier_to_send", + "bindings": { + "ctrl-enter": "agent::Chat", + "enter": "editor::Newline", + "ctrl-i": "agent::ToggleProfileSelector", + "shift-ctrl-r": "agent::OpenAgentDiff", + "ctrl-shift-y": "agent::KeepAll", + "ctrl-shift-n": "agent::RejectAll" + } + }, { "context": "EditMessageEditor > Editor", "bindings": { diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index 748deaa05d..70edee8534 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -318,7 +318,7 @@ } }, { - "context": "MessageEditor > Editor", + "context": "MessageEditor > Editor && !use_modifier_to_send", "use_key_equivalents": true, "bindings": { "enter": "agent::Chat", @@ -329,6 +329,18 @@ "cmd-shift-n": "agent::RejectAll" } }, + { + "context": "MessageEditor > Editor && use_modifier_to_send", + "use_key_equivalents": true, + "bindings": { + "cmd-enter": "agent::Chat", + "enter": "editor::Newline", + "cmd-i": "agent::ToggleProfileSelector", + "shift-ctrl-r": "agent::OpenAgentDiff", + "cmd-shift-y": "agent::KeepAll", + "cmd-shift-n": "agent::RejectAll" + } + }, { "context": "EditMessageEditor > Editor", "use_key_equivalents": true, diff --git a/crates/agent_settings/src/agent_settings.rs b/crates/agent_settings/src/agent_settings.rs index 131cd2dc3f..13b966608c 100644 --- a/crates/agent_settings/src/agent_settings.rs +++ b/crates/agent_settings/src/agent_settings.rs @@ -69,6 +69,7 @@ pub struct AgentSettings { pub enable_feedback: bool, pub expand_edit_card: bool, pub expand_terminal_card: bool, + pub use_modifier_to_send: bool, } impl AgentSettings { @@ -174,6 +175,10 @@ impl AgentSettingsContent { self.single_file_review = Some(allow); } + pub fn set_use_modifier_to_send(&mut self, always_use: bool) { + self.use_modifier_to_send = Some(always_use); + } + pub fn set_profile(&mut self, profile_id: AgentProfileId) { self.default_profile = Some(profile_id); } @@ -301,6 +306,10 @@ pub struct AgentSettingsContent { /// /// Default: true expand_terminal_card: Option, + /// Whether to always use cmd-enter (or ctrl-enter on Linux) to send messages in the agent panel. + /// + /// Default: false + use_modifier_to_send: Option, } #[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Default)] @@ -456,6 +465,10 @@ impl Settings for AgentSettings { &mut settings.expand_terminal_card, value.expand_terminal_card, ); + merge( + &mut settings.use_modifier_to_send, + value.use_modifier_to_send, + ); settings .model_parameters diff --git a/crates/agent_ui/src/message_editor.rs b/crates/agent_ui/src/message_editor.rs index 6967c8ab3e..ce9cc87fe3 100644 --- a/crates/agent_ui/src/message_editor.rs +++ b/crates/agent_ui/src/message_editor.rs @@ -28,8 +28,8 @@ use fs::Fs; use futures::future::Shared; use futures::{FutureExt as _, future}; use gpui::{ - Animation, AnimationExt, App, Entity, EventEmitter, Focusable, Subscription, Task, TextStyle, - WeakEntity, linear_color_stop, linear_gradient, point, pulsating_between, + Animation, AnimationExt, App, Entity, EventEmitter, Focusable, KeyContext, Subscription, Task, + TextStyle, WeakEntity, linear_color_stop, linear_gradient, point, pulsating_between, }; use language::{Buffer, Language, Point}; use language_model::{ @@ -132,6 +132,7 @@ pub(crate) fn create_editor( placement: Some(ContextMenuPlacement::Above), }); editor.register_addon(ContextCreasesAddon::new()); + editor.register_addon(MessageEditorAddon::new()); editor }); @@ -1494,6 +1495,31 @@ pub struct ContextCreasesAddon { _subscription: Option, } +pub struct MessageEditorAddon {} + +impl MessageEditorAddon { + pub fn new() -> Self { + Self {} + } +} + +impl Addon for MessageEditorAddon { + fn to_any(&self) -> &dyn std::any::Any { + self + } + + fn to_any_mut(&mut self) -> Option<&mut dyn std::any::Any> { + Some(self) + } + + fn extend_key_context(&self, key_context: &mut KeyContext, cx: &App) { + let settings = agent_settings::AgentSettings::get_global(cx); + if settings.use_modifier_to_send { + key_context.add("use_modifier_to_send"); + } + } +} + impl Addon for ContextCreasesAddon { fn to_any(&self) -> &dyn std::any::Any { self From fd64ee1bb6756cc41967a053d83ec0ca3519adcd Mon Sep 17 00:00:00 2001 From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com> Date: Fri, 18 Jul 2025 14:09:28 -0400 Subject: [PATCH 0068/1052] keymap ui: Fix remove key mapping bug (#34683) Release Notes: - N/A --------- Co-authored-by: Ben Kunkle --- crates/settings/src/keymap_file.rs | 40 ++++++++++++++++++++++++++++ crates/settings/src/settings_json.rs | 7 +++-- 2 files changed, 45 insertions(+), 2 deletions(-) diff --git a/crates/settings/src/keymap_file.rs b/crates/settings/src/keymap_file.rs index 3a01d889c4..67e8f7e7b2 100644 --- a/crates/settings/src/keymap_file.rs +++ b/crates/settings/src/keymap_file.rs @@ -1623,4 +1623,44 @@ mod tests { .unindent(), ); } + + #[test] + fn test_keymap_remove() { + zlog::init_test(); + + check_keymap_update( + r#" + [ + { + "context": "Editor", + "bindings": { + "cmd-k cmd-u": "editor::ConvertToUpperCase", + "cmd-k cmd-l": "editor::ConvertToLowerCase", + "cmd-[": "pane::GoBack", + } + }, + ] + "#, + KeybindUpdateOperation::Remove { + target: KeybindUpdateTarget { + context: Some("Editor"), + keystrokes: &parse_keystrokes("cmd-k cmd-l"), + action_name: "editor::ConvertToLowerCase", + action_arguments: None, + }, + target_keybind_source: KeybindSource::User, + }, + r#" + [ + { + "context": "Editor", + "bindings": { + "cmd-k cmd-u": "editor::ConvertToUpperCase", + "cmd-[": "pane::GoBack", + } + }, + ] + "#, + ); + } } diff --git a/crates/settings/src/settings_json.rs b/crates/settings/src/settings_json.rs index a448eb2737..e6683857e7 100644 --- a/crates/settings/src/settings_json.rs +++ b/crates/settings/src/settings_json.rs @@ -190,6 +190,7 @@ fn replace_value_in_json_text( } } + let mut removed_comma = false; // Look backward for a preceding comma first let preceding_text = text.get(0..removal_start).unwrap_or(""); if let Some(comma_pos) = preceding_text.rfind(',') { @@ -197,10 +198,12 @@ fn replace_value_in_json_text( let between_comma_and_key = text.get(comma_pos + 1..removal_start).unwrap_or(""); if between_comma_and_key.trim().is_empty() { removal_start = comma_pos; + removed_comma = true; } } - - if let Some(remaining_text) = text.get(existing_value_range.end..) { + if let Some(remaining_text) = text.get(existing_value_range.end..) + && !removed_comma + { let mut chars = remaining_text.char_indices(); while let Some((offset, ch)) = chars.next() { if ch == ',' { From 7b6b75b63fbcdd42e42394732e0fa2e1962512ea Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Fri, 18 Jul 2025 14:31:08 -0400 Subject: [PATCH 0069/1052] ci: Skip generating Windows release artifacts (#34704) Release Notes: - N/A --- .github/workflows/ci.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 98b70ad834..6987022f7a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -748,7 +748,7 @@ jobs: timeout-minutes: 120 name: Create a Windows installer runs-on: [self-hosted, Windows, X64] - if: ${{ startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-bundling') }} + if: false && (startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-bundling')) needs: [windows_tests] env: AZURE_TENANT_ID: ${{ secrets.AZURE_SIGNING_TENANT_ID }} @@ -787,7 +787,7 @@ jobs: - name: Upload Artifacts to release uses: softprops/action-gh-release@de2c0eb89ae2a093876385947365aca7b0e5f844 # v1 # Re-enable when we are ready to publish windows preview releases - if: false && ${{ !(contains(github.event.pull_request.labels.*.name, 'run-bundling')) && env.RELEASE_CHANNEL == 'preview' }} # upload only preview + if: ${{ !(contains(github.event.pull_request.labels.*.name, 'run-bundling')) && env.RELEASE_CHANNEL == 'preview' }} # upload only preview with: draft: true prerelease: ${{ env.RELEASE_CHANNEL == 'preview' }} From d197c96cdc83d2e3b163784944296b377d3c9f42 Mon Sep 17 00:00:00 2001 From: Michael Sloan Date: Fri, 18 Jul 2025 12:58:55 -0600 Subject: [PATCH 0070/1052] Add stripe-mock to docker compose configuration (#34732) Release Notes: - N/A --- compose.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/compose.yml b/compose.yml index 4cd4c86df6..06e8806d20 100644 --- a/compose.yml +++ b/compose.yml @@ -59,5 +59,11 @@ services: depends_on: - postgres + stripe-mock: + image: stripe/stripe-mock:v0.184.0 + ports: + - 12111:12111 + - 12112:12112 + volumes: postgres_data: From 43486c416c2be9a25322c52c71b2ed802593bcd4 Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Fri, 18 Jul 2025 13:04:05 -0600 Subject: [PATCH 0071/1052] Fix enter in branch view (#34731) Broken by #34664 Release Notes: - N/A --- assets/keymaps/default-linux.json | 2 +- assets/keymaps/default-macos.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index 8e67031485..6aba27fec8 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -928,7 +928,7 @@ } }, { - "context": "GitPanel > Editor", + "context": "CommitEditor > Editor", "bindings": { "escape": "git_panel::FocusChanges", "tab": "git_panel::FocusChanges", diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index 70edee8534..6bce3b0f28 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -975,7 +975,7 @@ } }, { - "context": "GitPanel > Editor", + "context": "CommitEditor > Editor", "use_key_equivalents": true, "bindings": { "enter": "editor::Newline", From 70bde54a2c861310eeb005e177019c96947dff09 Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Fri, 18 Jul 2025 15:15:07 -0400 Subject: [PATCH 0072/1052] ci: Lint GitHub Actions workflows with actionlint (#34729) Added [rhysd/actionlint](https://github.com/rhysd/actionlint/) a static checker for GitHub Actions workflow files. Install locally with `brew install actionlint` the run with `actionlint`. Inspired by: https://github.com/zed-industries/zed/pull/34704 which yielded this observation: > In github actions: > 1. strings are truthy > 2. `${{ }}` will become a string if it doesn't wrap the whole value. > > So `if: false && true` becomes `false` > and `if: ${{ false && true }}` becomes `false` > but `if: false && ${{ true }}` becomes `"false && true"` which evaluates true > The reason you sometimes need `${{ }}` is because YAML doesn't like `!` > so `if: !false` is invalid yaml > and `if: ${{ !false }}` works just fine. Changes: - Add `actionlint` job - Refactor `job_spec` job to be more readable - Fix all `actionlint` and `shellcheck` errors in Actions workflows (62 in all) - Add `self-mini-macos` and `self-32vcpu-windows-2022` labels to self-hosted runners. Not strictly related, but useful if you need to take a runner out of the rotation (since `macOS`, `self-hosted`, and `ARM64` are auto-set and cannot be added/removed). - Change ci.yml macos_relase to target `self-mini-macos` instead of `bundle` which was previously deprecated. This would've caught the error fixed in https://github.com/zed-industries/zed/pull/34704. Here's what that [job failure](https://github.com/zed-industries/zed/actions/runs/16376993944/job/46279281842?pr=34729) would've looked like. Release Notes: - N/A --- .github/actionlint.yml | 30 ++++++ .github/workflows/bump_patch_version.yml | 8 +- .github/workflows/ci.yml | 100 +++++++++++------- .../workflows/community_release_actions.yml | 6 +- .github/workflows/deploy_collab.yml | 9 +- .github/workflows/eval.yml | 2 +- .github/workflows/nix.yml | 10 +- .github/workflows/release_nightly.yml | 5 +- .github/workflows/unit_evals.yml | 2 +- 9 files changed, 111 insertions(+), 61 deletions(-) create mode 100644 .github/actionlint.yml diff --git a/.github/actionlint.yml b/.github/actionlint.yml new file mode 100644 index 0000000000..d93ec5b15e --- /dev/null +++ b/.github/actionlint.yml @@ -0,0 +1,30 @@ +# Configuration related to self-hosted runner. +self-hosted-runner: + # Labels of self-hosted runner in array of strings. + labels: + # GitHub-hosted Runners + - github-8vcpu-ubuntu-2404 + - github-16vcpu-ubuntu-2404 + - windows-2025-16 + - windows-2025-32 + - windows-2025-64 + # Buildjet Ubuntu 20.04 - AMD x86_64 + - buildjet-2vcpu-ubuntu-2004 + - buildjet-4vcpu-ubuntu-2004 + - buildjet-8vcpu-ubuntu-2004 + - buildjet-16vcpu-ubuntu-2004 + - buildjet-32vcpu-ubuntu-2004 + # Buildjet Ubuntu 22.04 - AMD x86_64 + - buildjet-2vcpu-ubuntu-2204 + - buildjet-4vcpu-ubuntu-2204 + - buildjet-8vcpu-ubuntu-2204 + - buildjet-16vcpu-ubuntu-2204 + - buildjet-32vcpu-ubuntu-2204 + # Buildjet Ubuntu 22.04 - Graviton aarch64 + - buildjet-8vcpu-ubuntu-2204-arm + - buildjet-16vcpu-ubuntu-2204-arm + - buildjet-32vcpu-ubuntu-2204-arm + - buildjet-64vcpu-ubuntu-2204-arm + # Self Hosted Runners + - self-mini-macos + - self-32vcpu-windows-2022 diff --git a/.github/workflows/bump_patch_version.yml b/.github/workflows/bump_patch_version.yml index 02857a9151..8a48ff96f1 100644 --- a/.github/workflows/bump_patch_version.yml +++ b/.github/workflows/bump_patch_version.yml @@ -28,7 +28,7 @@ jobs: run: | set -eux - channel=$(cat crates/zed/RELEASE_CHANNEL) + channel="$(cat crates/zed/RELEASE_CHANNEL)" tag_suffix="" case $channel in @@ -43,9 +43,9 @@ jobs: ;; esac which cargo-set-version > /dev/null || cargo install cargo-edit - output=$(cargo set-version -p zed --bump patch 2>&1 | sed 's/.* //') + output="$(cargo set-version -p zed --bump patch 2>&1 | sed 's/.* //')" export GIT_COMMITTER_NAME="Zed Bot" export GIT_COMMITTER_EMAIL="hi@zed.dev" git commit -am "Bump to $output for @$GITHUB_ACTOR" --author "Zed Bot " - git tag v${output}${tag_suffix} - git push origin HEAD v${output}${tag_suffix} + git tag "v${output}${tag_suffix}" + git push origin HEAD "v${output}${tag_suffix}" diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 6987022f7a..a4da5e99ba 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -34,6 +34,7 @@ jobs: run_license: ${{ steps.filter.outputs.run_license }} run_docs: ${{ steps.filter.outputs.run_docs }} run_nix: ${{ steps.filter.outputs.run_nix }} + run_actionlint: ${{ steps.filter.outputs.run_actionlint }} runs-on: - ubuntu-latest steps: @@ -47,39 +48,40 @@ jobs: run: | if [ -z "$GITHUB_BASE_REF" ]; then echo "Not in a PR context (i.e., push to main/stable/preview)" - COMPARE_REV=$(git rev-parse HEAD~1) + COMPARE_REV="$(git rev-parse HEAD~1)" else echo "In a PR context comparing to pull_request.base.ref" git fetch origin "$GITHUB_BASE_REF" --depth=350 - COMPARE_REV=$(git merge-base "origin/${GITHUB_BASE_REF}" HEAD) + COMPARE_REV="$(git merge-base "origin/${GITHUB_BASE_REF}" HEAD)" fi - # Specify anything which should skip full CI in this regex: + CHANGED_FILES="$(git diff --name-only "$COMPARE_REV" ${{ github.sha }})" + + # Specify anything which should potentially skip full test suite in this regex: # - docs/ # - script/update_top_ranking_issues/ # - .github/ISSUE_TEMPLATE/ # - .github/workflows/ (except .github/workflows/ci.yml) SKIP_REGEX='^(docs/|script/update_top_ranking_issues/|\.github/(ISSUE_TEMPLATE|workflows/(?!ci)))' - if [[ $(git diff --name-only $COMPARE_REV ${{ github.sha }} | grep -vP "$SKIP_REGEX") ]]; then - echo "run_tests=true" >> $GITHUB_OUTPUT - else - echo "run_tests=false" >> $GITHUB_OUTPUT - fi - if [[ $(git diff --name-only $COMPARE_REV ${{ github.sha }} | grep '^docs/') ]]; then - echo "run_docs=true" >> $GITHUB_OUTPUT - else - echo "run_docs=false" >> $GITHUB_OUTPUT - fi - if [[ $(git diff --name-only $COMPARE_REV ${{ github.sha }} | grep -P '^(Cargo.lock|script/.*licenses)') ]]; then - echo "run_license=true" >> $GITHUB_OUTPUT - else - echo "run_license=false" >> $GITHUB_OUTPUT - fi - NIX_REGEX='^(nix/|flake\.|Cargo\.|rust-toolchain.toml|\.cargo/config.toml)' - if [[ $(git diff --name-only $COMPARE_REV ${{ github.sha }} | grep -P "$NIX_REGEX") ]]; then - echo "run_nix=true" >> $GITHUB_OUTPUT - else - echo "run_nix=false" >> $GITHUB_OUTPUT - fi + + echo "$CHANGED_FILES" | grep -qvP "$SKIP_REGEX" && \ + echo "run_tests=true" >> "$GITHUB_OUTPUT" || \ + echo "run_tests=false" >> "$GITHUB_OUTPUT" + + echo "$CHANGED_FILES" | grep -qP '^docs/' && \ + echo "run_docs=true" >> "$GITHUB_OUTPUT" || \ + echo "run_docs=false" >> "$GITHUB_OUTPUT" + + echo "$CHANGED_FILES" | grep -qP '^\.github/(workflows/|actions/|actionlint.yml)' && \ + echo "run_actionlint=true" >> "$GITHUB_OUTPUT" || \ + echo "run_actionlint=false" >> "$GITHUB_OUTPUT" + + echo "$CHANGED_FILES" | grep -qP '^(Cargo.lock|script/.*licenses)' && \ + echo "run_license=true" >> "$GITHUB_OUTPUT" || \ + echo "run_license=false" >> "$GITHUB_OUTPUT" + + echo "$CHANGED_FILES" | grep -qP '^(nix/|flake\.|Cargo\.|rust-toolchain.toml|\.cargo/config.toml)' && \ + echo "run_nix=true" >> "$GITHUB_OUTPUT" || \ + echo "run_nix=false" >> "$GITHUB_OUTPUT" migration_checks: name: Check Postgres and Protobuf migrations, mergability @@ -89,8 +91,7 @@ jobs: needs.job_spec.outputs.run_tests == 'true' timeout-minutes: 60 runs-on: - - self-hosted - - macOS + - self-mini-macos steps: - name: Checkout repo uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4 @@ -112,11 +113,11 @@ jobs: run: | if [ -z "$GITHUB_BASE_REF" ]; then - echo "BUF_BASE_BRANCH=$(git merge-base origin/main HEAD)" >> $GITHUB_ENV + echo "BUF_BASE_BRANCH=$(git merge-base origin/main HEAD)" >> "$GITHUB_ENV" else git checkout -B temp - git merge -q origin/$GITHUB_BASE_REF -m "merge main into temp" - echo "BUF_BASE_BRANCH=$GITHUB_BASE_REF" >> $GITHUB_ENV + git merge -q "origin/$GITHUB_BASE_REF" -m "merge main into temp" + echo "BUF_BASE_BRANCH=$GITHUB_BASE_REF" >> "$GITHUB_ENV" fi - uses: bufbuild/buf-setup-action@v1 @@ -140,7 +141,7 @@ jobs: - name: Checkout repo uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4 - name: Add Rust to the PATH - run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH + run: echo "$HOME/.cargo/bin" >> "$GITHUB_PATH" - name: Install cargo-hakari uses: clechasseur/rs-cargo@8435b10f6e71c2e3d4d3b7573003a8ce4bfc6386 # v2 with: @@ -178,7 +179,7 @@ jobs: - name: Prettier Check on /docs working-directory: ./docs run: | - pnpm dlx prettier@${PRETTIER_VERSION} . --check || { + pnpm dlx "prettier@${PRETTIER_VERSION}" . --check || { echo "To fix, run from the root of the Zed repo:" echo " cd docs && pnpm dlx prettier@${PRETTIER_VERSION} . --write && cd .." false @@ -188,7 +189,7 @@ jobs: - name: Prettier Check on default.json run: | - pnpm dlx prettier@${PRETTIER_VERSION} assets/settings/default.json --check || { + pnpm dlx "prettier@${PRETTIER_VERSION}" assets/settings/default.json --check || { echo "To fix, run from the root of the Zed repo:" echo " pnpm dlx prettier@${PRETTIER_VERSION} assets/settings/default.json --write" false @@ -234,6 +235,20 @@ jobs: - name: Build docs uses: ./.github/actions/build_docs + actionlint: + runs-on: ubuntu-latest + if: github.repository_owner == 'zed-industries' && needs.job_spec.outputs.run_actionlint == 'true' + needs: [job_spec] + steps: + - uses: actions/checkout@v4 + - name: Download actionlint + id: get_actionlint + run: bash <(curl https://raw.githubusercontent.com/rhysd/actionlint/main/scripts/download-actionlint.bash) + shell: bash + - name: Check workflow files + run: ${{ steps.get_actionlint.outputs.executable }} -color + shell: bash + macos_tests: timeout-minutes: 60 name: (macOS) Run Clippy and tests @@ -242,8 +257,7 @@ jobs: github.repository_owner == 'zed-industries' && needs.job_spec.outputs.run_tests == 'true' runs-on: - - self-hosted - - macOS + - self-mini-macos steps: - name: Checkout repo uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4 @@ -312,7 +326,7 @@ jobs: - buildjet-16vcpu-ubuntu-2204 steps: - name: Add Rust to the PATH - run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH + run: echo "$HOME/.cargo/bin" >> "$GITHUB_PATH" - name: Checkout repo uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4 @@ -364,7 +378,7 @@ jobs: - buildjet-8vcpu-ubuntu-2204 steps: - name: Add Rust to the PATH - run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH + run: echo "$HOME/.cargo/bin" >> "$GITHUB_PATH" - name: Checkout repo uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4 @@ -444,6 +458,7 @@ jobs: - job_spec - style - check_docs + - actionlint - migration_checks # run_tests: If adding required tests, add them here and to script below. - workspace_hack @@ -465,6 +480,11 @@ jobs: if [[ "${{ needs.job_spec.outputs.run_docs }}" == "true" ]]; then [[ "${{ needs.check_docs.result }}" != 'success' ]] && { RET_CODE=1; echo "docs checks failed"; } fi + + if [[ "${{ needs.job_spec.outputs.run_actionlint }}" == "true" ]]; then + [[ "${{ needs.actionlint.result }}" != 'success' ]] && { RET_CODE=1; echo "actionlint checks failed"; } + fi + # Only check test jobs if they were supposed to run if [[ "${{ needs.job_spec.outputs.run_tests }}" == "true" ]]; then [[ "${{ needs.workspace_hack.result }}" != 'success' ]] && { RET_CODE=1; echo "Workspace Hack failed"; } @@ -484,8 +504,7 @@ jobs: timeout-minutes: 120 name: Create a macOS bundle runs-on: - - self-hosted - - bundle + - self-mini-macos if: | startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-bundling') @@ -802,10 +821,9 @@ jobs: && endsWith(github.ref, '-pre') && !endsWith(github.ref, '.0-pre') needs: [bundle-mac, bundle-linux-x86_x64, bundle-linux-aarch64, bundle-windows-x64] runs-on: - - self-hosted - - bundle + - self-mini-macos steps: - name: gh release - run: gh release edit $GITHUB_REF_NAME --draft=false + run: gh release edit "$GITHUB_REF_NAME" --draft=false env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/community_release_actions.yml b/.github/workflows/community_release_actions.yml index 3e253978b7..31dda1fa6d 100644 --- a/.github/workflows/community_release_actions.yml +++ b/.github/workflows/community_release_actions.yml @@ -18,7 +18,7 @@ jobs: URL="https://zed.dev/releases/stable/latest" fi - echo "URL=$URL" >> $GITHUB_OUTPUT + echo "URL=$URL" >> "$GITHUB_OUTPUT" - name: Get content uses: 2428392/gh-truncate-string-action@b3ff790d21cf42af3ca7579146eedb93c8fb0757 # v1.4.1 id: get-content @@ -50,9 +50,9 @@ jobs: PREVIEW_TAG="${VERSION}-pre" if git rev-parse "$PREVIEW_TAG" > /dev/null 2>&1; then - echo "was_promoted_from_preview=true" >> $GITHUB_OUTPUT + echo "was_promoted_from_preview=true" >> "$GITHUB_OUTPUT" else - echo "was_promoted_from_preview=false" >> $GITHUB_OUTPUT + echo "was_promoted_from_preview=false" >> "$GITHUB_OUTPUT" fi - name: Send release notes email diff --git a/.github/workflows/deploy_collab.yml b/.github/workflows/deploy_collab.yml index cfd455f920..f7348a1069 100644 --- a/.github/workflows/deploy_collab.yml +++ b/.github/workflows/deploy_collab.yml @@ -79,12 +79,12 @@ jobs: - name: Build docker image run: | docker build -f Dockerfile-collab \ - --build-arg GITHUB_SHA=$GITHUB_SHA \ - --tag registry.digitalocean.com/zed/collab:$GITHUB_SHA \ + --build-arg "GITHUB_SHA=$GITHUB_SHA" \ + --tag "registry.digitalocean.com/zed/collab:$GITHUB_SHA" \ . - name: Publish docker image - run: docker push registry.digitalocean.com/zed/collab:${GITHUB_SHA} + run: docker push "registry.digitalocean.com/zed/collab:${GITHUB_SHA}" - name: Prune Docker system run: docker system prune --filter 'until=72h' -f @@ -131,7 +131,8 @@ jobs: source script/lib/deploy-helpers.sh export_vars_for_environment $ZED_KUBE_NAMESPACE - export ZED_DO_CERTIFICATE_ID=$(doctl compute certificate list --format ID --no-header) + ZED_DO_CERTIFICATE_ID="$(doctl compute certificate list --format ID --no-header)" + export ZED_DO_CERTIFICATE_ID export ZED_IMAGE_ID="registry.digitalocean.com/zed/collab:${GITHUB_SHA}" export ZED_SERVICE_NAME=collab diff --git a/.github/workflows/eval.yml b/.github/workflows/eval.yml index 6eefdfea95..2ad302a602 100644 --- a/.github/workflows/eval.yml +++ b/.github/workflows/eval.yml @@ -35,7 +35,7 @@ jobs: - buildjet-16vcpu-ubuntu-2204 steps: - name: Add Rust to the PATH - run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH + run: echo "$HOME/.cargo/bin" >> "$GITHUB_PATH" - name: Checkout repo uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4 diff --git a/.github/workflows/nix.yml b/.github/workflows/nix.yml index 155fc484f5..beacd27774 100644 --- a/.github/workflows/nix.yml +++ b/.github/workflows/nix.yml @@ -43,8 +43,8 @@ jobs: - name: Set path if: ${{ ! matrix.system.install_nix }} run: | - echo "/nix/var/nix/profiles/default/bin" >> $GITHUB_PATH - echo "/Users/administrator/.nix-profile/bin" >> $GITHUB_PATH + echo "/nix/var/nix/profiles/default/bin" >> "$GITHUB_PATH" + echo "/Users/administrator/.nix-profile/bin" >> "$GITHUB_PATH" - uses: cachix/install-nix-action@02a151ada4993995686f9ed4f1be7cfbb229e56f # v31 if: ${{ matrix.system.install_nix }} @@ -56,11 +56,13 @@ jobs: name: zed authToken: "${{ secrets.CACHIX_AUTH_TOKEN }}" pushFilter: "${{ inputs.cachix-filter }}" - cachixArgs: '-v' + cachixArgs: "-v" - run: nix build .#${{ inputs.flake-output }} -L --accept-flake-config - name: Limit /nix/store to 50GB on macs if: ${{ ! matrix.system.install_nix }} run: | - [ $(du -sm /nix/store | cut -f1) -gt 50000 ] && nix-collect-garbage -d || : + if [ "$(du -sm /nix/store | cut -f1)" -gt 50000 ]; then + nix-collect-garbage -d || true + fi diff --git a/.github/workflows/release_nightly.yml b/.github/workflows/release_nightly.yml index 4be20525f9..f799133ea7 100644 --- a/.github/workflows/release_nightly.yml +++ b/.github/workflows/release_nightly.yml @@ -85,8 +85,7 @@ jobs: name: Create a macOS bundle if: github.repository_owner == 'zed-industries' runs-on: - - self-hosted - - bundle + - self-mini-macos needs: tests env: MACOS_CERTIFICATE: ${{ secrets.MACOS_CERTIFICATE }} @@ -132,7 +131,7 @@ jobs: clean: false - name: Add Rust to the PATH - run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH + run: echo "$HOME/.cargo/bin" >> "$GITHUB_PATH" - name: Install Linux dependencies run: ./script/linux && ./script/install-mold 2.34.0 diff --git a/.github/workflows/unit_evals.yml b/.github/workflows/unit_evals.yml index 705caff37a..cb4e39d151 100644 --- a/.github/workflows/unit_evals.yml +++ b/.github/workflows/unit_evals.yml @@ -26,7 +26,7 @@ jobs: - buildjet-16vcpu-ubuntu-2204 steps: - name: Add Rust to the PATH - run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH + run: echo "$HOME/.cargo/bin" >> "$GITHUB_PATH" - name: Checkout repo uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4 From 4bdac8026c6334f88777ab1f69145e124292a5d0 Mon Sep 17 00:00:00 2001 From: morgankrey Date: Fri, 18 Jul 2025 16:42:48 -0500 Subject: [PATCH 0073/1052] collab: Enable automatic tax calculation for all new subscriptions (#34720) Release Notes: - N/A --------- Co-authored-by: Marshall Bowers --- crates/collab/src/stripe_billing.rs | 5 ++-- crates/collab/src/stripe_client.rs | 6 +++++ .../src/stripe_client/real_stripe_client.rs | 23 ++++++++++++++----- 3 files changed, 26 insertions(+), 8 deletions(-) diff --git a/crates/collab/src/stripe_billing.rs b/crates/collab/src/stripe_billing.rs index fdd9653d7c..3d52dea0e3 100644 --- a/crates/collab/src/stripe_billing.rs +++ b/crates/collab/src/stripe_billing.rs @@ -11,8 +11,8 @@ use crate::Result; use crate::db::billing_subscription::SubscriptionKind; use crate::llm::AGENT_EXTENDED_TRIAL_FEATURE_FLAG; use crate::stripe_client::{ - RealStripeClient, StripeBillingAddressCollection, StripeCheckoutSessionMode, - StripeCheckoutSessionPaymentMethodCollection, StripeClient, + RealStripeClient, StripeAutomaticTax, StripeBillingAddressCollection, + StripeCheckoutSessionMode, StripeCheckoutSessionPaymentMethodCollection, StripeClient, StripeCreateCheckoutSessionLineItems, StripeCreateCheckoutSessionParams, StripeCreateCheckoutSessionSubscriptionData, StripeCreateMeterEventParams, StripeCreateMeterEventPayload, StripeCreateSubscriptionItems, StripeCreateSubscriptionParams, @@ -344,6 +344,7 @@ impl StripeBilling { price: Some(zed_free_price_id), quantity: Some(1), }], + automatic_tax: Some(StripeAutomaticTax { enabled: true }), }; let subscription = self.client.create_subscription(params).await?; diff --git a/crates/collab/src/stripe_client.rs b/crates/collab/src/stripe_client.rs index ec947e12f7..6e75a4d874 100644 --- a/crates/collab/src/stripe_client.rs +++ b/crates/collab/src/stripe_client.rs @@ -73,6 +73,7 @@ pub enum StripeCancellationDetailsReason { pub struct StripeCreateSubscriptionParams { pub customer: StripeCustomerId, pub items: Vec, + pub automatic_tax: Option, } #[derive(Debug)] @@ -224,6 +225,11 @@ pub struct StripeTaxIdCollection { pub enabled: bool, } +#[derive(Debug, Clone)] +pub struct StripeAutomaticTax { + pub enabled: bool, +} + #[derive(Debug)] pub struct StripeCheckoutSession { pub url: Option, diff --git a/crates/collab/src/stripe_client/real_stripe_client.rs b/crates/collab/src/stripe_client/real_stripe_client.rs index 07dde68d17..07c191ff30 100644 --- a/crates/collab/src/stripe_client/real_stripe_client.rs +++ b/crates/collab/src/stripe_client/real_stripe_client.rs @@ -10,16 +10,17 @@ use stripe::{ CreateCheckoutSessionSubscriptionData, CreateCheckoutSessionSubscriptionDataTrialSettings, CreateCheckoutSessionSubscriptionDataTrialSettingsEndBehavior, CreateCheckoutSessionSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod, - CreateCustomer, Customer, CustomerId, ListCustomers, Price, PriceId, Recurring, Subscription, - SubscriptionId, SubscriptionItem, SubscriptionItemId, UpdateCustomer, UpdateSubscriptionItems, - UpdateSubscriptionTrialSettings, UpdateSubscriptionTrialSettingsEndBehavior, + CreateCustomer, CreateSubscriptionAutomaticTax, Customer, CustomerId, ListCustomers, Price, + PriceId, Recurring, Subscription, SubscriptionId, SubscriptionItem, SubscriptionItemId, + UpdateCustomer, UpdateSubscriptionItems, UpdateSubscriptionTrialSettings, + UpdateSubscriptionTrialSettingsEndBehavior, UpdateSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod, }; use crate::stripe_client::{ - CreateCustomerParams, StripeBillingAddressCollection, StripeCancellationDetails, - StripeCancellationDetailsReason, StripeCheckoutSession, StripeCheckoutSessionMode, - StripeCheckoutSessionPaymentMethodCollection, StripeClient, + CreateCustomerParams, StripeAutomaticTax, StripeBillingAddressCollection, + StripeCancellationDetails, StripeCancellationDetailsReason, StripeCheckoutSession, + StripeCheckoutSessionMode, StripeCheckoutSessionPaymentMethodCollection, StripeClient, StripeCreateCheckoutSessionLineItems, StripeCreateCheckoutSessionParams, StripeCreateCheckoutSessionSubscriptionData, StripeCreateMeterEventParams, StripeCreateSubscriptionParams, StripeCustomer, StripeCustomerId, StripeCustomerUpdate, @@ -151,6 +152,7 @@ impl StripeClient for RealStripeClient { }) .collect(), ); + create_subscription.automatic_tax = params.automatic_tax.map(Into::into); let subscription = Subscription::create(&self.client, create_subscription).await?; @@ -366,6 +368,15 @@ impl From for StripeSubscriptionItem { } } +impl From for CreateSubscriptionAutomaticTax { + fn from(value: StripeAutomaticTax) -> Self { + Self { + enabled: value.enabled, + liability: None, + } + } +} + impl From for UpdateSubscriptionTrialSettings { fn from(value: StripeSubscriptionTrialSettings) -> Self { Self { From 2da2ae65a07dbace600e301b63640ac07ab61289 Mon Sep 17 00:00:00 2001 From: Mikayla Maki Date: Fri, 18 Jul 2025 18:27:54 -0700 Subject: [PATCH 0074/1052] gpui: Add use state APIs (#34741) This PR adds a component level state API to GPUI, as well as a few utilities for simplified interactions with entities Release Notes: - N/A --- crates/eval/src/example.rs | 7 ++ crates/gpui/src/app.rs | 96 +++++++++++++++++++- crates/gpui/src/app/async_context.rs | 20 +++- crates/gpui/src/app/context.rs | 7 ++ crates/gpui/src/app/entity_map.rs | 32 +++++-- crates/gpui/src/app/test_context.rs | 21 +++++ crates/gpui/src/element.rs | 29 +++--- crates/gpui/src/gpui.rs | 5 + crates/gpui/src/window.rs | 50 ++++++++++ crates/gpui_macros/src/derive_app_context.rs | 10 ++ 10 files changed, 252 insertions(+), 25 deletions(-) diff --git a/crates/eval/src/example.rs b/crates/eval/src/example.rs index 09770364cb..7ce3b1fdf1 100644 --- a/crates/eval/src/example.rs +++ b/crates/eval/src/example.rs @@ -422,6 +422,13 @@ impl AppContext for ExampleContext { self.app.update_entity(handle, update) } + fn as_mut<'a, T>(&'a mut self, handle: &Entity) -> Self::Result> + where + T: 'static, + { + self.app.as_mut(handle) + } + fn read_entity( &self, handle: &Entity, diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs index 957c7c4be6..70e1d1e4cd 100644 --- a/crates/gpui/src/app.rs +++ b/crates/gpui/src/app.rs @@ -448,15 +448,23 @@ impl App { } pub(crate) fn update(&mut self, update: impl FnOnce(&mut Self) -> R) -> R { - self.pending_updates += 1; + self.start_update(); let result = update(self); + self.finish_update(); + result + } + + pub(crate) fn start_update(&mut self) { + self.pending_updates += 1; + } + + pub(crate) fn finish_update(&mut self) { if !self.flushing_effects && self.pending_updates == 1 { self.flushing_effects = true; self.flush_effects(); self.flushing_effects = false; } self.pending_updates -= 1; - result } /// Arrange a callback to be invoked when the given entity calls `notify` on its respective context. @@ -868,7 +876,6 @@ impl App { loop { self.release_dropped_entities(); self.release_dropped_focus_handles(); - if let Some(effect) = self.pending_effects.pop_front() { match effect { Effect::Notify { emitter } => { @@ -1819,6 +1826,13 @@ impl AppContext for App { }) } + fn as_mut<'a, T>(&'a mut self, handle: &Entity) -> GpuiBorrow<'a, T> + where + T: 'static, + { + GpuiBorrow::new(handle.clone(), self) + } + fn read_entity( &self, handle: &Entity, @@ -2015,3 +2029,79 @@ impl HttpClient for NullHttpClient { type_name::() } } + +/// A mutable reference to an entity owned by GPUI +pub struct GpuiBorrow<'a, T> { + inner: Option>, + app: &'a mut App, +} + +impl<'a, T: 'static> GpuiBorrow<'a, T> { + fn new(inner: Entity, app: &'a mut App) -> Self { + app.start_update(); + let lease = app.entities.lease(&inner); + Self { + inner: Some(lease), + app, + } + } +} + +impl<'a, T: 'static> std::borrow::Borrow for GpuiBorrow<'a, T> { + fn borrow(&self) -> &T { + self.inner.as_ref().unwrap().borrow() + } +} + +impl<'a, T: 'static> std::borrow::BorrowMut for GpuiBorrow<'a, T> { + fn borrow_mut(&mut self) -> &mut T { + self.inner.as_mut().unwrap().borrow_mut() + } +} + +impl<'a, T> Drop for GpuiBorrow<'a, T> { + fn drop(&mut self) { + let lease = self.inner.take().unwrap(); + self.app.notify(lease.id); + self.app.entities.end_lease(lease); + self.app.finish_update(); + } +} + +#[cfg(test)] +mod test { + use std::{cell::RefCell, rc::Rc}; + + use crate::{AppContext, TestAppContext}; + + #[test] + fn test_gpui_borrow() { + let cx = TestAppContext::single(); + let observation_count = Rc::new(RefCell::new(0)); + + let state = cx.update(|cx| { + let state = cx.new(|_| false); + cx.observe(&state, { + let observation_count = observation_count.clone(); + move |_, _| { + let mut count = observation_count.borrow_mut(); + *count += 1; + } + }) + .detach(); + + state + }); + + cx.update(|cx| { + // Calling this like this so that we don't clobber the borrow_mut above + *std::borrow::BorrowMut::borrow_mut(&mut state.as_mut(cx)) = true; + }); + + cx.update(|cx| { + state.write(cx, false); + }); + + assert_eq!(*observation_count.borrow(), 2); + } +} diff --git a/crates/gpui/src/app/async_context.rs b/crates/gpui/src/app/async_context.rs index c3b60dd580..d9d21c0244 100644 --- a/crates/gpui/src/app/async_context.rs +++ b/crates/gpui/src/app/async_context.rs @@ -3,7 +3,7 @@ use crate::{ Entity, EventEmitter, Focusable, ForegroundExecutor, Global, PromptButton, PromptLevel, Render, Reservation, Result, Subscription, Task, VisualContext, Window, WindowHandle, }; -use anyhow::Context as _; +use anyhow::{Context as _, anyhow}; use derive_more::{Deref, DerefMut}; use futures::channel::oneshot; use std::{future::Future, rc::Weak}; @@ -58,6 +58,15 @@ impl AppContext for AsyncApp { Ok(app.update_entity(handle, update)) } + fn as_mut<'a, T>(&'a mut self, _handle: &Entity) -> Self::Result> + where + T: 'static, + { + Err(anyhow!( + "Cannot as_mut with an async context. Try calling update() first" + )) + } + fn read_entity( &self, handle: &Entity, @@ -364,6 +373,15 @@ impl AppContext for AsyncWindowContext { .update(self, |_, _, cx| cx.update_entity(handle, update)) } + fn as_mut<'a, T>(&'a mut self, _: &Entity) -> Self::Result> + where + T: 'static, + { + Err(anyhow!( + "Cannot use as_mut() from an async context, call `update`" + )) + } + fn read_entity( &self, handle: &Entity, diff --git a/crates/gpui/src/app/context.rs b/crates/gpui/src/app/context.rs index 2d90ff35b1..392be2ffe9 100644 --- a/crates/gpui/src/app/context.rs +++ b/crates/gpui/src/app/context.rs @@ -726,6 +726,13 @@ impl AppContext for Context<'_, T> { self.app.update_entity(handle, update) } + fn as_mut<'a, E>(&'a mut self, handle: &Entity) -> Self::Result> + where + E: 'static, + { + self.app.as_mut(handle) + } + fn read_entity( &self, handle: &Entity, diff --git a/crates/gpui/src/app/entity_map.rs b/crates/gpui/src/app/entity_map.rs index f1aafa55e8..d4e5b2570e 100644 --- a/crates/gpui/src/app/entity_map.rs +++ b/crates/gpui/src/app/entity_map.rs @@ -1,4 +1,4 @@ -use crate::{App, AppContext, VisualContext, Window, seal::Sealed}; +use crate::{App, AppContext, GpuiBorrow, VisualContext, Window, seal::Sealed}; use anyhow::{Context as _, Result}; use collections::FxHashSet; use derive_more::{Deref, DerefMut}; @@ -105,7 +105,7 @@ impl EntityMap { /// Move an entity to the stack. #[track_caller] - pub fn lease<'a, T>(&mut self, pointer: &'a Entity) -> Lease<'a, T> { + pub fn lease(&mut self, pointer: &Entity) -> Lease { self.assert_valid_context(pointer); let mut accessed_entities = self.accessed_entities.borrow_mut(); accessed_entities.insert(pointer.entity_id); @@ -117,15 +117,14 @@ impl EntityMap { ); Lease { entity, - pointer, + id: pointer.entity_id, entity_type: PhantomData, } } /// Returns an entity after moving it to the stack. pub fn end_lease(&mut self, mut lease: Lease) { - self.entities - .insert(lease.pointer.entity_id, lease.entity.take().unwrap()); + self.entities.insert(lease.id, lease.entity.take().unwrap()); } pub fn read(&self, entity: &Entity) -> &T { @@ -187,13 +186,13 @@ fn double_lease_panic(operation: &str) -> ! { ) } -pub(crate) struct Lease<'a, T> { +pub(crate) struct Lease { entity: Option>, - pub pointer: &'a Entity, + pub id: EntityId, entity_type: PhantomData, } -impl core::ops::Deref for Lease<'_, T> { +impl core::ops::Deref for Lease { type Target = T; fn deref(&self) -> &Self::Target { @@ -201,13 +200,13 @@ impl core::ops::Deref for Lease<'_, T> { } } -impl core::ops::DerefMut for Lease<'_, T> { +impl core::ops::DerefMut for Lease { fn deref_mut(&mut self) -> &mut Self::Target { self.entity.as_mut().unwrap().downcast_mut().unwrap() } } -impl Drop for Lease<'_, T> { +impl Drop for Lease { fn drop(&mut self) { if self.entity.is_some() && !panicking() { panic!("Leases must be ended with EntityMap::end_lease") @@ -437,6 +436,19 @@ impl Entity { cx.update_entity(self, update) } + /// Updates the entity referenced by this handle with the given function. + pub fn as_mut<'a, C: AppContext>(&self, cx: &'a mut C) -> C::Result> { + cx.as_mut(self) + } + + /// Updates the entity referenced by this handle with the given function. + pub fn write(&self, cx: &mut C, value: T) -> C::Result<()> { + self.update(cx, |entity, cx| { + *entity = value; + cx.notify(); + }) + } + /// Updates the entity referenced by this handle with the given function if /// the referenced entity still exists, within a visual context that has a window. /// Returns an error if the entity has been released. diff --git a/crates/gpui/src/app/test_context.rs b/crates/gpui/src/app/test_context.rs index dfc7af0d9c..35e6032671 100644 --- a/crates/gpui/src/app/test_context.rs +++ b/crates/gpui/src/app/test_context.rs @@ -9,6 +9,7 @@ use crate::{ }; use anyhow::{anyhow, bail}; use futures::{Stream, StreamExt, channel::oneshot}; +use rand::{SeedableRng, rngs::StdRng}; use std::{cell::RefCell, future::Future, ops::Deref, rc::Rc, sync::Arc, time::Duration}; /// A TestAppContext is provided to tests created with `#[gpui::test]`, it provides @@ -63,6 +64,13 @@ impl AppContext for TestAppContext { app.update_entity(handle, update) } + fn as_mut<'a, T>(&'a mut self, _: &Entity) -> Self::Result> + where + T: 'static, + { + panic!("Cannot use as_mut with a test app context. Try calling update() first") + } + fn read_entity( &self, handle: &Entity, @@ -134,6 +142,12 @@ impl TestAppContext { } } + /// Create a single TestAppContext, for non-multi-client tests + pub fn single() -> Self { + let dispatcher = TestDispatcher::new(StdRng::from_entropy()); + Self::build(dispatcher, None) + } + /// The name of the test function that created this `TestAppContext` pub fn test_function_name(&self) -> Option<&'static str> { self.fn_name @@ -914,6 +928,13 @@ impl AppContext for VisualTestContext { self.cx.update_entity(handle, update) } + fn as_mut<'a, T>(&'a mut self, handle: &Entity) -> Self::Result> + where + T: 'static, + { + self.cx.as_mut(handle) + } + fn read_entity( &self, handle: &Entity, diff --git a/crates/gpui/src/element.rs b/crates/gpui/src/element.rs index 2852841b2c..e5f49c7be1 100644 --- a/crates/gpui/src/element.rs +++ b/crates/gpui/src/element.rs @@ -39,7 +39,7 @@ use crate::{ use derive_more::{Deref, DerefMut}; pub(crate) use smallvec::SmallVec; use std::{ - any::Any, + any::{Any, type_name}, fmt::{self, Debug, Display}, mem, panic, }; @@ -220,14 +220,17 @@ impl Element for Component { window: &mut Window, cx: &mut App, ) -> (LayoutId, Self::RequestLayoutState) { - let mut element = self - .component - .take() - .unwrap() - .render(window, cx) - .into_any_element(); - let layout_id = element.request_layout(window, cx); - (layout_id, element) + window.with_global_id(ElementId::Name(type_name::().into()), |_, window| { + let mut element = self + .component + .take() + .unwrap() + .render(window, cx) + .into_any_element(); + + let layout_id = element.request_layout(window, cx); + (layout_id, element) + }) } fn prepaint( @@ -239,7 +242,9 @@ impl Element for Component { window: &mut Window, cx: &mut App, ) { - element.prepaint(window, cx); + window.with_global_id(ElementId::Name(type_name::().into()), |_, window| { + element.prepaint(window, cx); + }) } fn paint( @@ -252,7 +257,9 @@ impl Element for Component { window: &mut Window, cx: &mut App, ) { - element.paint(window, cx); + window.with_global_id(ElementId::Name(type_name::().into()), |_, window| { + element.paint(window, cx); + }) } } diff --git a/crates/gpui/src/gpui.rs b/crates/gpui/src/gpui.rs index 91461a4d2c..4eb6fa8dab 100644 --- a/crates/gpui/src/gpui.rs +++ b/crates/gpui/src/gpui.rs @@ -197,6 +197,11 @@ pub trait AppContext { where T: 'static; + /// Update a entity in the app context. + fn as_mut<'a, T>(&'a mut self, handle: &Entity) -> Self::Result> + where + T: 'static; + /// Read a entity from the app context. fn read_entity( &self, diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rs index 94f1b39ba2..b6601829c7 100644 --- a/crates/gpui/src/window.rs +++ b/crates/gpui/src/window.rs @@ -2424,6 +2424,53 @@ impl Window { result } + /// Use a piece of state that exists as long this element is being rendered in consecutive frames. + pub fn use_keyed_state( + &mut self, + key: impl Into, + cx: &mut App, + init: impl FnOnce(&mut Self, &mut App) -> S, + ) -> Entity { + let current_view = self.current_view(); + self.with_global_id(key.into(), |global_id, window| { + window.with_element_state(global_id, |state: Option>, window| { + if let Some(state) = state { + (state.clone(), state) + } else { + let new_state = cx.new(|cx| init(window, cx)); + cx.observe(&new_state, move |_, cx| { + cx.notify(current_view); + }) + .detach(); + (new_state.clone(), new_state) + } + }) + }) + } + + /// Immediately push an element ID onto the stack. Useful for simplifying IDs in lists + pub fn with_id(&mut self, id: impl Into, f: impl FnOnce(&mut Self) -> R) -> R { + self.with_global_id(id.into(), |_, window| f(window)) + } + + /// Use a piece of state that exists as long this element is being rendered in consecutive frames, without needing to specify a key + /// + /// NOTE: This method uses the location of the caller to generate an ID for this state. + /// If this is not sufficient to identify your state (e.g. you're rendering a list item), + /// you can provide a custom ElementID using the `use_keyed_state` method. + #[track_caller] + pub fn use_state( + &mut self, + cx: &mut App, + init: impl FnOnce(&mut Self, &mut App) -> S, + ) -> Entity { + self.use_keyed_state( + ElementId::CodeLocation(*core::panic::Location::caller()), + cx, + init, + ) + } + /// Updates or initializes state for an element with the given id that lives across multiple /// frames. If an element with this ID existed in the rendered frame, its state will be passed /// to the given closure. The state returned by the closure will be stored so it can be referenced @@ -4577,6 +4624,8 @@ pub enum ElementId { NamedInteger(SharedString, u64), /// A path. Path(Arc), + /// A code location. + CodeLocation(core::panic::Location<'static>), } impl ElementId { @@ -4596,6 +4645,7 @@ impl Display for ElementId { ElementId::NamedInteger(s, i) => write!(f, "{}-{}", s, i)?, ElementId::Uuid(uuid) => write!(f, "{}", uuid)?, ElementId::Path(path) => write!(f, "{}", path.display())?, + ElementId::CodeLocation(location) => write!(f, "{}", location)?, } Ok(()) diff --git a/crates/gpui_macros/src/derive_app_context.rs b/crates/gpui_macros/src/derive_app_context.rs index bca015b8dc..d2dc250d02 100644 --- a/crates/gpui_macros/src/derive_app_context.rs +++ b/crates/gpui_macros/src/derive_app_context.rs @@ -53,6 +53,16 @@ pub fn derive_app_context(input: TokenStream) -> TokenStream { self.#app_variable.update_entity(handle, update) } + fn as_mut<'y, 'z, T>( + &'y mut self, + handle: &'z gpui::Entity, + ) -> Self::Result> + where + T: 'static, + { + self.#app_variable.as_mut(handle) + } + fn read_entity( &self, handle: &gpui::Entity, From 0ffd93774cb9b21850e8480a2e57f69763923a0e Mon Sep 17 00:00:00 2001 From: Vitaly Slobodin Date: Sat, 19 Jul 2025 17:06:35 +0200 Subject: [PATCH 0075/1052] Fix Tailwind support for HTML/ERB files (#34743) Closes #27118 Closes #34165 Fix a small issue after we landed https://github.com/zed-extensions/ruby/pull/113+ where we introduced `HTML/ERB` and `YAML/ERB` language IDs to improve user experience. Sorry about that. Thanks! Release Notes: - N/A --- crates/languages/src/lib.rs | 1 + crates/languages/src/tailwind.rs | 1 + 2 files changed, 2 insertions(+) diff --git a/crates/languages/src/lib.rs b/crates/languages/src/lib.rs index 431c051081..a224111002 100644 --- a/crates/languages/src/lib.rs +++ b/crates/languages/src/lib.rs @@ -273,6 +273,7 @@ pub fn init(languages: Arc, node: NodeRuntime, cx: &mut App) { "Astro", "CSS", "ERB", + "HTML/ERB", "HEEX", "HTML", "JavaScript", diff --git a/crates/languages/src/tailwind.rs b/crates/languages/src/tailwind.rs index 04f30b6246..cb4e939083 100644 --- a/crates/languages/src/tailwind.rs +++ b/crates/languages/src/tailwind.rs @@ -179,6 +179,7 @@ impl LspAdapter for TailwindLspAdapter { ("Elixir".to_string(), "phoenix-heex".to_string()), ("HEEX".to_string(), "phoenix-heex".to_string()), ("ERB".to_string(), "erb".to_string()), + ("HTML/ERB".to_string(), "erb".to_string()), ("PHP".to_string(), "php".to_string()), ("Vue.js".to_string(), "vue".to_string()), ]) From 29111304dde348a00fbceca71183bd30703175b8 Mon Sep 17 00:00:00 2001 From: Oleksandr Mykhailenko <58030797+armyhaylenko@users.noreply.github.com> Date: Sat, 19 Jul 2025 18:59:57 +0300 Subject: [PATCH 0076/1052] agent: Fix Mistral tool use error message (#34692) Closes #32675 Exactly the same changes as in #33640 by @sviande The PR has been in WIP state for 3 weeks with no activity, and the issue basically makes Mistral models unusable. I have tested the changes locally, and it does indeed work. Full credit goes to @sviande, I just want this feature to be finished. Release Notes: - agent: Fixed an issue with tool calling with the Mistral provider (thanks [@sviande](https://github.com/sviande) and [@armyhaylenko](https://github.com/armyhaylenko)) Co-authored-by: sviande --- .../language_models/src/provider/mistral.rs | 34 ++++++++----------- 1 file changed, 14 insertions(+), 20 deletions(-) diff --git a/crates/language_models/src/provider/mistral.rs b/crates/language_models/src/provider/mistral.rs index 11497fda35..fb385308fa 100644 --- a/crates/language_models/src/provider/mistral.rs +++ b/crates/language_models/src/provider/mistral.rs @@ -410,8 +410,20 @@ pub fn into_mistral( .push_part(mistral::MessagePart::Text { text: text.clone() }); } MessageContent::RedactedThinking(_) => {} - MessageContent::ToolUse(_) | MessageContent::ToolResult(_) => { - // Tool content is not supported in User messages for Mistral + MessageContent::ToolUse(_) => { + // Tool use is not supported in User messages for Mistral + } + MessageContent::ToolResult(tool_result) => { + let tool_content = match &tool_result.content { + LanguageModelToolResultContent::Text(text) => text.to_string(), + LanguageModelToolResultContent::Image(_) => { + "[Tool responded with an image, but Zed doesn't support these in Mistral models yet]".to_string() + } + }; + messages.push(mistral::RequestMessage::Tool { + content: tool_content, + tool_call_id: tool_result.tool_use_id.to_string(), + }); } } } @@ -482,24 +494,6 @@ pub fn into_mistral( } } - for message in &request.messages { - for content in &message.content { - if let MessageContent::ToolResult(tool_result) = content { - let content = match &tool_result.content { - LanguageModelToolResultContent::Text(text) => text.to_string(), - LanguageModelToolResultContent::Image(_) => { - "[Tool responded with an image, but Zed doesn't support these in Mistral models yet]".to_string() - } - }; - - messages.push(mistral::RequestMessage::Tool { - content, - tool_call_id: tool_result.tool_use_id.to_string(), - }); - } - } - } - // The Mistral API requires that tool messages be followed by assistant messages, // not user messages. When we have a tool->user sequence in the conversation, // we need to insert a placeholder assistant message to maintain proper conversation From fb88de92234fd494bafb13c694569015bcb2356c Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Sat, 19 Jul 2025 12:01:18 -0400 Subject: [PATCH 0077/1052] Fix error in OpenRouter svg logo (#34764) Fix a spurious error in Zed logs from the OpenRouter svg Logo introduced in https://github.com/zed-industries/zed/pull/29496: ```log WARN [usvg::parser::svgtree] Failed to parse clip-path value: 'url(#clip0_205_3)'. ``` Release Notes: - N/A --- assets/icons/ai_open_router.svg | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/assets/icons/ai_open_router.svg b/assets/icons/ai_open_router.svg index cc8597729a..94f2849146 100644 --- a/assets/icons/ai_open_router.svg +++ b/assets/icons/ai_open_router.svg @@ -1,5 +1,5 @@ - + From 5f92ac25a7690fdfa6864e30d4528c2a5b5e56f8 Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Sat, 19 Jul 2025 12:01:33 -0400 Subject: [PATCH 0078/1052] docs: Consolidate backend setup docs into local-collaboration.md (#34653) Simplify docs for mac/linux/windows by consolidating the backend dependencies (collaboration) docs into local-collaboration.md. Most users building zed will not need to do this -- streamline them into getting setup to build the zed client app first. Release Notes: - N/A --- docs/src/development/linux.md | 15 +---- docs/src/development/local-collaboration.md | 66 ++++++++++++++++++++- docs/src/development/macos.md | 23 ++----- docs/src/development/windows.md | 15 +---- 4 files changed, 73 insertions(+), 46 deletions(-) diff --git a/docs/src/development/linux.md b/docs/src/development/linux.md index 08ac7f116b..6fff25f6c1 100644 --- a/docs/src/development/linux.md +++ b/docs/src/development/linux.md @@ -16,20 +16,9 @@ Clone down the [Zed repository](https://github.com/zed-industries/zed). If you prefer to install the system libraries manually, you can find the list of required packages in the `script/linux` file. -## Backend dependencies +### Backend Dependencies (optional) {#backend-dependencies} -> This section is still in development. The instructions are not yet complete. - -If you are developing collaborative features of Zed, you'll need to install the dependencies of zed's `collab` server: - -- Install [Postgres](https://www.postgresql.org/download/linux/) -- Install [Livekit](https://github.com/livekit/livekit-cli) and [Foreman](https://theforeman.org/manuals/3.9/quickstart_guide.html) - -Alternatively, if you have [Docker](https://www.docker.com/) installed you can bring up all the `collab` dependencies using Docker Compose: - -```sh -docker compose up -d -``` +If you are looking to develop Zed collaboration features using a local collabortation server, please see: [Local Collaboration](./local-collaboration.md) docs. ## Building from source diff --git a/docs/src/development/local-collaboration.md b/docs/src/development/local-collaboration.md index 6c96c342a8..9f0e3ef191 100644 --- a/docs/src/development/local-collaboration.md +++ b/docs/src/development/local-collaboration.md @@ -1,6 +1,6 @@ # Local Collaboration -First, make sure you've installed Zed's backend dependencies for your platform: +First, make sure you've installed Zed's dependencies for your platform: - [macOS](./macos.md#backend-dependencies) - [Linux](./linux.md#backend-dependencies) @@ -8,6 +8,70 @@ First, make sure you've installed Zed's backend dependencies for your platform: Note that `collab` can be compiled only with MSVC toolchain on Windows +## Backend Dependencies + +If you are developing collaborative features of Zed, you'll need to install the dependencies of zed's `collab` server: + +- PostgreSQL +- LiveKit +- Foreman + +You can install these dependencies natively or run them under Docker. + +### MacOS + +1. Install [Postgres.app](https://postgresapp.com) or [postgresql via homebrew](https://formulae.brew.sh/formula/postgresql@15): + + ```sh + brew install postgresql@15 + ``` + +2. Install [Livekit](https://formulae.brew.sh/formula/livekit) and [Foreman](https://formulae.brew.sh/formula/foreman) + + ```sh + brew install livekit foreman + ``` + +- Follow the steps in the [collab README](https://github.com/zed-industries/zed/blob/main/crates/collab/README.md) to configure the Postgres database for integration tests + +Alternatively, if you have [Docker](https://www.docker.com/) installed you can bring up all the `collab` dependencies using Docker Compose: + +### Linux + +1. Install [Postgres](https://www.postgresql.org/download/linux/) + + ```sh + sudo apt-get install postgresql postgresql # Ubuntu/Debian + sudo pacman -S postgresql # Arch Linux + sudo dnf install postgresql postgresql-server # RHEL/Fedora + sudo zypper install postgresql postgresql-server # OpenSUSE + ``` + +2. Install [Livekit](https://github.com/livekit/livekit-cli) + + ```sh + curl -sSL https://get.livekit.io/cli | bash + ``` + +3. Install [Foreman](https://theforeman.org/manuals/3.15/quickstart_guide.html) + +### Windows {#backend-windows} + +> This section is still in development. The instructions are not yet complete. + +- Install [Postgres](https://www.postgresql.org/download/windows/) +- Install [Livekit](https://github.com/livekit/livekit), optionally you can add the `livekit-server` binary to your `PATH`. + +Alternatively, if you have [Docker](https://www.docker.com/) installed you can bring up all the `collab` dependencies using Docker Compose. + +### Docker {#Docker} + +If you have docker or podman available, you can run the backend dependencies inside containers with Docker Compose: + +```sh +docker compose up -d +``` + ## Database setup Before you can run the `collab` server locally, you'll need to set up a `zed` Postgres database. diff --git a/docs/src/development/macos.md b/docs/src/development/macos.md index 91adf78193..f081f0b5f1 100644 --- a/docs/src/development/macos.md +++ b/docs/src/development/macos.md @@ -31,6 +31,10 @@ Clone down the [Zed repository](https://github.com/zed-industries/zed). brew install cmake ``` +### Backend Dependencies (optional) {#backend-dependencies} + +If you are looking to develop Zed collaboration features using a local collabortation server, please see: [Local Collaboration](./local-collaboration.md) docs. + ## Building Zed from Source Once you have the dependencies installed, you can build Zed using [Cargo](https://doc.rust-lang.org/cargo/). @@ -53,25 +57,6 @@ And to run the tests: cargo test --workspace ``` -## Backend Dependencies - -If you are developing collaborative features of Zed, you'll need to install the dependencies of zed's `collab` server: - -- Install [Postgres](https://postgresapp.com) -- Install [Livekit](https://formulae.brew.sh/formula/livekit) and [Foreman](https://formulae.brew.sh/formula/foreman) - - ```sh - brew install livekit foreman - ``` - -- Follow the steps in the [collab README](https://github.com/zed-industries/zed/blob/main/crates/collab/README.md) to configure the Postgres database for integration tests - -Alternatively, if you have [Docker](https://www.docker.com/) installed you can bring up all the `collab` dependencies using Docker Compose: - -```sh -docker compose up -d -``` - ## Troubleshooting ### Error compiling metal shaders diff --git a/docs/src/development/windows.md b/docs/src/development/windows.md index 6d67500aab..ac38e4d7d6 100644 --- a/docs/src/development/windows.md +++ b/docs/src/development/windows.md @@ -66,20 +66,9 @@ The list can be obtained as follows: - Click on `More` in the `Installed` tab - Click on `Export configuration` -## Backend dependencies +### Backend Dependencies (optional) {#backend-dependencies} -> This section is still in development. The instructions are not yet complete. - -If you are developing collaborative features of Zed, you'll need to install the dependencies of zed's `collab` server: - -- Install [Postgres](https://www.postgresql.org/download/windows/) -- Install [Livekit](https://github.com/livekit/livekit), optionally you can add the `livekit-server` binary to your `PATH`. - -Alternatively, if you have [Docker](https://www.docker.com/) installed you can bring up all the `collab` dependencies using Docker Compose: - -```sh -docker compose up -d -``` +If you are looking to develop Zed collaboration features using a local collabortation server, please see: [Local Collaboration](./local-collaboration.md) docs. ### Notes From 2e41e312ad73cb138475c79b5cf8ab3e4a887866 Mon Sep 17 00:00:00 2001 From: Bennet Bo Fenner Date: Sun, 20 Jul 2025 18:27:18 +0200 Subject: [PATCH 0079/1052] component preview: Fix Zed AI onboarding young account preview (#34783) Release Notes: - N/A --- crates/ai_onboarding/src/ai_onboarding.rs | 24 ++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/crates/ai_onboarding/src/ai_onboarding.rs b/crates/ai_onboarding/src/ai_onboarding.rs index 131d385e78..f19b8821fa 100644 --- a/crates/ai_onboarding/src/ai_onboarding.rs +++ b/crates/ai_onboarding/src/ai_onboarding.rs @@ -339,16 +339,18 @@ impl Component for ZedAiOnboarding { plan: Option, account_too_young: bool, ) -> AnyElement { - ZedAiOnboarding { - sign_in_status, - has_accepted_terms_of_service, - plan, - account_too_young, - continue_with_zed_ai: Arc::new(|_, _| {}), - sign_in: Arc::new(|_, _| {}), - accept_terms_of_service: Arc::new(|_, _| {}), - } - .into_any_element() + div() + .w(px(800.)) + .child(ZedAiOnboarding { + sign_in_status, + has_accepted_terms_of_service, + plan, + account_too_young, + continue_with_zed_ai: Arc::new(|_, _| {}), + sign_in: Arc::new(|_, _| {}), + accept_terms_of_service: Arc::new(|_, _| {}), + }) + .into_any_element() } Some( @@ -366,7 +368,7 @@ impl Component for ZedAiOnboarding { ), single_example( "Account too young", - onboarding(SignInStatus::SignedIn, false, None, true), + onboarding(SignInStatus::SignedIn, true, None, true), ), single_example( "Free Plan", From ff79b29f3812e8d39763e51af17c9c13e3ebf8f5 Mon Sep 17 00:00:00 2001 From: Michael Sloan Date: Sun, 20 Jul 2025 13:39:04 -0600 Subject: [PATCH 0080/1052] Set stripe-mock version to `0.178.0` to match stripe API version used (#34786) Release Notes: - N/A --- compose.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compose.yml b/compose.yml index 06e8806d20..d0d9bac425 100644 --- a/compose.yml +++ b/compose.yml @@ -60,7 +60,7 @@ services: - postgres stripe-mock: - image: stripe/stripe-mock:v0.184.0 + image: stripe/stripe-mock:v0.178.0 ports: - 12111:12111 - 12112:12112 From 7c1040bc938df6926a88fc5bce139c4a1ec7e3d0 Mon Sep 17 00:00:00 2001 From: Ben Kunkle Date: Sun, 20 Jul 2025 15:24:17 -0500 Subject: [PATCH 0081/1052] keymap_ui: Auto complete action arguments (#34785) Supersedes: #34242 Creates an `ActionArgumentsEditor` that implements the required logic to have a JSON language server run when editing keybinds so that there is auto-complete for action arguments. This is the first time action argument schemas are required by themselves rather than inlined in the keymap schema. Rather than add all action schemas to the configuration options we send to the JSON LSP on startup, this PR implements support for the `vscode-json-language-server` extension to the LSP whereby the server will request the client (Zed) to resolve URLs with URI schemes it does not recognize, in our case `zed://`. This limits the impact on the size of the configuration options to ~1KB as we send URLs for the language server to resolve on demand rather than the schema itself. My understanding is that this is how VSCode handles JSON schemas as well. I plan to investigate converting the rest of our schema generation logic to this method in a follow up PR. Co-Authored-By: Cole Release Notes: - N/A *or* Added/Fixed/Improved ... --- Cargo.lock | 1 + assets/keymaps/default-macos.json | 1 + crates/languages/src/json.rs | 7 + crates/project/src/lsp_store.rs | 2 + .../src/lsp_store/json_language_server_ext.rs | 101 ++++ crates/settings_ui/Cargo.toml | 1 + crates/settings_ui/src/keybindings.rs | 449 +++++++++++++----- 7 files changed, 453 insertions(+), 109 deletions(-) create mode 100644 crates/project/src/lsp_store/json_language_server_ext.rs diff --git a/Cargo.lock b/Cargo.lock index cbed9f5988..a5ea621cd1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -14768,6 +14768,7 @@ dependencies = [ "serde_json", "settings", "telemetry", + "tempfile", "theme", "tree-sitter-json", "tree-sitter-rust", diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index 6bce3b0f28..ba903c0782 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -1228,6 +1228,7 @@ "context": "KeymapEditor", "use_key_equivalents": true, "bindings": { + "cmd-f": "search::FocusSearch", "cmd-alt-f": "keymap_editor::ToggleKeystrokeSearch", "cmd-alt-c": "keymap_editor::ToggleConflictFilter", "enter": "keymap_editor::EditBinding", diff --git a/crates/languages/src/json.rs b/crates/languages/src/json.rs index 7a3300eb01..15818730b8 100644 --- a/crates/languages/src/json.rs +++ b/crates/languages/src/json.rs @@ -231,6 +231,13 @@ impl JsonLspAdapter { )) } + schemas + .as_array_mut() + .unwrap() + .extend(cx.all_action_names().into_iter().map(|&name| { + project::lsp_store::json_language_server_ext::url_schema_for_action(name) + })); + // This can be viewed via `dev: open language server logs` -> `json-language-server` -> // `Server Info` serde_json::json!({ diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs index e4078393ee..28cbfcdd18 100644 --- a/crates/project/src/lsp_store.rs +++ b/crates/project/src/lsp_store.rs @@ -1,4 +1,5 @@ pub mod clangd_ext; +pub mod json_language_server_ext; pub mod lsp_ext_command; pub mod rust_analyzer_ext; @@ -1034,6 +1035,7 @@ impl LocalLspStore { }) .detach(); + json_language_server_ext::register_requests(this.clone(), language_server); rust_analyzer_ext::register_notifications(this.clone(), language_server); clangd_ext::register_notifications(this, language_server, adapter); } diff --git a/crates/project/src/lsp_store/json_language_server_ext.rs b/crates/project/src/lsp_store/json_language_server_ext.rs new file mode 100644 index 0000000000..3eb93386a9 --- /dev/null +++ b/crates/project/src/lsp_store/json_language_server_ext.rs @@ -0,0 +1,101 @@ +use anyhow::Context as _; +use collections::HashMap; +use gpui::WeakEntity; +use lsp::LanguageServer; + +use crate::LspStore; +/// https://github.com/Microsoft/vscode/blob/main/extensions/json-language-features/server/README.md#schema-content-request +/// +/// Represents a "JSON language server-specific, non-standardized, extension to the LSP" with which the vscode-json-language-server +/// can request the contents of a schema that is associated with a uri scheme it does not support. +/// In our case, we provide the uris for actions on server startup under the `zed://schemas/action/{normalize_action_name}` scheme. +/// We can then respond to this request with the schema content on demand, thereby greatly reducing the total size of the JSON we send to the server on startup +struct SchemaContentRequest {} + +impl lsp::request::Request for SchemaContentRequest { + type Params = Vec; + + type Result = String; + + const METHOD: &'static str = "vscode/content"; +} + +pub fn register_requests(_lsp_store: WeakEntity, language_server: &LanguageServer) { + language_server + .on_request::(|params, cx| { + // PERF: Use a cache (`OnceLock`?) to avoid recomputing the action schemas + let mut generator = settings::KeymapFile::action_schema_generator(); + let all_schemas = cx.update(|cx| HashMap::from_iter(cx.action_schemas(&mut generator))); + async move { + let all_schemas = all_schemas?; + let Some(uri) = params.get(0) else { + anyhow::bail!("No URI"); + }; + let normalized_action_name = uri + .strip_prefix("zed://schemas/action/") + .context("Invalid URI")?; + let action_name = denormalize_action_name(normalized_action_name); + let schema = root_schema_from_action_schema( + all_schemas + .get(action_name.as_str()) + .and_then(Option::as_ref), + &mut generator, + ) + .to_value(); + + serde_json::to_string(&schema).context("Failed to serialize schema") + } + }) + .detach(); +} + +pub fn normalize_action_name(action_name: &str) -> String { + action_name.replace("::", "__") +} + +pub fn denormalize_action_name(action_name: &str) -> String { + action_name.replace("__", "::") +} + +pub fn normalized_action_file_name(action_name: &str) -> String { + normalized_action_name_to_file_name(normalize_action_name(action_name)) +} + +pub fn normalized_action_name_to_file_name(mut normalized_action_name: String) -> String { + normalized_action_name.push_str(".json"); + normalized_action_name +} + +pub fn url_schema_for_action(action_name: &str) -> serde_json::Value { + let normalized_name = normalize_action_name(action_name); + let file_name = normalized_action_name_to_file_name(normalized_name.clone()); + serde_json::json!({ + "fileMatch": [file_name], + "url": format!("zed://schemas/action/{}", normalized_name) + }) +} + +fn root_schema_from_action_schema( + action_schema: Option<&schemars::Schema>, + generator: &mut schemars::SchemaGenerator, +) -> schemars::Schema { + let Some(action_schema) = action_schema else { + return schemars::json_schema!(false); + }; + let meta_schema = generator + .settings() + .meta_schema + .as_ref() + .expect("meta_schema should be present in schemars settings") + .to_string(); + let defs = generator.definitions(); + let mut schema = schemars::json_schema!({ + "$schema": meta_schema, + "allowTrailingCommas": true, + "$defs": defs, + }); + schema + .ensure_object() + .extend(std::mem::take(action_schema.clone().ensure_object())); + schema +} diff --git a/crates/settings_ui/Cargo.toml b/crates/settings_ui/Cargo.toml index e512c4e4d4..651397dd51 100644 --- a/crates/settings_ui/Cargo.toml +++ b/crates/settings_ui/Cargo.toml @@ -35,6 +35,7 @@ serde.workspace = true serde_json.workspace = true settings.workspace = true telemetry.workspace = true +tempfile.workspace = true theme.workspace = true tree-sitter-json.workspace = true tree-sitter-rust.workspace = true diff --git a/crates/settings_ui/src/keybindings.rs b/crates/settings_ui/src/keybindings.rs index 1a5bb7b459..5f940e8a25 100644 --- a/crates/settings_ui/src/keybindings.rs +++ b/crates/settings_ui/src/keybindings.rs @@ -13,11 +13,13 @@ use gpui::{ Action, Animation, AnimationExt, AppContext as _, AsyncApp, Axis, ClickEvent, Context, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, FontWeight, Global, IsZero, KeyContext, Keystroke, Modifiers, ModifiersChangedEvent, MouseButton, Point, ScrollStrategy, - ScrollWheelEvent, StyledText, Subscription, Task, WeakEntity, actions, anchored, deferred, div, + ScrollWheelEvent, StyledText, Subscription, Task, TextStyleRefinement, WeakEntity, actions, + anchored, deferred, div, }; use language::{Language, LanguageConfig, ToOffset as _}; use notifications::status_toast::{StatusToast, ToastIcon}; -use settings::{BaseKeymap, KeybindSource, KeymapFile, SettingsAssets}; +use project::Project; +use settings::{BaseKeymap, KeybindSource, KeymapFile, Settings as _, SettingsAssets}; use util::ResultExt; @@ -283,6 +285,14 @@ struct KeymapEditor { previous_edit: Option, humanized_action_names: HumanizedActionNameCache, show_hover_menus: bool, + /// In order for the JSON LSP to run in the actions arguments editor, we + /// require a backing file In order to avoid issues (primarily log spam) + /// with drop order between the buffer, file, worktree, etc, we create a + /// temporary directory for these backing files in the keymap editor struct + /// instead of here. This has the added benefit of only having to create a + /// worktree and directory once, although the perf improvement is negligible. + action_args_temp_dir_worktree: Option>, + action_args_temp_dir: Option, } enum PreviousEdit { @@ -307,13 +317,18 @@ impl EventEmitter<()> for KeymapEditor {} impl Focusable for KeymapEditor { fn focus_handle(&self, cx: &App) -> gpui::FocusHandle { - return self.filter_editor.focus_handle(cx); + if self.selected_index.is_some() { + self.focus_handle.clone() + } else { + self.filter_editor.focus_handle(cx) + } } } impl KeymapEditor { fn new(workspace: WeakEntity, window: &mut Window, cx: &mut Context) -> Self { - let _keymap_subscription = cx.observe_global::(Self::on_keymap_changed); + let _keymap_subscription = + cx.observe_global_in::(window, Self::on_keymap_changed); let table_interaction_state = TableInteractionState::new(window, cx); let keystroke_editor = cx.new(|cx| { @@ -346,6 +361,24 @@ impl KeymapEditor { }) .detach(); + cx.spawn({ + let workspace = workspace.clone(); + async move |this, cx| { + let temp_dir = tempfile::tempdir_in(paths::temp_dir())?; + let worktree = workspace + .update(cx, |ws, cx| { + ws.project() + .update(cx, |p, cx| p.create_worktree(temp_dir.path(), false, cx)) + })? + .await?; + this.update(cx, |this, _| { + this.action_args_temp_dir = Some(temp_dir); + this.action_args_temp_dir_worktree = Some(worktree); + }) + } + }) + .detach(); + let mut this = Self { workspace, keybindings: vec![], @@ -365,9 +398,11 @@ impl KeymapEditor { search_query_debounce: None, humanized_action_names: HumanizedActionNameCache::new(cx), show_hover_menus: true, + action_args_temp_dir: None, + action_args_temp_dir_worktree: None, }; - this.on_keymap_changed(cx); + this.on_keymap_changed(window, cx); this } @@ -557,10 +592,10 @@ impl KeymapEditor { HashSet::from_iter(cx.all_action_names().into_iter().copied()); let action_documentation = cx.action_documentation(); let mut generator = KeymapFile::action_schema_generator(); - let action_schema = HashMap::from_iter( + let actions_with_schemas = HashSet::from_iter( cx.action_schemas(&mut generator) .into_iter() - .filter_map(|(name, schema)| schema.map(|schema| (name, schema))), + .filter_map(|(name, schema)| schema.is_some().then_some(name)), ); let mut processed_bindings = Vec::new(); @@ -607,7 +642,7 @@ impl KeymapEditor { action_arguments, humanized_action_name, action_docs, - action_schema: action_schema.get(action_name).cloned(), + has_schema: actions_with_schemas.contains(action_name), context: Some(context), source, }); @@ -626,7 +661,7 @@ impl KeymapEditor { action_arguments: None, humanized_action_name, action_docs: action_documentation.get(action_name).copied(), - action_schema: action_schema.get(action_name).cloned(), + has_schema: actions_with_schemas.contains(action_name), context: None, source: None, }); @@ -636,9 +671,9 @@ impl KeymapEditor { (processed_bindings, string_match_candidates) } - fn on_keymap_changed(&mut self, cx: &mut Context) { + fn on_keymap_changed(&mut self, window: &mut Window, cx: &mut Context) { let workspace = self.workspace.clone(); - cx.spawn(async move |this, cx| { + cx.spawn_in(window, async move |this, cx| { let json_language = load_json_language(workspace.clone(), cx).await; let zed_keybind_context_language = load_keybind_context_language(workspace.clone(), cx).await; @@ -673,7 +708,7 @@ impl KeymapEditor { })?; // calls cx.notify Self::update_matches(this.clone(), action_query, keystroke_query, cx).await?; - this.update(cx, |this, cx| { + this.update_in(cx, |this, window, cx| { if let Some(previous_edit) = this.previous_edit.take() { match previous_edit { // should remove scroll from process_query @@ -701,8 +736,12 @@ impl KeymapEditor { }); if let Some(scroll_position) = scroll_position { - this.scroll_to_item(scroll_position, ScrollStrategy::Top, cx); - this.selected_index = Some(scroll_position); + this.select_index( + scroll_position, + Some(ScrollStrategy::Top), + window, + cx, + ); } else { this.table_interaction_state.update(cx, |table, _| { table.set_scrollbar_offset(Axis::Vertical, fallback) @@ -768,9 +807,19 @@ impl KeymapEditor { .and_then(|keybind_index| self.keybindings.get(keybind_index)) } - fn select_index(&mut self, index: usize, cx: &mut Context) { + fn select_index( + &mut self, + index: usize, + scroll: Option, + window: &mut Window, + cx: &mut Context, + ) { if self.selected_index != Some(index) { self.selected_index = Some(index); + if let Some(scroll_strategy) = scroll { + self.scroll_to_item(index, scroll_strategy, cx); + } + window.focus(&self.focus_handle); cx.notify(); } } @@ -872,9 +921,7 @@ impl KeymapEditor { if selected >= self.matches.len() { self.select_last(&Default::default(), window, cx); } else { - self.selected_index = Some(selected); - self.scroll_to_item(selected, ScrollStrategy::Center, cx); - cx.notify(); + self.select_index(selected, Some(ScrollStrategy::Center), window, cx); } } else { self.select_first(&Default::default(), window, cx); @@ -898,36 +945,25 @@ impl KeymapEditor { if selected >= self.matches.len() { self.select_last(&Default::default(), window, cx); } else { - self.selected_index = Some(selected); - self.scroll_to_item(selected, ScrollStrategy::Center, cx); - cx.notify(); + self.select_index(selected, Some(ScrollStrategy::Center), window, cx); } } else { self.select_last(&Default::default(), window, cx); } } - fn select_first( - &mut self, - _: &menu::SelectFirst, - _window: &mut Window, - cx: &mut Context, - ) { + fn select_first(&mut self, _: &menu::SelectFirst, window: &mut Window, cx: &mut Context) { self.show_hover_menus = false; if self.matches.get(0).is_some() { - self.selected_index = Some(0); - self.scroll_to_item(0, ScrollStrategy::Center, cx); - cx.notify(); + self.select_index(0, Some(ScrollStrategy::Center), window, cx); } } - fn select_last(&mut self, _: &menu::SelectLast, _window: &mut Window, cx: &mut Context) { + fn select_last(&mut self, _: &menu::SelectLast, window: &mut Window, cx: &mut Context) { self.show_hover_menus = false; if self.matches.last().is_some() { let index = self.matches.len() - 1; - self.selected_index = Some(index); - self.scroll_to_item(index, ScrollStrategy::Center, cx); - cx.notify(); + self.select_index(index, Some(ScrollStrategy::Center), window, cx); } } @@ -963,6 +999,8 @@ impl KeymapEditor { arguments = arguments, ); + let temp_dir = self.action_args_temp_dir.as_ref().map(|dir| dir.path()); + self.workspace .update(cx, |workspace, cx| { let fs = workspace.app_state().fs.clone(); @@ -973,6 +1011,7 @@ impl KeymapEditor { keybind, keybind_index, keymap_editor, + temp_dir, workspace_weak, fs, window, @@ -1134,7 +1173,7 @@ struct ProcessedKeybinding { humanized_action_name: SharedString, action_arguments: Option, action_docs: Option<&'static str>, - action_schema: Option, + has_schema: bool, context: Option, source: Option<(KeybindSource, SharedString)>, } @@ -1428,7 +1467,7 @@ impl Render for KeymapEditor { cx, ); } else { - this.select_index(index, cx); + this.select_index(index, None, window, cx); this.open_edit_keybinding_modal( false, window, cx, ); @@ -1458,7 +1497,7 @@ impl Render for KeymapEditor { }, ) .on_click(cx.listener(move |this, _, window, cx| { - this.select_index(index, cx); + this.select_index(index, None, window, cx); this.open_edit_keybinding_modal(false, window, cx); cx.stop_propagation(); })) @@ -1506,7 +1545,7 @@ impl Render for KeymapEditor { let action_arguments = match binding.action_arguments.clone() { Some(arguments) => arguments.into_any_element(), None => { - if binding.action_schema.is_some() { + if binding.has_schema { muted_styled_text(NO_ACTION_ARGUMENTS_TEXT, cx) .into_any_element() } else { @@ -1571,7 +1610,7 @@ impl Render for KeymapEditor { cx| { match mouse_down_event.button { MouseButton::Right => { - this.select_index(row_index, cx); + this.select_index(row_index, None, window, cx); this.create_context_menu( mouse_down_event.position, window, @@ -1584,7 +1623,7 @@ impl Render for KeymapEditor { )) .on_click(cx.listener( move |this, event: &ClickEvent, window, cx| { - this.select_index(row_index, cx); + this.select_index(row_index, None, window, cx); if event.up.click_count == 2 { this.open_edit_keybinding_modal(false, window, cx); } @@ -1686,23 +1725,23 @@ impl RenderOnce for SyntaxHighlightedText { } #[derive(PartialEq)] -enum InputError { - Warning(SharedString), - Error(SharedString), +struct InputError { + severity: ui::Severity, + content: SharedString, } impl InputError { fn warning(message: impl Into) -> Self { - Self::Warning(message.into()) + Self { + severity: ui::Severity::Warning, + content: message.into(), + } } - fn error(error: anyhow::Error) -> Self { - Self::Error(error.to_string().into()) - } - - fn content(&self) -> &SharedString { - match self { - InputError::Warning(content) | InputError::Error(content) => content, + fn error(message: anyhow::Error) -> Self { + Self { + severity: ui::Severity::Error, + content: message.to_string().into(), } } } @@ -1713,7 +1752,7 @@ struct KeybindingEditorModal { editing_keybind_idx: usize, keybind_editor: Entity, context_editor: Entity, - action_arguments_editor: Option>, + action_arguments_editor: Option>, fs: Arc, error: Option, keymap_editor: Entity, @@ -1737,6 +1776,7 @@ impl KeybindingEditorModal { editing_keybind: ProcessedKeybinding, editing_keybind_idx: usize, keymap_editor: Entity, + action_args_temp_dir: Option<&std::path::Path>, workspace: WeakEntity, fs: Arc, window: &mut Window, @@ -1786,40 +1826,29 @@ impl KeybindingEditorModal { input }); - let action_arguments_editor = editing_keybind.action_schema.clone().map(|_schema| { + let action_arguments_editor = editing_keybind.has_schema.then(|| { + let arguments = editing_keybind + .action_arguments + .as_ref() + .map(|args| args.text.clone()); cx.new(|cx| { - let mut editor = Editor::auto_height_unbounded(1, window, cx); - let workspace = workspace.clone(); - - if let Some(arguments) = editing_keybind.action_arguments.clone() { - editor.set_text(arguments.text, window, cx); - } else { - // TODO: default value from schema? - editor.set_placeholder_text("Action Arguments", cx); - } - cx.spawn(async |editor, cx| { - let json_language = load_json_language(workspace, cx).await; - editor - .update(cx, |editor, cx| { - if let Some(buffer) = editor.buffer().read(cx).as_singleton() { - buffer.update(cx, |buffer, cx| { - buffer.set_language(Some(json_language), cx) - }); - } - }) - .context("Failed to load JSON language for editing keybinding action arguments input") - }) - .detach_and_log_err(cx); - editor + ActionArgumentsEditor::new( + editing_keybind.action_name, + arguments, + action_args_temp_dir, + workspace.clone(), + window, + cx, + ) }) }); let focus_state = KeybindingEditorModalFocusState::new( - keybind_editor.read_with(cx, |keybind_editor, cx| keybind_editor.focus_handle(cx)), - action_arguments_editor.as_ref().map(|args_editor| { - args_editor.read_with(cx, |args_editor, cx| args_editor.focus_handle(cx)) - }), - context_editor.read_with(cx, |context_editor, cx| context_editor.focus_handle(cx)), + keybind_editor.focus_handle(cx), + action_arguments_editor + .as_ref() + .map(|args_editor| args_editor.focus_handle(cx)), + context_editor.focus_handle(cx), ); Self { @@ -1837,14 +1866,15 @@ impl KeybindingEditorModal { } } - fn set_error(&mut self, error: InputError, cx: &mut Context) { - if self - .error - .as_ref() - .is_none_or(|old_error| *old_error != error) - { + fn set_error(&mut self, error: InputError, cx: &mut Context) -> bool { + if self.error.as_ref().is_some_and(|old_error| { + old_error.severity == ui::Severity::Warning && *old_error == error + }) { + false + } else { self.error = Some(error); cx.notify(); + true } } @@ -1852,7 +1882,7 @@ impl KeybindingEditorModal { let action_arguments = self .action_arguments_editor .as_ref() - .map(|editor| editor.read(cx).text(cx)); + .map(|editor| editor.read(cx).editor.read(cx).text(cx)); let value = action_arguments .as_ref() @@ -1938,7 +1968,7 @@ impl KeybindingEditorModal { let warning_message = match conflicting_action_name { Some(name) => { - if remaining_conflict_amount > 0 { + if remaining_conflict_amount > 0 { format!( "Your keybind would conflict with the \"{}\" action and {} other bindings", name, remaining_conflict_amount @@ -2108,38 +2138,21 @@ impl Render for KeybindingEditorModal { .mt_1p5() .gap_1() .child(Label::new("Edit Arguments")) - .child( - div() - .w_full() - .py_1() - .px_1p5() - .rounded_lg() - .bg(theme.editor_background) - .border_1() - .border_color(theme.border_variant) - .child(editor), - ), + .child(editor), ) }) .child(self.context_editor.clone()) .when_some(self.error.as_ref(), |this, error| { this.child( Banner::new() - .map(|banner| match error { - InputError::Error(_) => { - banner.severity(ui::Severity::Error) - } - InputError::Warning(_) => { - banner.severity(ui::Severity::Warning) - } - }) + .severity(error.severity) // For some reason, the div overflows its container to the //right. The padding accounts for that. .child( div() .size_full() .pr_2() - .child(Label::new(error.content())), + .child(Label::new(error.content.clone())), ), ) }), @@ -2219,6 +2232,219 @@ impl KeybindingEditorModalFocusState { } } +struct ActionArgumentsEditor { + editor: Entity, + focus_handle: FocusHandle, + is_loading: bool, + /// See documentation in `KeymapEditor` for why a temp dir is needed. + /// This field exists because the keymap editor temp dir creation may fail, + /// and rather than implement a complicated retry mechanism, we simply + /// fallback to trying to create a temporary directory in this editor on + /// demand. Of note is that the TempDir struct will remove the directory + /// when dropped. + backup_temp_dir: Option, +} + +impl Focusable for ActionArgumentsEditor { + fn focus_handle(&self, _cx: &App) -> FocusHandle { + self.focus_handle.clone() + } +} + +impl ActionArgumentsEditor { + fn new( + action_name: &'static str, + arguments: Option, + temp_dir: Option<&std::path::Path>, + workspace: WeakEntity, + window: &mut Window, + cx: &mut Context, + ) -> Self { + let focus_handle = cx.focus_handle(); + cx.on_focus_in(&focus_handle, window, |this, window, cx| { + this.editor.focus_handle(cx).focus(window); + }) + .detach(); + let editor = cx.new(|cx| { + let mut editor = Editor::auto_height_unbounded(1, window, cx); + Self::set_editor_text(&mut editor, arguments.clone(), window, cx); + editor.set_read_only(true); + editor + }); + + let temp_dir = temp_dir.map(|path| path.to_owned()); + cx.spawn_in(window, async move |this, cx| { + let result = async { + let (project, fs) = workspace.read_with(cx, |workspace, _cx| { + ( + workspace.project().downgrade(), + workspace.app_state().fs.clone(), + ) + })?; + + let file_name = project::lsp_store::json_language_server_ext::normalized_action_file_name(action_name); + + let (buffer, backup_temp_dir) = Self::create_temp_buffer(temp_dir, file_name.clone(), project.clone(), fs, cx).await.context("Failed to create temporary buffer for action arguments. Auto-complete will not work") + ?; + + let editor = cx.new_window_entity(|window, cx| { + let multi_buffer = cx.new(|cx| editor::MultiBuffer::singleton(buffer, cx)); + let mut editor = Editor::new(editor::EditorMode::Full { scale_ui_elements_with_buffer_font_size: true, show_active_line_background: false, sized_by_content: true },multi_buffer, project.upgrade(), window, cx); + editor.set_searchable(false); + editor.disable_scrollbars_and_minimap(window, cx); + editor.set_show_edit_predictions(Some(false), window, cx); + editor.set_show_gutter(false, cx); + Self::set_editor_text(&mut editor, arguments, window, cx); + editor + })?; + + this.update_in(cx, |this, window, cx| { + if this.editor.focus_handle(cx).is_focused(window) { + editor.focus_handle(cx).focus(window); + } + this.editor = editor; + this.backup_temp_dir = backup_temp_dir; + this.is_loading = false; + })?; + + anyhow::Ok(()) + }.await; + if result.is_err() { + let json_language = load_json_language(workspace.clone(), cx).await; + this.update(cx, |this, cx| { + this.editor.update(cx, |editor, cx| { + if let Some(buffer) = editor.buffer().read(cx).as_singleton() { + buffer.update(cx, |buffer, cx| { + buffer.set_language(Some(json_language.clone()), cx) + }); + } + }) + // .context("Failed to load JSON language for editing keybinding action arguments input") + }).ok(); + this.update(cx, |this, _cx| { + this.is_loading = false; + }).ok(); + } + return result; + }) + .detach_and_log_err(cx); + Self { + editor, + focus_handle, + is_loading: true, + backup_temp_dir: None, + } + } + + fn set_editor_text( + editor: &mut Editor, + arguments: Option, + window: &mut Window, + cx: &mut Context, + ) { + if let Some(arguments) = arguments { + editor.set_text(arguments, window, cx); + } else { + // TODO: default value from schema? + editor.set_placeholder_text("Action Arguments", cx); + } + } + + async fn create_temp_buffer( + temp_dir: Option, + file_name: String, + project: WeakEntity, + fs: Arc, + cx: &mut AsyncApp, + ) -> anyhow::Result<(Entity, Option)> { + let (temp_file_path, temp_dir) = { + let file_name = file_name.clone(); + async move { + let temp_dir_backup = match temp_dir.as_ref() { + Some(_) => None, + None => { + let temp_dir = paths::temp_dir(); + let sub_temp_dir = tempfile::Builder::new() + .tempdir_in(temp_dir) + .context("Failed to create temporary directory")?; + Some(sub_temp_dir) + } + }; + let dir_path = temp_dir.as_deref().unwrap_or_else(|| { + temp_dir_backup + .as_ref() + .expect("created backup tempdir") + .path() + }); + let path = dir_path.join(file_name); + fs.create_file( + &path, + fs::CreateOptions { + ignore_if_exists: true, + overwrite: true, + }, + ) + .await + .context("Failed to create temporary file")?; + anyhow::Ok((path, temp_dir_backup)) + } + } + .await + .context("Failed to create backing file")?; + + project + .update(cx, |project, cx| { + project.open_local_buffer(temp_file_path, cx) + })? + .await + .context("Failed to create buffer") + .map(|buffer| (buffer, temp_dir)) + } +} + +impl Render for ActionArgumentsEditor { + fn render(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement { + let background_color; + let border_color; + let text_style = { + let colors = cx.theme().colors(); + let settings = theme::ThemeSettings::get_global(cx); + background_color = colors.editor_background; + border_color = if self.is_loading { + colors.border_disabled + } else { + colors.border_variant + }; + TextStyleRefinement { + font_size: Some(rems(0.875).into()), + font_weight: Some(settings.buffer_font.weight), + line_height: Some(relative(1.2)), + font_style: Some(gpui::FontStyle::Normal), + color: self.is_loading.then_some(colors.text_disabled), + ..Default::default() + } + }; + + self.editor + .update(cx, |editor, _| editor.set_text_style_refinement(text_style)); + + return v_flex().w_full().child( + h_flex() + .min_h_8() + .min_w_48() + .px_2() + .py_1p5() + .flex_grow() + .rounded_lg() + .bg(background_color) + .border_1() + .border_color(border_color) + .track_focus(&self.focus_handle) + .child(self.editor.clone()), + ); + } +} + struct KeyContextCompletionProvider { contexts: Vec, } @@ -2643,6 +2869,11 @@ impl KeystrokeInput { { if self.search { last.key = keystroke.key.clone(); + if close_keystroke_result == CloseKeystrokeResult::Partial + && self.close_keystrokes_start.is_none() + { + self.close_keystrokes_start = Some(self.keystrokes.len() - 1); + } self.keystrokes_changed(cx); cx.stop_propagation(); return; From 137081f050c766cc2f5a3fbf913a12453912e35d Mon Sep 17 00:00:00 2001 From: Michael Sloan Date: Sun, 20 Jul 2025 17:22:13 -0600 Subject: [PATCH 0082/1052] Misc code cleanups accumulated while working on other changes (#34787) Release Notes: - N/A --- crates/command_palette/src/command_palette.rs | 2 +- crates/dap/src/registry.rs | 1 + crates/gpui/examples/set_menus.rs | 2 +- crates/gpui/src/app.rs | 4 +++- .../src/migrations/m_2025_04_15/keymap.rs | 2 +- crates/theme/src/schema.rs | 18 ++---------------- crates/util/src/schemars.rs | 1 - 7 files changed, 9 insertions(+), 21 deletions(-) diff --git a/crates/command_palette/src/command_palette.rs b/crates/command_palette/src/command_palette.rs index abb8978d5a..dfaede0dc4 100644 --- a/crates/command_palette/src/command_palette.rs +++ b/crates/command_palette/src/command_palette.rs @@ -242,7 +242,7 @@ impl CommandPaletteDelegate { self.selected_ix = cmp::min(self.selected_ix, self.matches.len() - 1); } } - /// + /// Hit count for each command in the palette. /// We only account for commands triggered directly via command palette and not by e.g. keystrokes because /// if a user already knows a keystroke for a command, they are unlikely to use a command palette to look for it. diff --git a/crates/dap/src/registry.rs b/crates/dap/src/registry.rs index 9435b16b92..d56e2f8f34 100644 --- a/crates/dap/src/registry.rs +++ b/crates/dap/src/registry.rs @@ -46,6 +46,7 @@ impl DapRegistry { let name = adapter.name(); let _previous_value = self.0.write().adapters.insert(name, adapter); } + pub fn add_locator(&self, locator: Arc) { self.0.write().locators.insert(locator.name(), locator); } diff --git a/crates/gpui/examples/set_menus.rs b/crates/gpui/examples/set_menus.rs index 2b302f78f2..f53fff7c7f 100644 --- a/crates/gpui/examples/set_menus.rs +++ b/crates/gpui/examples/set_menus.rs @@ -34,7 +34,7 @@ fn main() { }); } -// Associate actions using the `actions!` macro (or `impl_actions!` macro) +// Associate actions using the `actions!` macro (or `Action` derive macro) actions!(set_menus, [Quit]); // Define the quit function that is registered with the App diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs index 70e1d1e4cd..de7ba782b2 100644 --- a/crates/gpui/src/app.rs +++ b/crates/gpui/src/app.rs @@ -1370,7 +1370,9 @@ impl App { self.keymap.clone() } - /// Register a global listener for actions invoked via the keyboard. + /// Register a global handler for actions invoked via the keyboard. These handlers are run at + /// the end of the bubble phase for actions, and so will only be invoked if there are no other + /// handlers or if they called `cx.propagate()`. pub fn on_action(&mut self, listener: impl Fn(&A, &mut Self) + 'static) { self.global_action_listeners .entry(TypeId::of::()) diff --git a/crates/migrator/src/migrations/m_2025_04_15/keymap.rs b/crates/migrator/src/migrations/m_2025_04_15/keymap.rs index d1443a922a..efbdc6b1c6 100644 --- a/crates/migrator/src/migrations/m_2025_04_15/keymap.rs +++ b/crates/migrator/src/migrations/m_2025_04_15/keymap.rs @@ -25,7 +25,7 @@ fn replace_string_action( None } -/// "ctrl-k ctrl-1": "inline_completion::ToggleMenu" -> "edit_prediction::ToggleMenu" +/// "space": "outline_panel::Open" -> "outline_panel::OpenSelectedEntry" static STRING_REPLACE: LazyLock> = LazyLock::new(|| { HashMap::from_iter([("outline_panel::Open", "outline_panel::OpenSelectedEntry")]) }); diff --git a/crates/theme/src/schema.rs b/crates/theme/src/schema.rs index b2a13b54b6..bed25d0c05 100644 --- a/crates/theme/src/schema.rs +++ b/crates/theme/src/schema.rs @@ -4,11 +4,10 @@ use anyhow::Result; use gpui::{FontStyle, FontWeight, HighlightStyle, Hsla, WindowBackgroundAppearance}; use indexmap::IndexMap; use palette::FromColor; -use schemars::{JsonSchema, json_schema}; +use schemars::{JsonSchema, JsonSchema_repr}; use serde::{Deserialize, Deserializer, Serialize}; use serde_json::Value; use serde_repr::{Deserialize_repr, Serialize_repr}; -use std::borrow::Cow; use crate::{StatusColorsRefinement, ThemeColorsRefinement}; @@ -1486,7 +1485,7 @@ impl From for FontStyle { } } -#[derive(Debug, Clone, Copy, Serialize_repr, Deserialize_repr, PartialEq)] +#[derive(Debug, Clone, Copy, Serialize_repr, Deserialize_repr, JsonSchema_repr, PartialEq)] #[repr(u16)] pub enum FontWeightContent { Thin = 100, @@ -1500,19 +1499,6 @@ pub enum FontWeightContent { Black = 900, } -impl JsonSchema for FontWeightContent { - fn schema_name() -> Cow<'static, str> { - "FontWeightContent".into() - } - - fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema { - json_schema!({ - "type": "integer", - "enum": [100, 200, 300, 400, 500, 600, 700, 800, 900] - }) - } -} - impl From for FontWeight { fn from(value: FontWeightContent) -> Self { match value { diff --git a/crates/util/src/schemars.rs b/crates/util/src/schemars.rs index 4d8ab530dd..e162b41933 100644 --- a/crates/util/src/schemars.rs +++ b/crates/util/src/schemars.rs @@ -15,7 +15,6 @@ pub fn replace_subschema( generator: &mut schemars::SchemaGenerator, schema: impl Fn() -> schemars::Schema, ) -> schemars::Schema { - // fallback on just using the schema name, which could collide. let schema_name = T::schema_name(); let definitions = generator.definitions_mut(); assert!(!definitions.contains_key(&format!("{schema_name}2"))); From caa4b529e4b130006990a31b4908e4252aa96fe4 Mon Sep 17 00:00:00 2001 From: Jason Lee Date: Mon, 21 Jul 2025 07:38:54 +0800 Subject: [PATCH 0083/1052] gpui: Add tab focus support (#33008) Release Notes: - N/A With a `tab_index` and `tab_stop` option to `FocusHandle` to us can switch focus by `Tab`, `Shift-Tab`. The `tab_index` is from [WinUI](https://learn.microsoft.com/en-us/uwp/api/windows.ui.xaml.controls.control.tabindex?view=winrt-26100) and [HTML tabindex](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/tabindex), only the `tab_stop` is enabled that can be added into the `tab_handles` list. - Added `window.focus_next()` and `window.focus_previous()` method to switch focus. - Added `tab_index` to `InteractiveElement`. ```bash cargo run -p gpui --example tab_stop ``` https://github.com/user-attachments/assets/ac4e3e49-8359-436c-9a6e-badba2225211 --- crates/gpui/examples/tab_stop.rs | 130 +++++++++++++++++++++++++ crates/gpui/src/app.rs | 4 +- crates/gpui/src/elements/div.rs | 29 ++++-- crates/gpui/src/gpui.rs | 2 + crates/gpui/src/tab_stop.rs | 157 +++++++++++++++++++++++++++++++ crates/gpui/src/window.rs | 81 ++++++++++++++-- 6 files changed, 387 insertions(+), 16 deletions(-) create mode 100644 crates/gpui/examples/tab_stop.rs create mode 100644 crates/gpui/src/tab_stop.rs diff --git a/crates/gpui/examples/tab_stop.rs b/crates/gpui/examples/tab_stop.rs new file mode 100644 index 0000000000..9c58b52a5e --- /dev/null +++ b/crates/gpui/examples/tab_stop.rs @@ -0,0 +1,130 @@ +use gpui::{ + App, Application, Bounds, Context, Div, ElementId, FocusHandle, KeyBinding, SharedString, + Stateful, Window, WindowBounds, WindowOptions, actions, div, prelude::*, px, size, +}; + +actions!(example, [Tab, TabPrev]); + +struct Example { + items: Vec, + message: SharedString, +} + +impl Example { + fn new(window: &mut Window, cx: &mut Context) -> Self { + let items = vec![ + cx.focus_handle().tab_index(1).tab_stop(true), + cx.focus_handle().tab_index(2).tab_stop(true), + cx.focus_handle().tab_index(3).tab_stop(true), + cx.focus_handle(), + cx.focus_handle().tab_index(2).tab_stop(true), + ]; + + window.focus(items.first().unwrap()); + Self { + items, + message: SharedString::from("Press `Tab`, `Shift-Tab` to switch focus."), + } + } + + fn on_tab(&mut self, _: &Tab, window: &mut Window, _: &mut Context) { + window.focus_next(); + self.message = SharedString::from("You have pressed `Tab`."); + } + + fn on_tab_prev(&mut self, _: &TabPrev, window: &mut Window, _: &mut Context) { + window.focus_prev(); + self.message = SharedString::from("You have pressed `Shift-Tab`."); + } +} + +impl Render for Example { + fn render(&mut self, window: &mut Window, cx: &mut Context) -> impl IntoElement { + fn button(id: impl Into) -> Stateful

{ + div() + .id(id) + .h_10() + .flex_1() + .flex() + .justify_center() + .items_center() + .border_1() + .border_color(gpui::black()) + .bg(gpui::black()) + .text_color(gpui::white()) + .focus(|this| this.border_color(gpui::blue())) + .shadow_sm() + } + + div() + .id("app") + .on_action(cx.listener(Self::on_tab)) + .on_action(cx.listener(Self::on_tab_prev)) + .size_full() + .flex() + .flex_col() + .p_4() + .gap_3() + .bg(gpui::white()) + .text_color(gpui::black()) + .child(self.message.clone()) + .children( + self.items + .clone() + .into_iter() + .enumerate() + .map(|(ix, item_handle)| { + div() + .id(("item", ix)) + .track_focus(&item_handle) + .h_10() + .w_full() + .flex() + .justify_center() + .items_center() + .border_1() + .border_color(gpui::black()) + .when( + item_handle.tab_stop && item_handle.is_focused(window), + |this| this.border_color(gpui::blue()), + ) + .map(|this| match item_handle.tab_stop { + true => this + .hover(|this| this.bg(gpui::black().opacity(0.1))) + .child(format!("tab_index: {}", item_handle.tab_index)), + false => this.opacity(0.4).child("tab_stop: false"), + }) + }), + ) + .child( + div() + .flex() + .flex_row() + .gap_3() + .items_center() + .child(button("el1").tab_index(4).child("Button 1")) + .child(button("el2").tab_index(5).child("Button 2")), + ) + } +} + +fn main() { + Application::new().run(|cx: &mut App| { + cx.bind_keys([ + KeyBinding::new("tab", Tab, None), + KeyBinding::new("shift-tab", TabPrev, None), + ]); + + let bounds = Bounds::centered(None, size(px(800.), px(600.0)), cx); + cx.open_window( + WindowOptions { + window_bounds: Some(WindowBounds::Windowed(bounds)), + ..Default::default() + }, + |window, cx| cx.new(|cx| Example::new(window, cx)), + ) + .unwrap(); + + cx.activate(true); + }); +} diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs index de7ba782b2..2771de9aac 100644 --- a/crates/gpui/src/app.rs +++ b/crates/gpui/src/app.rs @@ -954,8 +954,8 @@ impl App { self.focus_handles .clone() .write() - .retain(|handle_id, count| { - if count.load(SeqCst) == 0 { + .retain(|handle_id, focus| { + if focus.ref_count.load(SeqCst) == 0 { for window_handle in self.windows() { window_handle .update(self, |_, window, _| { diff --git a/crates/gpui/src/elements/div.rs b/crates/gpui/src/elements/div.rs index cb53276bc2..ed1666c530 100644 --- a/crates/gpui/src/elements/div.rs +++ b/crates/gpui/src/elements/div.rs @@ -619,6 +619,13 @@ pub trait InteractiveElement: Sized { self } + /// Set index of the tab stop order. + fn tab_index(mut self, index: isize) -> Self { + self.interactivity().focusable = true; + self.interactivity().tab_index = Some(index); + self + } + /// Set the keymap context for this element. This will be used to determine /// which action to dispatch from the keymap. fn key_context(mut self, key_context: C) -> Self @@ -1462,6 +1469,7 @@ pub struct Interactivity { pub(crate) tooltip_builder: Option, pub(crate) window_control: Option, pub(crate) hitbox_behavior: HitboxBehavior, + pub(crate) tab_index: Option, #[cfg(any(feature = "inspector", debug_assertions))] pub(crate) source_location: Option<&'static core::panic::Location<'static>>, @@ -1521,12 +1529,17 @@ impl Interactivity { // as frames contain an element with this id. if self.focusable && self.tracked_focus_handle.is_none() { if let Some(element_state) = element_state.as_mut() { - self.tracked_focus_handle = Some( - element_state - .focus_handle - .get_or_insert_with(|| cx.focus_handle()) - .clone(), - ); + let mut handle = element_state + .focus_handle + .get_or_insert_with(|| cx.focus_handle()) + .clone() + .tab_stop(false); + + if let Some(index) = self.tab_index { + handle = handle.tab_index(index).tab_stop(true); + } + + self.tracked_focus_handle = Some(handle); } } @@ -1729,6 +1742,10 @@ impl Interactivity { return ((), element_state); } + if let Some(focus_handle) = &self.tracked_focus_handle { + window.next_frame.tab_handles.insert(focus_handle); + } + window.with_element_opacity(style.opacity, |window| { style.paint(bounds, window, cx, |window: &mut Window, cx: &mut App| { window.with_text_style(style.text_style().cloned(), |window| { diff --git a/crates/gpui/src/gpui.rs b/crates/gpui/src/gpui.rs index 4eb6fa8dab..09799eb910 100644 --- a/crates/gpui/src/gpui.rs +++ b/crates/gpui/src/gpui.rs @@ -95,6 +95,7 @@ mod style; mod styled; mod subscription; mod svg_renderer; +mod tab_stop; mod taffy; #[cfg(any(test, feature = "test-support"))] pub mod test; @@ -151,6 +152,7 @@ pub use style::*; pub use styled::*; pub use subscription::*; use svg_renderer::*; +pub(crate) use tab_stop::*; pub use taffy::{AvailableSpace, LayoutId}; #[cfg(any(test, feature = "test-support"))] pub use test::*; diff --git a/crates/gpui/src/tab_stop.rs b/crates/gpui/src/tab_stop.rs new file mode 100644 index 0000000000..2ec3f560e8 --- /dev/null +++ b/crates/gpui/src/tab_stop.rs @@ -0,0 +1,157 @@ +use crate::{FocusHandle, FocusId}; + +/// Represents a collection of tab handles. +/// +/// Used to manage the `Tab` event to switch between focus handles. +#[derive(Default)] +pub(crate) struct TabHandles { + handles: Vec, +} + +impl TabHandles { + pub(crate) fn insert(&mut self, focus_handle: &FocusHandle) { + if !focus_handle.tab_stop { + return; + } + + let focus_handle = focus_handle.clone(); + + // Insert handle with same tab_index last + if let Some(ix) = self + .handles + .iter() + .position(|tab| tab.tab_index > focus_handle.tab_index) + { + self.handles.insert(ix, focus_handle); + } else { + self.handles.push(focus_handle); + } + } + + pub(crate) fn clear(&mut self) { + self.handles.clear(); + } + + fn current_index(&self, focused_id: Option<&FocusId>) -> usize { + self.handles + .iter() + .position(|h| Some(&h.id) == focused_id) + .unwrap_or_default() + } + + pub(crate) fn next(&self, focused_id: Option<&FocusId>) -> Option { + let ix = self.current_index(focused_id); + + let mut next_ix = ix + 1; + if next_ix + 1 > self.handles.len() { + next_ix = 0; + } + + if let Some(next_handle) = self.handles.get(next_ix) { + Some(next_handle.clone()) + } else { + None + } + } + + pub(crate) fn prev(&self, focused_id: Option<&FocusId>) -> Option { + let ix = self.current_index(focused_id); + let prev_ix; + if ix == 0 { + prev_ix = self.handles.len().saturating_sub(1); + } else { + prev_ix = ix.saturating_sub(1); + } + + if let Some(prev_handle) = self.handles.get(prev_ix) { + Some(prev_handle.clone()) + } else { + None + } + } +} + +#[cfg(test)] +mod tests { + use crate::{FocusHandle, FocusMap, TabHandles}; + use std::sync::Arc; + + #[test] + fn test_tab_handles() { + let focus_map = Arc::new(FocusMap::default()); + let mut tab = TabHandles::default(); + + let focus_handles = vec![ + FocusHandle::new(&focus_map).tab_stop(true).tab_index(0), + FocusHandle::new(&focus_map).tab_stop(true).tab_index(1), + FocusHandle::new(&focus_map).tab_stop(true).tab_index(1), + FocusHandle::new(&focus_map), + FocusHandle::new(&focus_map).tab_index(2), + FocusHandle::new(&focus_map).tab_stop(true).tab_index(0), + FocusHandle::new(&focus_map).tab_stop(true).tab_index(2), + ]; + + for handle in focus_handles.iter() { + tab.insert(&handle); + } + assert_eq!( + tab.handles + .iter() + .map(|handle| handle.id) + .collect::>(), + vec![ + focus_handles[0].id, + focus_handles[5].id, + focus_handles[1].id, + focus_handles[2].id, + focus_handles[6].id, + ] + ); + + // next + assert_eq!(tab.next(None), Some(tab.handles[1].clone())); + assert_eq!( + tab.next(Some(&tab.handles[0].id)), + Some(tab.handles[1].clone()) + ); + assert_eq!( + tab.next(Some(&tab.handles[1].id)), + Some(tab.handles[2].clone()) + ); + assert_eq!( + tab.next(Some(&tab.handles[2].id)), + Some(tab.handles[3].clone()) + ); + assert_eq!( + tab.next(Some(&tab.handles[3].id)), + Some(tab.handles[4].clone()) + ); + assert_eq!( + tab.next(Some(&tab.handles[4].id)), + Some(tab.handles[0].clone()) + ); + + // prev + assert_eq!(tab.prev(None), Some(tab.handles[4].clone())); + assert_eq!( + tab.prev(Some(&tab.handles[0].id)), + Some(tab.handles[4].clone()) + ); + assert_eq!( + tab.prev(Some(&tab.handles[1].id)), + Some(tab.handles[0].clone()) + ); + assert_eq!( + tab.prev(Some(&tab.handles[2].id)), + Some(tab.handles[1].clone()) + ); + assert_eq!( + tab.prev(Some(&tab.handles[3].id)), + Some(tab.handles[2].clone()) + ); + assert_eq!( + tab.prev(Some(&tab.handles[4].id)), + Some(tab.handles[3].clone()) + ); + } +} diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rs index b6601829c7..963d2bb45c 100644 --- a/crates/gpui/src/window.rs +++ b/crates/gpui/src/window.rs @@ -12,10 +12,11 @@ use crate::{ PlatformInputHandler, PlatformWindow, Point, PolychromeSprite, PromptButton, PromptLevel, Quad, Render, RenderGlyphParams, RenderImage, RenderImageParams, RenderSvgParams, Replay, ResizeEdge, SMOOTH_SVG_SCALE_FACTOR, SUBPIXEL_VARIANTS, ScaledPixels, Scene, Shadow, SharedString, Size, - StrikethroughStyle, Style, SubscriberSet, Subscription, TaffyLayoutEngine, Task, TextStyle, - TextStyleRefinement, TransformationMatrix, Underline, UnderlineStyle, WindowAppearance, - WindowBackgroundAppearance, WindowBounds, WindowControls, WindowDecorations, WindowOptions, - WindowParams, WindowTextSystem, point, prelude::*, px, rems, size, transparent_black, + StrikethroughStyle, Style, SubscriberSet, Subscription, TabHandles, TaffyLayoutEngine, Task, + TextStyle, TextStyleRefinement, TransformationMatrix, Underline, UnderlineStyle, + WindowAppearance, WindowBackgroundAppearance, WindowBounds, WindowControls, WindowDecorations, + WindowOptions, WindowParams, WindowTextSystem, point, prelude::*, px, rems, size, + transparent_black, }; use anyhow::{Context as _, Result, anyhow}; use collections::{FxHashMap, FxHashSet}; @@ -222,7 +223,12 @@ impl ArenaClearNeeded { } } -pub(crate) type FocusMap = RwLock>; +pub(crate) type FocusMap = RwLock>; +pub(crate) struct FocusRef { + pub(crate) ref_count: AtomicUsize, + pub(crate) tab_index: isize, + pub(crate) tab_stop: bool, +} impl FocusId { /// Obtains whether the element associated with this handle is currently focused. @@ -258,6 +264,10 @@ impl FocusId { pub struct FocusHandle { pub(crate) id: FocusId, handles: Arc, + /// The index of this element in the tab order. + pub tab_index: isize, + /// Whether this element can be focused by tab navigation. + pub tab_stop: bool, } impl std::fmt::Debug for FocusHandle { @@ -268,25 +278,54 @@ impl std::fmt::Debug for FocusHandle { impl FocusHandle { pub(crate) fn new(handles: &Arc) -> Self { - let id = handles.write().insert(AtomicUsize::new(1)); + let id = handles.write().insert(FocusRef { + ref_count: AtomicUsize::new(1), + tab_index: 0, + tab_stop: false, + }); + Self { id, + tab_index: 0, + tab_stop: false, handles: handles.clone(), } } pub(crate) fn for_id(id: FocusId, handles: &Arc) -> Option { let lock = handles.read(); - let ref_count = lock.get(id)?; - if atomic_incr_if_not_zero(ref_count) == 0 { + let focus = lock.get(id)?; + if atomic_incr_if_not_zero(&focus.ref_count) == 0 { return None; } Some(Self { id, + tab_index: focus.tab_index, + tab_stop: focus.tab_stop, handles: handles.clone(), }) } + /// Sets the tab index of the element associated with this handle. + pub fn tab_index(mut self, index: isize) -> Self { + self.tab_index = index; + if let Some(focus) = self.handles.write().get_mut(self.id) { + focus.tab_index = index; + } + self + } + + /// Sets whether the element associated with this handle is a tab stop. + /// + /// When `false`, the element will not be included in the tab order. + pub fn tab_stop(mut self, tab_stop: bool) -> Self { + self.tab_stop = tab_stop; + if let Some(focus) = self.handles.write().get_mut(self.id) { + focus.tab_stop = tab_stop; + } + self + } + /// Converts this focus handle into a weak variant, which does not prevent it from being released. pub fn downgrade(&self) -> WeakFocusHandle { WeakFocusHandle { @@ -354,6 +393,7 @@ impl Drop for FocusHandle { .read() .get(self.id) .unwrap() + .ref_count .fetch_sub(1, SeqCst); } } @@ -642,6 +682,7 @@ pub(crate) struct Frame { pub(crate) next_inspector_instance_ids: FxHashMap, usize>, #[cfg(any(feature = "inspector", debug_assertions))] pub(crate) inspector_hitboxes: FxHashMap, + pub(crate) tab_handles: TabHandles, } #[derive(Clone, Default)] @@ -689,6 +730,7 @@ impl Frame { #[cfg(any(feature = "inspector", debug_assertions))] inspector_hitboxes: FxHashMap::default(), + tab_handles: TabHandles::default(), } } @@ -704,6 +746,7 @@ impl Frame { self.hitboxes.clear(); self.window_control_hitboxes.clear(); self.deferred_draws.clear(); + self.tab_handles.clear(); self.focus = None; #[cfg(any(feature = "inspector", debug_assertions))] @@ -1289,6 +1332,28 @@ impl Window { self.focus_enabled = false; } + /// Move focus to next tab stop. + pub fn focus_next(&mut self) { + if !self.focus_enabled { + return; + } + + if let Some(handle) = self.rendered_frame.tab_handles.next(self.focus.as_ref()) { + self.focus(&handle) + } + } + + /// Move focus to previous tab stop. + pub fn focus_prev(&mut self) { + if !self.focus_enabled { + return; + } + + if let Some(handle) = self.rendered_frame.tab_handles.prev(self.focus.as_ref()) { + self.focus(&handle) + } + } + /// Accessor for the text system. pub fn text_system(&self) -> &Arc { &self.text_system From 57ab09c2dabe5282926593360e0d865b19fe8e36 Mon Sep 17 00:00:00 2001 From: Ben Brandt Date: Mon, 21 Jul 2025 11:53:05 +0200 Subject: [PATCH 0084/1052] claude: Don't quote executable path in mcp configuration (#34805) This was generating an invalid string for the configuration, removing the extra quotes makes it work. This affected the versions of Zed that have a space in their name. Release Notes: - N/A --- crates/agent_servers/src/claude/mcp_server.rs | 3 --- 1 file changed, 3 deletions(-) diff --git a/crates/agent_servers/src/claude/mcp_server.rs b/crates/agent_servers/src/claude/mcp_server.rs index fa61e67112..468027c4c3 100644 --- a/crates/agent_servers/src/claude/mcp_server.rs +++ b/crates/agent_servers/src/claude/mcp_server.rs @@ -69,9 +69,6 @@ impl ClaudeMcpServer { } pub fn server_config(&self) -> Result { - #[cfg(not(target_os = "windows"))] - let zed_path = util::get_shell_safe_zed_path()?; - #[cfg(target_os = "windows")] let zed_path = std::env::current_exe() .context("finding current executable path for use in mcp_server")? .to_string_lossy() From 88af35fe4727f5187608cfb396def24f4c60c004 Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Mon, 21 Jul 2025 13:44:51 +0200 Subject: [PATCH 0085/1052] collab: Add screen selector (#31506) Instead of selecting a screen to share arbitrarily, we'll now allow user to select the screen to share. Note that sharing multiple screens at the time is still not supported (though prolly not too far-fetched). Related to #4666 ![image](https://github.com/user-attachments/assets/1afb664f-3cdb-4e0a-bb29-9d7093d87fa5) Release Notes: - Added screen selector dropdown to screen share button --------- Co-authored-by: Kirill Bulatov Co-authored-by: Cole Miller --- .config/hakari.toml | 2 +- Cargo.lock | 6 +- Cargo.toml | 4 +- crates/call/src/call_impl/room.rs | 61 +++--- crates/collab/src/tests/following_tests.rs | 12 +- crates/collab/src/tests/integration_tests.rs | 21 +- crates/collab_ui/src/collab_panel.rs | 22 +- crates/gpui/src/app.rs | 2 +- crates/gpui/src/platform.rs | 31 ++- .../src/platform/linux/headless/client.rs | 2 +- crates/gpui/src/platform/linux/platform.rs | 4 +- .../gpui/src/platform/linux/wayland/client.rs | 2 +- crates/gpui/src/platform/linux/x11/client.rs | 2 +- crates/gpui/src/platform/mac/platform.rs | 2 +- .../gpui/src/platform/mac/screen_capture.rs | 102 ++++++++-- .../gpui/src/platform/scap_screen_capture.rs | 99 ++++++--- crates/gpui/src/platform/test.rs | 2 +- crates/gpui/src/platform/test/platform.rs | 22 +- crates/gpui/src/platform/windows/platform.rs | 2 +- .../src/livekit_client/playback.rs | 6 +- .../src/mock_client/participant.rs | 6 +- crates/title_bar/Cargo.toml | 1 + crates/title_bar/src/collab.rs | 192 +++++++++++++++--- crates/title_bar/src/title_bar.rs | 4 +- .../ui/src/components/button/icon_button.rs | 3 +- crates/ui/src/components/context_menu.rs | 6 + 26 files changed, 473 insertions(+), 145 deletions(-) diff --git a/.config/hakari.toml b/.config/hakari.toml index 5168887581..2050065cc2 100644 --- a/.config/hakari.toml +++ b/.config/hakari.toml @@ -24,7 +24,7 @@ workspace-members = [ third-party = [ { name = "reqwest", version = "0.11.27" }, # build of remote_server should not include scap / its x11 dependency - { name = "scap", git = "https://github.com/zed-industries/scap", rev = "270538dc780f5240723233ff901e1054641ed318" }, + { name = "scap", git = "https://github.com/zed-industries/scap", rev = "808aa5c45b41e8f44729d02e38fd00a2fe2722e7" }, ] [final-excludes] diff --git a/Cargo.lock b/Cargo.lock index a5ea621cd1..bc69de7a7c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -14185,7 +14185,7 @@ dependencies = [ [[package]] name = "scap" version = "0.0.8" -source = "git+https://github.com/zed-industries/scap?rev=270538dc780f5240723233ff901e1054641ed318#270538dc780f5240723233ff901e1054641ed318" +source = "git+https://github.com/zed-industries/scap?rev=808aa5c45b41e8f44729d02e38fd00a2fe2722e7#808aa5c45b41e8f44729d02e38fd00a2fe2722e7" dependencies = [ "anyhow", "cocoa 0.25.0", @@ -16484,6 +16484,7 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" name = "title_bar" version = "0.1.0" dependencies = [ + "anyhow", "auto_update", "call", "chrono", @@ -18729,8 +18730,7 @@ dependencies = [ [[package]] name = "windows-capture" version = "1.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "59d10b4be8b907c7055bc7270dd68d2b920978ffacc1599dcb563a79f0e68d16" +source = "git+https://github.com/zed-industries/windows-capture.git?rev=f0d6c1b6691db75461b732f6d5ff56eed002eeb9#f0d6c1b6691db75461b732f6d5ff56eed002eeb9" dependencies = [ "clap", "ctrlc", diff --git a/Cargo.toml b/Cargo.toml index aa9af9a423..0169d32eb6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -553,8 +553,7 @@ rustc-demangle = "0.1.23" rustc-hash = "2.1.0" rustls = { version = "0.23.26" } rustls-platform-verifier = "0.5.0" -# When updating scap rev, also update it in .config/hakari.toml -scap = { git = "https://github.com/zed-industries/scap", rev = "270538dc780f5240723233ff901e1054641ed318", default-features = false } +scap = { git = "https://github.com/zed-industries/scap", rev = "808aa5c45b41e8f44729d02e38fd00a2fe2722e7", default-features = false } schemars = { version = "1.0", features = ["indexmap2"] } semver = "1.0" serde = { version = "1.0", features = ["derive", "rc"] } @@ -708,6 +707,7 @@ features = [ [patch.crates-io] notify = { git = "https://github.com/zed-industries/notify.git", rev = "bbb9ea5ae52b253e095737847e367c30653a2e96" } notify-types = { git = "https://github.com/zed-industries/notify.git", rev = "bbb9ea5ae52b253e095737847e367c30653a2e96" } +windows-capture = { git = "https://github.com/zed-industries/windows-capture.git", rev = "f0d6c1b6691db75461b732f6d5ff56eed002eeb9" } # Makes the workspace hack crate refer to the local one, but only when you're building locally workspace-hack = { path = "tooling/workspace-hack" } diff --git a/crates/call/src/call_impl/room.rs b/crates/call/src/call_impl/room.rs index 7aac72ed46..afeee4c924 100644 --- a/crates/call/src/call_impl/room.rs +++ b/crates/call/src/call_impl/room.rs @@ -11,15 +11,18 @@ use client::{ use collections::{BTreeMap, HashMap, HashSet}; use fs::Fs; use futures::{FutureExt, StreamExt}; -use gpui::{App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, Task, WeakEntity}; +use gpui::{ + App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, ScreenCaptureSource, + ScreenCaptureStream, Task, WeakEntity, +}; use gpui_tokio::Tokio; use language::LanguageRegistry; use livekit::{LocalTrackPublication, ParticipantIdentity, RoomEvent}; -use livekit_client::{self as livekit, TrackSid}; +use livekit_client::{self as livekit, AudioStream, TrackSid}; use postage::{sink::Sink, stream::Stream, watch}; use project::Project; use settings::Settings as _; -use std::{any::Any, future::Future, mem, rc::Rc, sync::Arc, time::Duration}; +use std::{future::Future, mem, rc::Rc, sync::Arc, time::Duration}; use util::{ResultExt, TryFutureExt, post_inc}; pub const RECONNECT_TIMEOUT: Duration = Duration::from_secs(30); @@ -1251,12 +1254,21 @@ impl Room { }) } - pub fn is_screen_sharing(&self) -> bool { + pub fn is_sharing_screen(&self) -> bool { self.live_kit.as_ref().map_or(false, |live_kit| { !matches!(live_kit.screen_track, LocalTrack::None) }) } + pub fn shared_screen_id(&self) -> Option { + self.live_kit.as_ref().and_then(|lk| match lk.screen_track { + LocalTrack::Published { ref _stream, .. } => { + _stream.metadata().ok().map(|meta| meta.id) + } + _ => None, + }) + } + pub fn is_sharing_mic(&self) -> bool { self.live_kit.as_ref().map_or(false, |live_kit| { !matches!(live_kit.microphone_track, LocalTrack::None) @@ -1369,11 +1381,15 @@ impl Room { }) } - pub fn share_screen(&mut self, cx: &mut Context) -> Task> { + pub fn share_screen( + &mut self, + source: Rc, + cx: &mut Context, + ) -> Task> { if self.status.is_offline() { return Task::ready(Err(anyhow!("room is offline"))); } - if self.is_screen_sharing() { + if self.is_sharing_screen() { return Task::ready(Err(anyhow!("screen was already shared"))); } @@ -1386,20 +1402,8 @@ impl Room { return Task::ready(Err(anyhow!("live-kit was not initialized"))); }; - let sources = cx.screen_capture_sources(); - cx.spawn(async move |this, cx| { - let sources = sources - .await - .map_err(|error| error.into()) - .and_then(|sources| sources); - let source = - sources.and_then(|sources| sources.into_iter().next().context("no display found")); - - let publication = match source { - Ok(source) => participant.publish_screenshare_track(&*source, cx).await, - Err(error) => Err(error), - }; + let publication = participant.publish_screenshare_track(&*source, cx).await; this.update(cx, |this, cx| { let live_kit = this @@ -1426,7 +1430,7 @@ impl Room { } else { live_kit.screen_track = LocalTrack::Published { track_publication: publication, - _stream: Box::new(stream), + _stream: stream, }; cx.notify(); } @@ -1492,7 +1496,7 @@ impl Room { } } - pub fn unshare_screen(&mut self, cx: &mut Context) -> Result<()> { + pub fn unshare_screen(&mut self, play_sound: bool, cx: &mut Context) -> Result<()> { anyhow::ensure!(!self.status.is_offline(), "room is offline"); let live_kit = self @@ -1516,7 +1520,10 @@ impl Room { cx.notify(); } - Audio::play_sound(Sound::StopScreenshare, cx); + if play_sound { + Audio::play_sound(Sound::StopScreenshare, cx); + } + Ok(()) } } @@ -1624,8 +1631,8 @@ fn spawn_room_connection( struct LiveKitRoom { room: Rc, - screen_track: LocalTrack, - microphone_track: LocalTrack, + screen_track: LocalTrack, + microphone_track: LocalTrack, /// Tracks whether we're currently in a muted state due to auto-mute from deafening or manual mute performed by user. muted_by_user: bool, deafened: bool, @@ -1663,18 +1670,18 @@ impl LiveKitRoom { } } -enum LocalTrack { +enum LocalTrack { None, Pending { publish_id: usize, }, Published { track_publication: LocalTrackPublication, - _stream: Box, + _stream: Box, }, } -impl Default for LocalTrack { +impl Default for LocalTrack { fn default() -> Self { Self::None } diff --git a/crates/collab/src/tests/following_tests.rs b/crates/collab/src/tests/following_tests.rs index 1a4c3a70a4..d9fd8ffeb2 100644 --- a/crates/collab/src/tests/following_tests.rs +++ b/crates/collab/src/tests/following_tests.rs @@ -439,7 +439,7 @@ async fn test_basic_following( editor_a1.item_id() ); - #[cfg(all(not(target_os = "macos"), not(target_os = "windows")))] + // #[cfg(all(not(target_os = "macos"), not(target_os = "windows")))] { use crate::rpc::RECONNECT_TIMEOUT; use gpui::TestScreenCaptureSource; @@ -456,11 +456,19 @@ async fn test_basic_following( .await .unwrap(); cx_b.set_screen_capture_sources(vec![display]); + let source = cx_b + .read(|cx| cx.screen_capture_sources()) + .await + .unwrap() + .unwrap() + .into_iter() + .next() + .unwrap(); active_call_b .update(cx_b, |call, cx| { call.room() .unwrap() - .update(cx, |room, cx| room.share_screen(cx)) + .update(cx, |room, cx| room.share_screen(source, cx)) }) .await .unwrap(); diff --git a/crates/collab/src/tests/integration_tests.rs b/crates/collab/src/tests/integration_tests.rs index d1099a327a..9795c27574 100644 --- a/crates/collab/src/tests/integration_tests.rs +++ b/crates/collab/src/tests/integration_tests.rs @@ -277,11 +277,19 @@ async fn test_basic_calls( let events_b = active_call_events(cx_b); let events_c = active_call_events(cx_c); cx_a.set_screen_capture_sources(vec![display]); + let screen_a = cx_a + .update(|cx| cx.screen_capture_sources()) + .await + .unwrap() + .unwrap() + .into_iter() + .next() + .unwrap(); active_call_a .update(cx_a, |call, cx| { call.room() .unwrap() - .update(cx, |room, cx| room.share_screen(cx)) + .update(cx, |room, cx| room.share_screen(screen_a, cx)) }) .await .unwrap(); @@ -6312,11 +6320,20 @@ async fn test_join_call_after_screen_was_shared( // User A shares their screen let display = gpui::TestScreenCaptureSource::new(); cx_a.set_screen_capture_sources(vec![display]); + let screen_a = cx_a + .update(|cx| cx.screen_capture_sources()) + .await + .unwrap() + .unwrap() + .into_iter() + .next() + .unwrap(); + active_call_a .update(cx_a, |call, cx| { call.room() .unwrap() - .update(cx, |room, cx| room.share_screen(cx)) + .update(cx, |room, cx| room.share_screen(screen_a, cx)) }) .await .unwrap(); diff --git a/crates/collab_ui/src/collab_panel.rs b/crates/collab_ui/src/collab_panel.rs index ec23e2c3f5..4d5973481e 100644 --- a/crates/collab_ui/src/collab_panel.rs +++ b/crates/collab_ui/src/collab_panel.rs @@ -144,10 +144,22 @@ pub fn init(cx: &mut App) { if let Some(room) = room { window.defer(cx, move |_window, cx| { room.update(cx, |room, cx| { - if room.is_screen_sharing() { - room.unshare_screen(cx).ok(); + if room.is_sharing_screen() { + room.unshare_screen(true, cx).ok(); } else { - room.share_screen(cx).detach_and_log_err(cx); + let sources = cx.screen_capture_sources(); + + cx.spawn(async move |room, cx| { + let sources = sources.await??; + let first = sources.into_iter().next(); + if let Some(first) = first { + room.update(cx, |room, cx| room.share_screen(first, cx))? + .await + } else { + Ok(()) + } + }) + .detach_and_log_err(cx); }; }); }); @@ -528,10 +540,10 @@ impl CollabPanel { project_id: project.id, worktree_root_names: project.worktree_root_names.clone(), host_user_id: user_id, - is_last: projects.peek().is_none() && !room.is_screen_sharing(), + is_last: projects.peek().is_none() && !room.is_sharing_screen(), }); } - if room.is_screen_sharing() { + if room.is_sharing_screen() { self.entries.push(ListEntry::ParticipantScreen { peer_id: None, is_last: true, diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs index 2771de9aac..759d33563e 100644 --- a/crates/gpui/src/app.rs +++ b/crates/gpui/src/app.rs @@ -696,7 +696,7 @@ impl App { /// Returns a list of available screen capture sources. pub fn screen_capture_sources( &self, - ) -> oneshot::Receiver>>> { + ) -> oneshot::Receiver>>> { self.platform.screen_capture_sources() } diff --git a/crates/gpui/src/platform.rs b/crates/gpui/src/platform.rs index 8918fdd28b..6f227f1d07 100644 --- a/crates/gpui/src/platform.rs +++ b/crates/gpui/src/platform.rs @@ -85,7 +85,7 @@ pub(crate) use test::*; pub(crate) use windows::*; #[cfg(any(test, feature = "test-support"))] -pub use test::{TestDispatcher, TestScreenCaptureSource}; +pub use test::{TestDispatcher, TestScreenCaptureSource, TestScreenCaptureStream}; /// Returns a background executor for the current platform. pub fn background_executor() -> BackgroundExecutor { @@ -189,13 +189,12 @@ pub(crate) trait Platform: 'static { false } #[cfg(feature = "screen-capture")] - fn screen_capture_sources( - &self, - ) -> oneshot::Receiver>>>; + fn screen_capture_sources(&self) + -> oneshot::Receiver>>>; #[cfg(not(feature = "screen-capture"))] fn screen_capture_sources( &self, - ) -> oneshot::Receiver>>> { + ) -> oneshot::Receiver>>> { let (sources_tx, sources_rx) = oneshot::channel(); sources_tx .send(Err(anyhow::anyhow!( @@ -293,10 +292,23 @@ pub trait PlatformDisplay: Send + Sync + Debug { } } +/// Metadata for a given [ScreenCaptureSource] +#[derive(Clone)] +pub struct SourceMetadata { + /// Opaque identifier of this screen. + pub id: u64, + /// Human-readable label for this source. + pub label: Option, + /// Whether this source is the main display. + pub is_main: Option, + /// Video resolution of this source. + pub resolution: Size, +} + /// A source of on-screen video content that can be captured. pub trait ScreenCaptureSource { - /// Returns the video resolution of this source. - fn resolution(&self) -> Result>; + /// Returns metadata for this source. + fn metadata(&self) -> Result; /// Start capture video from this source, invoking the given callback /// with each frame. @@ -308,7 +320,10 @@ pub trait ScreenCaptureSource { } /// A video stream captured from a screen. -pub trait ScreenCaptureStream {} +pub trait ScreenCaptureStream { + /// Returns metadata for this source. + fn metadata(&self) -> Result; +} /// A frame of video captured from a screen. pub struct ScreenCaptureFrame(pub PlatformScreenCaptureFrame); diff --git a/crates/gpui/src/platform/linux/headless/client.rs b/crates/gpui/src/platform/linux/headless/client.rs index 663a740389..da54db3710 100644 --- a/crates/gpui/src/platform/linux/headless/client.rs +++ b/crates/gpui/src/platform/linux/headless/client.rs @@ -73,7 +73,7 @@ impl LinuxClient for HeadlessClient { #[cfg(feature = "screen-capture")] fn screen_capture_sources( &self, - ) -> futures::channel::oneshot::Receiver>>> + ) -> futures::channel::oneshot::Receiver>>> { let (mut tx, rx) = futures::channel::oneshot::channel(); tx.send(Err(anyhow::anyhow!( diff --git a/crates/gpui/src/platform/linux/platform.rs b/crates/gpui/src/platform/linux/platform.rs index c4b90ccf08..a52841e1af 100644 --- a/crates/gpui/src/platform/linux/platform.rs +++ b/crates/gpui/src/platform/linux/platform.rs @@ -56,7 +56,7 @@ pub trait LinuxClient { #[cfg(feature = "screen-capture")] fn screen_capture_sources( &self, - ) -> oneshot::Receiver>>>; + ) -> oneshot::Receiver>>>; fn open_window( &self, @@ -245,7 +245,7 @@ impl Platform for P { #[cfg(feature = "screen-capture")] fn screen_capture_sources( &self, - ) -> oneshot::Receiver>>> { + ) -> oneshot::Receiver>>> { self.screen_capture_sources() } diff --git a/crates/gpui/src/platform/linux/wayland/client.rs b/crates/gpui/src/platform/linux/wayland/client.rs index 57d1dcec04..72e4477ecf 100644 --- a/crates/gpui/src/platform/linux/wayland/client.rs +++ b/crates/gpui/src/platform/linux/wayland/client.rs @@ -672,7 +672,7 @@ impl LinuxClient for WaylandClient { #[cfg(feature = "screen-capture")] fn screen_capture_sources( &self, - ) -> futures::channel::oneshot::Receiver>>> + ) -> futures::channel::oneshot::Receiver>>> { // TODO: Get screen capture working on wayland. Be sure to try window resizing as that may // be tricky. diff --git a/crates/gpui/src/platform/linux/x11/client.rs b/crates/gpui/src/platform/linux/x11/client.rs index 0606f619c6..d1cb7d00cc 100644 --- a/crates/gpui/src/platform/linux/x11/client.rs +++ b/crates/gpui/src/platform/linux/x11/client.rs @@ -1448,7 +1448,7 @@ impl LinuxClient for X11Client { #[cfg(feature = "screen-capture")] fn screen_capture_sources( &self, - ) -> futures::channel::oneshot::Receiver>>> + ) -> futures::channel::oneshot::Receiver>>> { crate::platform::scap_screen_capture::scap_screen_sources( &self.0.borrow().common.foreground_executor, diff --git a/crates/gpui/src/platform/mac/platform.rs b/crates/gpui/src/platform/mac/platform.rs index d9bb665469..1d2146cf73 100644 --- a/crates/gpui/src/platform/mac/platform.rs +++ b/crates/gpui/src/platform/mac/platform.rs @@ -583,7 +583,7 @@ impl Platform for MacPlatform { #[cfg(feature = "screen-capture")] fn screen_capture_sources( &self, - ) -> oneshot::Receiver>>> { + ) -> oneshot::Receiver>>> { super::screen_capture::get_sources() } diff --git a/crates/gpui/src/platform/mac/screen_capture.rs b/crates/gpui/src/platform/mac/screen_capture.rs index af5e02fc06..4d4ffa6896 100644 --- a/crates/gpui/src/platform/mac/screen_capture.rs +++ b/crates/gpui/src/platform/mac/screen_capture.rs @@ -1,5 +1,5 @@ use crate::{ - DevicePixels, ForegroundExecutor, Size, + DevicePixels, ForegroundExecutor, SharedString, SourceMetadata, platform::{ScreenCaptureFrame, ScreenCaptureSource, ScreenCaptureStream}, size, }; @@ -7,8 +7,9 @@ use anyhow::{Result, anyhow}; use block::ConcreteBlock; use cocoa::{ base::{YES, id, nil}, - foundation::NSArray, + foundation::{NSArray, NSString}, }; +use collections::HashMap; use core_foundation::base::TCFType; use core_graphics::display::{ CGDirectDisplayID, CGDisplayCopyDisplayMode, CGDisplayModeGetPixelHeight, @@ -32,11 +33,13 @@ use super::NSStringExt; #[derive(Clone)] pub struct MacScreenCaptureSource { sc_display: id, + meta: Option, } pub struct MacScreenCaptureStream { sc_stream: id, sc_stream_output: id, + meta: SourceMetadata, } static mut DELEGATE_CLASS: *const Class = ptr::null(); @@ -47,19 +50,31 @@ const FRAME_CALLBACK_IVAR: &str = "frame_callback"; const SCStreamOutputTypeScreen: NSInteger = 0; impl ScreenCaptureSource for MacScreenCaptureSource { - fn resolution(&self) -> Result> { - unsafe { + fn metadata(&self) -> Result { + let (display_id, size) = unsafe { let display_id: CGDirectDisplayID = msg_send![self.sc_display, displayID]; let display_mode_ref = CGDisplayCopyDisplayMode(display_id); let width = CGDisplayModeGetPixelWidth(display_mode_ref); let height = CGDisplayModeGetPixelHeight(display_mode_ref); CGDisplayModeRelease(display_mode_ref); - Ok(size( - DevicePixels(width as i32), - DevicePixels(height as i32), - )) - } + ( + display_id, + size(DevicePixels(width as i32), DevicePixels(height as i32)), + ) + }; + let (label, is_main) = self + .meta + .clone() + .map(|meta| (meta.label, meta.is_main)) + .unzip(); + + Ok(SourceMetadata { + id: display_id as u64, + label, + is_main, + resolution: size, + }) } fn stream( @@ -89,9 +104,9 @@ impl ScreenCaptureSource for MacScreenCaptureSource { Box::into_raw(Box::new(frame_callback)) as *mut c_void, ); - let resolution = self.resolution().unwrap(); - let _: id = msg_send![configuration, setWidth: resolution.width.0 as i64]; - let _: id = msg_send![configuration, setHeight: resolution.height.0 as i64]; + let meta = self.metadata().unwrap(); + let _: id = msg_send![configuration, setWidth: meta.resolution.width.0 as i64]; + let _: id = msg_send![configuration, setHeight: meta.resolution.height.0 as i64]; let stream: id = msg_send![stream, initWithFilter:filter configuration:configuration delegate:delegate]; let (mut tx, rx) = oneshot::channel(); @@ -110,6 +125,7 @@ impl ScreenCaptureSource for MacScreenCaptureSource { move |error: id| { let result = if error == nil { let stream = MacScreenCaptureStream { + meta: meta.clone(), sc_stream: stream, sc_stream_output: output, }; @@ -138,7 +154,11 @@ impl Drop for MacScreenCaptureSource { } } -impl ScreenCaptureStream for MacScreenCaptureStream {} +impl ScreenCaptureStream for MacScreenCaptureStream { + fn metadata(&self) -> Result { + Ok(self.meta.clone()) + } +} impl Drop for MacScreenCaptureStream { fn drop(&mut self) { @@ -164,24 +184,74 @@ impl Drop for MacScreenCaptureStream { } } -pub(crate) fn get_sources() -> oneshot::Receiver>>> { +#[derive(Clone)] +struct ScreenMeta { + label: SharedString, + // Is this the screen with menu bar? + is_main: bool, +} + +unsafe fn screen_id_to_human_label() -> HashMap { + let screens: id = msg_send![class!(NSScreen), screens]; + let count: usize = msg_send![screens, count]; + let mut map = HashMap::default(); + let screen_number_key = unsafe { NSString::alloc(nil).init_str("NSScreenNumber") }; + for i in 0..count { + let screen: id = msg_send![screens, objectAtIndex: i]; + let device_desc: id = msg_send![screen, deviceDescription]; + if device_desc == nil { + continue; + } + + let nsnumber: id = msg_send![device_desc, objectForKey: screen_number_key]; + if nsnumber == nil { + continue; + } + + let screen_id: u32 = msg_send![nsnumber, unsignedIntValue]; + + let name: id = msg_send![screen, localizedName]; + if name != nil { + let cstr: *const std::os::raw::c_char = msg_send![name, UTF8String]; + let rust_str = unsafe { + std::ffi::CStr::from_ptr(cstr) + .to_string_lossy() + .into_owned() + }; + map.insert( + screen_id, + ScreenMeta { + label: rust_str.into(), + is_main: i == 0, + }, + ); + } + } + map +} + +pub(crate) fn get_sources() -> oneshot::Receiver>>> { unsafe { let (mut tx, rx) = oneshot::channel(); let tx = Rc::new(RefCell::new(Some(tx))); - + let screen_id_to_label = screen_id_to_human_label(); let block = ConcreteBlock::new(move |shareable_content: id, error: id| { let Some(mut tx) = tx.borrow_mut().take() else { return; }; + let result = if error == nil { let displays: id = msg_send![shareable_content, displays]; let mut result = Vec::new(); for i in 0..displays.count() { let display = displays.objectAtIndex(i); + let id: CGDirectDisplayID = msg_send![display, displayID]; + let meta = screen_id_to_label.get(&id).cloned(); let source = MacScreenCaptureSource { sc_display: msg_send![display, retain], + meta, }; - result.push(Box::new(source) as Box); + result.push(Rc::new(source) as Rc); } Ok(result) } else { diff --git a/crates/gpui/src/platform/scap_screen_capture.rs b/crates/gpui/src/platform/scap_screen_capture.rs index c5e2267a37..32041b655f 100644 --- a/crates/gpui/src/platform/scap_screen_capture.rs +++ b/crates/gpui/src/platform/scap_screen_capture.rs @@ -1,10 +1,12 @@ //! Screen capture for Linux and Windows use crate::{ DevicePixels, ForegroundExecutor, ScreenCaptureFrame, ScreenCaptureSource, ScreenCaptureStream, - Size, size, + Size, SourceMetadata, size, }; use anyhow::{Context as _, Result, anyhow}; use futures::channel::oneshot; +use scap::Target; +use std::rc::Rc; use std::sync::Arc; use std::sync::atomic::{self, AtomicBool}; @@ -15,7 +17,7 @@ use std::sync::atomic::{self, AtomicBool}; #[allow(dead_code)] pub(crate) fn scap_screen_sources( foreground_executor: &ForegroundExecutor, -) -> oneshot::Receiver>>> { +) -> oneshot::Receiver>>> { let (sources_tx, sources_rx) = oneshot::channel(); get_screen_targets(sources_tx); to_dyn_screen_capture_sources(sources_rx, foreground_executor) @@ -29,14 +31,14 @@ pub(crate) fn scap_screen_sources( #[allow(dead_code)] pub(crate) fn start_scap_default_target_source( foreground_executor: &ForegroundExecutor, -) -> oneshot::Receiver>>> { +) -> oneshot::Receiver>>> { let (sources_tx, sources_rx) = oneshot::channel(); start_default_target_screen_capture(sources_tx); to_dyn_screen_capture_sources(sources_rx, foreground_executor) } struct ScapCaptureSource { - target: scap::Target, + target: scap::Display, size: Size, } @@ -52,7 +54,7 @@ fn get_screen_targets(sources_tx: oneshot::Sender> } }; let sources = targets - .iter() + .into_iter() .filter_map(|target| match target { scap::Target::Display(display) => { let size = Size { @@ -60,7 +62,7 @@ fn get_screen_targets(sources_tx: oneshot::Sender> height: DevicePixels(display.height as i32), }; Some(ScapCaptureSource { - target: target.clone(), + target: display, size, }) } @@ -72,8 +74,13 @@ fn get_screen_targets(sources_tx: oneshot::Sender> } impl ScreenCaptureSource for ScapCaptureSource { - fn resolution(&self) -> Result> { - Ok(self.size) + fn metadata(&self) -> Result { + Ok(SourceMetadata { + resolution: self.size, + label: Some(self.target.title.clone().into()), + is_main: None, + id: self.target.id as u64, + }) } fn stream( @@ -85,13 +92,15 @@ impl ScreenCaptureSource for ScapCaptureSource { let target = self.target.clone(); // Due to use of blocking APIs, a dedicated thread is used. - std::thread::spawn(move || match new_scap_capturer(Some(target)) { - Ok(mut capturer) => { - capturer.start_capture(); - run_capture(capturer, frame_callback, stream_tx); - } - Err(e) => { - stream_tx.send(Err(e)).ok(); + std::thread::spawn(move || { + match new_scap_capturer(Some(scap::Target::Display(target.clone()))) { + Ok(mut capturer) => { + capturer.start_capture(); + run_capture(capturer, target.clone(), frame_callback, stream_tx); + } + Err(e) => { + stream_tx.send(Err(e)).ok(); + } } }); @@ -107,6 +116,7 @@ struct ScapDefaultTargetCaptureSource { // Callback for frames. Box, )>, + target: scap::Display, size: Size, } @@ -123,33 +133,48 @@ fn start_default_target_screen_capture( .get_next_frame() .context("Failed to get first frame of screenshare to get the size.")?; let size = frame_size(&first_frame); - Ok((capturer, size)) + let target = capturer + .target() + .context("Unable to determine the target display.")?; + let target = target.clone(); + Ok((capturer, size, target)) }); match start_result { - Err(e) => { - sources_tx.send(Err(e)).ok(); - } - Ok((capturer, size)) => { + Ok((capturer, size, Target::Display(display))) => { let (stream_call_tx, stream_rx) = std::sync::mpsc::sync_channel(1); sources_tx .send(Ok(vec![ScapDefaultTargetCaptureSource { stream_call_tx, size, + target: display.clone(), }])) .ok(); let Ok((stream_tx, frame_callback)) = stream_rx.recv() else { return; }; - run_capture(capturer, frame_callback, stream_tx); + run_capture(capturer, display, frame_callback, stream_tx); + } + Err(e) => { + sources_tx.send(Err(e)).ok(); + } + _ => { + sources_tx + .send(Err(anyhow!("The screen capture source is not a display"))) + .ok(); } } }); } impl ScreenCaptureSource for ScapDefaultTargetCaptureSource { - fn resolution(&self) -> Result> { - Ok(self.size) + fn metadata(&self) -> Result { + Ok(SourceMetadata { + resolution: self.size, + label: None, + is_main: None, + id: self.target.id as u64, + }) } fn stream( @@ -189,12 +214,19 @@ fn new_scap_capturer(target: Option) -> Result, stream_tx: oneshot::Sender>, ) { let cancel_stream = Arc::new(AtomicBool::new(false)); + let size = Size { + width: DevicePixels(display.width as i32), + height: DevicePixels(display.height as i32), + }; let stream_send_result = stream_tx.send(Ok(ScapStream { cancel_stream: cancel_stream.clone(), + display, + size, })); if let Err(_) = stream_send_result { return; @@ -213,9 +245,20 @@ fn run_capture( struct ScapStream { cancel_stream: Arc, + display: scap::Display, + size: Size, } -impl ScreenCaptureStream for ScapStream {} +impl ScreenCaptureStream for ScapStream { + fn metadata(&self) -> Result { + Ok(SourceMetadata { + resolution: self.size, + label: Some(self.display.title.clone().into()), + is_main: None, + id: self.display.id as u64, + }) + } +} impl Drop for ScapStream { fn drop(&mut self) { @@ -237,12 +280,12 @@ fn frame_size(frame: &scap::frame::Frame) -> Size { } /// This is used by `get_screen_targets` and `start_default_target_screen_capture` to turn their -/// results into `Box`. They need to `Send` their capture source, and so -/// the capture source structs are used as `Box` is not `Send`. +/// results into `Rc`. They need to `Send` their capture source, and so +/// the capture source structs are used as `Rc` is not `Send`. fn to_dyn_screen_capture_sources( sources_rx: oneshot::Receiver>>, foreground_executor: &ForegroundExecutor, -) -> oneshot::Receiver>>> { +) -> oneshot::Receiver>>> { let (dyn_sources_tx, dyn_sources_rx) = oneshot::channel(); foreground_executor .spawn(async move { @@ -250,7 +293,7 @@ fn to_dyn_screen_capture_sources( Ok(Ok(results)) => dyn_sources_tx .send(Ok(results .into_iter() - .map(|source| Box::new(source) as Box) + .map(|source| Rc::new(source) as Rc) .collect::>())) .ok(), Ok(Err(err)) => dyn_sources_tx.send(Err(err)).ok(), diff --git a/crates/gpui/src/platform/test.rs b/crates/gpui/src/platform/test.rs index e4173b7c6b..9227df5b63 100644 --- a/crates/gpui/src/platform/test.rs +++ b/crates/gpui/src/platform/test.rs @@ -8,4 +8,4 @@ pub(crate) use display::*; pub(crate) use platform::*; pub(crate) use window::*; -pub use platform::TestScreenCaptureSource; +pub use platform::{TestScreenCaptureSource, TestScreenCaptureStream}; diff --git a/crates/gpui/src/platform/test/platform.rs b/crates/gpui/src/platform/test/platform.rs index bef05399e5..a26b65576c 100644 --- a/crates/gpui/src/platform/test/platform.rs +++ b/crates/gpui/src/platform/test/platform.rs @@ -2,7 +2,7 @@ use crate::{ AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DevicePixels, ForegroundExecutor, Keymap, NoopTextSystem, Platform, PlatformDisplay, PlatformKeyboardLayout, PlatformTextSystem, PromptButton, ScreenCaptureFrame, ScreenCaptureSource, ScreenCaptureStream, - Size, Task, TestDisplay, TestWindow, WindowAppearance, WindowParams, size, + SourceMetadata, Task, TestDisplay, TestWindow, WindowAppearance, WindowParams, size, }; use anyhow::Result; use collections::VecDeque; @@ -44,11 +44,17 @@ pub(crate) struct TestPlatform { /// A fake screen capture source, used for testing. pub struct TestScreenCaptureSource {} +/// A fake screen capture stream, used for testing. pub struct TestScreenCaptureStream {} impl ScreenCaptureSource for TestScreenCaptureSource { - fn resolution(&self) -> Result> { - Ok(size(DevicePixels(1), DevicePixels(1))) + fn metadata(&self) -> Result { + Ok(SourceMetadata { + id: 0, + is_main: None, + label: None, + resolution: size(DevicePixels(1), DevicePixels(1)), + }) } fn stream( @@ -64,7 +70,11 @@ impl ScreenCaptureSource for TestScreenCaptureSource { } } -impl ScreenCaptureStream for TestScreenCaptureStream {} +impl ScreenCaptureStream for TestScreenCaptureStream { + fn metadata(&self) -> Result { + TestScreenCaptureSource {}.metadata() + } +} struct TestPrompt { msg: String, @@ -271,13 +281,13 @@ impl Platform for TestPlatform { #[cfg(feature = "screen-capture")] fn screen_capture_sources( &self, - ) -> oneshot::Receiver>>> { + ) -> oneshot::Receiver>>> { let (mut tx, rx) = oneshot::channel(); tx.send(Ok(self .screen_capture_sources .borrow() .iter() - .map(|source| Box::new(source.clone()) as Box) + .map(|source| Rc::new(source.clone()) as Rc) .collect())) .ok(); rx diff --git a/crates/gpui/src/platform/windows/platform.rs b/crates/gpui/src/platform/windows/platform.rs index f69a802da0..401ecdeffe 100644 --- a/crates/gpui/src/platform/windows/platform.rs +++ b/crates/gpui/src/platform/windows/platform.rs @@ -440,7 +440,7 @@ impl Platform for WindowsPlatform { #[cfg(feature = "screen-capture")] fn screen_capture_sources( &self, - ) -> oneshot::Receiver>>> { + ) -> oneshot::Receiver>>> { crate::platform::scap_screen_capture::scap_screen_sources(&self.foreground_executor) } diff --git a/crates/livekit_client/src/livekit_client/playback.rs b/crates/livekit_client/src/livekit_client/playback.rs index 7e36314c12..c62b8853b4 100644 --- a/crates/livekit_client/src/livekit_client/playback.rs +++ b/crates/livekit_client/src/livekit_client/playback.rs @@ -326,11 +326,11 @@ pub(crate) async fn capture_local_video_track( capture_source: &dyn ScreenCaptureSource, cx: &mut gpui::AsyncApp, ) -> Result<(crate::LocalVideoTrack, Box)> { - let resolution = capture_source.resolution()?; + let metadata = capture_source.metadata()?; let track_source = gpui_tokio::Tokio::spawn(cx, async move { NativeVideoSource::new(VideoResolution { - width: resolution.width.0 as u32, - height: resolution.height.0 as u32, + width: metadata.resolution.width.0 as u32, + height: metadata.resolution.height.0 as u32, }) })? .await?; diff --git a/crates/livekit_client/src/mock_client/participant.rs b/crates/livekit_client/src/mock_client/participant.rs index 1f4168b8e0..991d10bd50 100644 --- a/crates/livekit_client/src/mock_client/participant.rs +++ b/crates/livekit_client/src/mock_client/participant.rs @@ -5,7 +5,7 @@ use crate::{ }; use anyhow::Result; use collections::HashMap; -use gpui::{AsyncApp, ScreenCaptureSource, ScreenCaptureStream}; +use gpui::{AsyncApp, ScreenCaptureSource, ScreenCaptureStream, TestScreenCaptureStream}; #[derive(Clone, Debug)] pub struct LocalParticipant { @@ -119,7 +119,3 @@ impl RemoteParticipant { self.identity.clone() } } - -struct TestScreenCaptureStream; - -impl gpui::ScreenCaptureStream for TestScreenCaptureStream {} diff --git a/crates/title_bar/Cargo.toml b/crates/title_bar/Cargo.toml index 3c39e6b946..8e95c6f79f 100644 --- a/crates/title_bar/Cargo.toml +++ b/crates/title_bar/Cargo.toml @@ -27,6 +27,7 @@ test-support = [ ] [dependencies] +anyhow.workspace = true auto_update.workspace = true call.workspace = true chrono.workspace = true diff --git a/crates/title_bar/src/collab.rs b/crates/title_bar/src/collab.rs index b2a37a4f1c..1eebc0de0c 100644 --- a/crates/title_bar/src/collab.rs +++ b/crates/title_bar/src/collab.rs @@ -1,12 +1,20 @@ +use std::rc::Rc; use std::sync::Arc; use call::{ActiveCall, ParticipantLocation, Room}; use client::{User, proto::PeerId}; -use gpui::{AnyElement, Hsla, IntoElement, MouseButton, Path, Styled, canvas, point}; +use gpui::{ + AnyElement, Hsla, IntoElement, MouseButton, Path, ScreenCaptureSource, Styled, WeakEntity, + canvas, point, +}; use gpui::{App, Task, Window, actions}; use rpc::proto::{self}; use theme::ActiveTheme; -use ui::{Avatar, AvatarAudioStatusIndicator, Facepile, TintColor, Tooltip, prelude::*}; +use ui::{ + Avatar, AvatarAudioStatusIndicator, ContextMenu, ContextMenuItem, Facepile, PopoverMenu, + SplitButton, TintColor, Tooltip, prelude::*, +}; +use util::maybe; use workspace::notifications::DetachAndPromptErr; use crate::TitleBar; @@ -23,24 +31,49 @@ actions!( ] ); -fn toggle_screen_sharing(_: &ToggleScreenSharing, window: &mut Window, cx: &mut App) { +fn toggle_screen_sharing( + screen: Option>, + window: &mut Window, + cx: &mut App, +) { let call = ActiveCall::global(cx).read(cx); if let Some(room) = call.room().cloned() { let toggle_screen_sharing = room.update(cx, |room, cx| { - if room.is_screen_sharing() { + let clicked_on_currently_shared_screen = + room.shared_screen_id().is_some_and(|screen_id| { + Some(screen_id) + == screen + .as_deref() + .and_then(|s| s.metadata().ok().map(|meta| meta.id)) + }); + let should_unshare_current_screen = room.is_sharing_screen(); + let unshared_current_screen = should_unshare_current_screen.then(|| { telemetry::event!( "Screen Share Disabled", room_id = room.id(), channel_id = room.channel_id(), ); - Task::ready(room.unshare_screen(cx)) + room.unshare_screen(clicked_on_currently_shared_screen || screen.is_none(), cx) + }); + if let Some(screen) = screen { + if !should_unshare_current_screen { + telemetry::event!( + "Screen Share Enabled", + room_id = room.id(), + channel_id = room.channel_id(), + ); + } + cx.spawn(async move |room, cx| { + unshared_current_screen.transpose()?; + if !clicked_on_currently_shared_screen { + room.update(cx, |room, cx| room.share_screen(screen, cx))? + .await + } else { + Ok(()) + } + }) } else { - telemetry::event!( - "Screen Share Enabled", - room_id = room.id(), - channel_id = room.channel_id(), - ); - room.share_screen(cx) + Task::ready(Ok(())) } }); toggle_screen_sharing.detach_and_prompt_err("Sharing Screen Failed", window, cx, |e, _, _| Some(format!("{:?}\n\nPlease check that you have given Zed permissions to record your screen in Settings.", e))); @@ -303,7 +336,7 @@ impl TitleBar { let is_muted = room.is_muted(); let muted_by_user = room.muted_by_user(); let is_deafened = room.is_deafened().unwrap_or(false); - let is_screen_sharing = room.is_screen_sharing(); + let is_screen_sharing = room.is_sharing_screen(); let can_use_microphone = room.can_use_microphone(); let can_share_projects = room.can_share_projects(); let screen_sharing_supported = cx.is_screen_capture_supported(); @@ -428,21 +461,43 @@ impl TitleBar { ); if can_use_microphone && screen_sharing_supported { + let trigger = IconButton::new("screen-share", ui::IconName::Screen) + .style(ButtonStyle::Subtle) + .icon_size(IconSize::Small) + .toggle_state(is_screen_sharing) + .selected_style(ButtonStyle::Tinted(TintColor::Accent)) + .tooltip(Tooltip::text(if is_screen_sharing { + "Stop Sharing Screen" + } else { + "Share Screen" + })) + .on_click(move |_, window, cx| { + let should_share = ActiveCall::global(cx) + .read(cx) + .room() + .is_some_and(|room| !room.read(cx).is_sharing_screen()); + + window + .spawn(cx, async move |cx| { + let screen = if should_share { + cx.update(|_, cx| pick_default_screen(cx))?.await + } else { + None + }; + + cx.update(|window, cx| toggle_screen_sharing(screen, window, cx))?; + + Result::<_, anyhow::Error>::Ok(()) + }) + .detach(); + }); + children.push( - IconButton::new("screen-share", ui::IconName::Screen) - .style(ButtonStyle::Subtle) - .icon_size(IconSize::Small) - .toggle_state(is_screen_sharing) - .selected_style(ButtonStyle::Tinted(TintColor::Accent)) - .tooltip(Tooltip::text(if is_screen_sharing { - "Stop Sharing Screen" - } else { - "Share Screen" - })) - .on_click(move |_, window, cx| { - toggle_screen_sharing(&Default::default(), window, cx) - }) - .into_any_element(), + SplitButton::new( + trigger.render(window, cx), + self.render_screen_list().into_any_element(), + ) + .into_any_element(), ); } @@ -450,4 +505,89 @@ impl TitleBar { children } + + fn render_screen_list(&self) -> impl IntoElement { + PopoverMenu::new("screen-share-screen-list") + .with_handle(self.screen_share_popover_handle.clone()) + .trigger( + ui::ButtonLike::new_rounded_right("screen-share-screen-list-trigger") + .layer(ui::ElevationIndex::ModalSurface) + .size(ui::ButtonSize::None) + .child( + div() + .px_1() + .child(Icon::new(IconName::ChevronDownSmall).size(IconSize::XSmall)), + ) + .toggle_state(self.screen_share_popover_handle.is_deployed()), + ) + .menu(|window, cx| { + let screens = cx.screen_capture_sources(); + Some(ContextMenu::build(window, cx, |context_menu, _, cx| { + cx.spawn(async move |this: WeakEntity, cx| { + let screens = screens.await??; + this.update(cx, |this, cx| { + let active_screenshare_id = ActiveCall::global(cx) + .read(cx) + .room() + .and_then(|room| room.read(cx).shared_screen_id()); + for screen in screens { + let Ok(meta) = screen.metadata() else { + continue; + }; + + let label = meta + .label + .clone() + .unwrap_or_else(|| SharedString::from("Unknown screen")); + let resolution = SharedString::from(format!( + "{} × {}", + meta.resolution.width.0, meta.resolution.height.0 + )); + this.push_item(ContextMenuItem::CustomEntry { + entry_render: Box::new(move |_, _| { + h_flex() + .gap_2() + .child(Icon::new(IconName::Screen).when( + active_screenshare_id == Some(meta.id), + |this| this.color(Color::Accent), + )) + .child(Label::new(label.clone())) + .child( + Label::new(resolution.clone()) + .color(Color::Muted) + .size(LabelSize::Small), + ) + .into_any() + }), + selectable: true, + documentation_aside: None, + handler: Rc::new(move |_, window, cx| { + toggle_screen_sharing(Some(screen.clone()), window, cx); + }), + }); + } + }) + }) + .detach_and_log_err(cx); + context_menu + })) + }) + } +} + +/// Picks the screen to share when clicking on the main screen sharing button. +fn pick_default_screen(cx: &App) -> Task>> { + let source = cx.screen_capture_sources(); + cx.spawn(async move |_| { + let available_sources = maybe!(async move { source.await? }).await.ok()?; + available_sources + .iter() + .find(|it| { + it.as_ref() + .metadata() + .is_ok_and(|meta| meta.is_main.unwrap_or_default()) + }) + .or_else(|| available_sources.iter().next()) + .cloned() + }) } diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs index c4fdb16f4f..17c4c85b6d 100644 --- a/crates/title_bar/src/title_bar.rs +++ b/crates/title_bar/src/title_bar.rs @@ -36,7 +36,7 @@ use theme::ActiveTheme; use title_bar_settings::TitleBarSettings; use ui::{ Avatar, Button, ButtonLike, ButtonStyle, Chip, ContextMenu, Icon, IconName, IconSize, - IconWithIndicator, Indicator, PopoverMenu, Tooltip, h_flex, prelude::*, + IconWithIndicator, Indicator, PopoverMenu, PopoverMenuHandle, Tooltip, h_flex, prelude::*, }; use util::ResultExt; use workspace::{Workspace, notifications::NotifyResultExt}; @@ -131,6 +131,7 @@ pub struct TitleBar { application_menu: Option>, _subscriptions: Vec, banner: Entity, + screen_share_popover_handle: PopoverMenuHandle, } impl Render for TitleBar { @@ -295,6 +296,7 @@ impl TitleBar { client, _subscriptions: subscriptions, banner, + screen_share_popover_handle: Default::default(), } } diff --git a/crates/ui/src/components/button/icon_button.rs b/crates/ui/src/components/button/icon_button.rs index 050db6addd..e5d13e09cd 100644 --- a/crates/ui/src/components/button/icon_button.rs +++ b/crates/ui/src/components/button/icon_button.rs @@ -178,7 +178,8 @@ impl VisibleOnHover for IconButton { } impl RenderOnce for IconButton { - fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement { + #[allow(refining_impl_trait)] + fn render(self, window: &mut Window, cx: &mut App) -> ButtonLike { let is_disabled = self.base.disabled; let is_selected = self.base.selected; let selected_style = self.base.selected_style; diff --git a/crates/ui/src/components/context_menu.rs b/crates/ui/src/components/context_menu.rs index 467dd226fb..77468fd295 100644 --- a/crates/ui/src/components/context_menu.rs +++ b/crates/ui/src/components/context_menu.rs @@ -139,6 +139,8 @@ impl ContextMenuEntry { } } +impl FluentBuilder for ContextMenuEntry {} + impl From for ContextMenuItem { fn from(entry: ContextMenuEntry) -> Self { ContextMenuItem::Entry(entry) @@ -353,6 +355,10 @@ impl ContextMenu { self } + pub fn push_item(&mut self, item: impl Into) { + self.items.push(item.into()); + } + pub fn entry( mut self, label: impl Into, From 56fd950d940f13bcef6b93f9c4e2bb472acb707b Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Mon, 21 Jul 2025 09:26:31 -0300 Subject: [PATCH 0086/1052] thread view: Add ability to expand message editor and fix scroll (#34766) Release Notes: - N/A --- crates/agent_ui/src/acp/thread_view.rs | 173 ++++++++++++++++++------- crates/agent_ui/src/agent_panel.rs | 3 + crates/agent_ui/src/message_editor.rs | 10 +- 3 files changed, 135 insertions(+), 51 deletions(-) diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index 765f4fe6c0..d2903ab6eb 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -45,7 +45,8 @@ use ::acp_thread::{ use crate::acp::completion_provider::{ContextPickerCompletionProvider, MentionSet}; use crate::acp::message_history::MessageHistory; use crate::agent_diff::AgentDiff; -use crate::{AgentDiffPane, Follow, KeepAll, OpenAgentDiff, RejectAll}; +use crate::message_editor::{MAX_EDITOR_LINES, MIN_EDITOR_LINES}; +use crate::{AgentDiffPane, ExpandMessageEditor, Follow, KeepAll, OpenAgentDiff, RejectAll}; const RESPONSE_PADDING_X: Pixels = px(19.); @@ -65,6 +66,7 @@ pub struct AcpThreadView { expanded_tool_calls: HashSet, expanded_thinking_blocks: HashSet<(usize, usize)>, edits_expanded: bool, + editor_is_expanded: bool, message_history: Rc>>, } @@ -94,6 +96,8 @@ impl AcpThreadView { workspace: WeakEntity, project: Entity, message_history: Rc>>, + min_lines: usize, + max_lines: Option, window: &mut Window, cx: &mut Context, ) -> Self { @@ -113,8 +117,8 @@ impl AcpThreadView { let mut editor = Editor::new( editor::EditorMode::AutoHeight { - min_lines: 4, - max_lines: None, + min_lines, + max_lines: max_lines, }, buffer, None, @@ -182,6 +186,7 @@ impl AcpThreadView { expanded_tool_calls: HashSet::default(), expanded_thinking_blocks: HashSet::default(), edits_expanded: false, + editor_is_expanded: false, message_history, } } @@ -321,6 +326,35 @@ impl AcpThreadView { } } + pub fn expand_message_editor( + &mut self, + _: &ExpandMessageEditor, + _window: &mut Window, + cx: &mut Context, + ) { + self.set_editor_is_expanded(!self.editor_is_expanded, cx); + cx.notify(); + } + + fn set_editor_is_expanded(&mut self, is_expanded: bool, cx: &mut Context) { + self.editor_is_expanded = is_expanded; + self.message_editor.update(cx, |editor, _| { + if self.editor_is_expanded { + editor.set_mode(EditorMode::Full { + scale_ui_elements_with_buffer_font_size: false, + show_active_line_background: false, + sized_by_content: false, + }) + } else { + editor.set_mode(EditorMode::AutoHeight { + min_lines: MIN_EDITOR_LINES, + max_lines: Some(MAX_EDITOR_LINES), + }) + } + }); + cx.notify(); + } + fn chat(&mut self, _: &Chat, window: &mut Window, cx: &mut Context) { self.last_error.take(); @@ -381,6 +415,7 @@ impl AcpThreadView { let mention_set = self.mention_set.clone(); + self.set_editor_is_expanded(false, cx); self.message_editor.update(cx, |editor, cx| { editor.clear(window, cx); editor.remove_creases(mention_set.lock().drain(), cx) @@ -1793,34 +1828,96 @@ impl AcpThreadView { )) } - fn render_message_editor(&mut self, cx: &mut Context) -> AnyElement { - let settings = ThemeSettings::get_global(cx); - let font_size = TextSize::Small - .rems(cx) - .to_pixels(settings.agent_font_size(cx)); - let line_height = settings.buffer_line_height.value() * font_size; - - let text_style = TextStyle { - color: cx.theme().colors().text, - font_family: settings.buffer_font.family.clone(), - font_fallbacks: settings.buffer_font.fallbacks.clone(), - font_features: settings.buffer_font.features.clone(), - font_size: font_size.into(), - line_height: line_height.into(), - ..Default::default() + fn render_message_editor(&mut self, window: &mut Window, cx: &mut Context) -> AnyElement { + let focus_handle = self.message_editor.focus_handle(cx); + let editor_bg_color = cx.theme().colors().editor_background; + let (expand_icon, expand_tooltip) = if self.editor_is_expanded { + (IconName::Minimize, "Minimize Message Editor") + } else { + (IconName::Maximize, "Expand Message Editor") }; - EditorElement::new( - &self.message_editor, - EditorStyle { - background: cx.theme().colors().editor_background, - local_player: cx.theme().players().local(), - text: text_style, - syntax: cx.theme().syntax().clone(), - ..Default::default() - }, - ) - .into_any() + v_flex() + .on_action(cx.listener(Self::expand_message_editor)) + .p_2() + .gap_2() + .border_t_1() + .border_color(cx.theme().colors().border) + .bg(editor_bg_color) + .when(self.editor_is_expanded, |this| { + this.h(vh(0.8, window)).size_full().justify_between() + }) + .child( + v_flex() + .relative() + .size_full() + .pt_1() + .pr_2p5() + .child(div().flex_1().child({ + let settings = ThemeSettings::get_global(cx); + let font_size = TextSize::Small + .rems(cx) + .to_pixels(settings.agent_font_size(cx)); + let line_height = settings.buffer_line_height.value() * font_size; + + let text_style = TextStyle { + color: cx.theme().colors().text, + font_family: settings.buffer_font.family.clone(), + font_fallbacks: settings.buffer_font.fallbacks.clone(), + font_features: settings.buffer_font.features.clone(), + font_size: font_size.into(), + line_height: line_height.into(), + ..Default::default() + }; + + EditorElement::new( + &self.message_editor, + EditorStyle { + background: editor_bg_color, + local_player: cx.theme().players().local(), + text: text_style, + syntax: cx.theme().syntax().clone(), + ..Default::default() + }, + ) + })) + .child( + h_flex() + .absolute() + .top_0() + .right_0() + .opacity(0.5) + .hover(|this| this.opacity(1.0)) + .child( + IconButton::new("toggle-height", expand_icon) + .icon_size(IconSize::XSmall) + .icon_color(Color::Muted) + .tooltip({ + let focus_handle = focus_handle.clone(); + move |window, cx| { + Tooltip::for_action_in( + expand_tooltip, + &ExpandMessageEditor, + &focus_handle, + window, + cx, + ) + } + }) + .on_click(cx.listener(|_, _, window, cx| { + window.dispatch_action(Box::new(ExpandMessageEditor), cx); + })), + ), + ), + ) + .child( + h_flex() + .flex_none() + .justify_between() + .child(self.render_follow_toggle(cx)) + .child(self.render_send_button(cx)), + ) + .into_any() } fn render_send_button(&self, cx: &mut Context) -> AnyElement { @@ -2132,7 +2229,6 @@ impl Render for AcpThreadView { .px(RESPONSE_PADDING_X) .opacity(0.4) .hover(|style| style.opacity(1.)) - .gap_1() .flex_wrap() .justify_end() .child(open_as_markdown) @@ -2166,22 +2262,7 @@ impl Render for AcpThreadView { ), ) }) - .child( - v_flex() - .p_2() - .pt_3() - .gap_1() - .bg(cx.theme().colors().editor_background) - .border_t_1() - .border_color(cx.theme().colors().border) - .child(self.render_message_editor(cx)) - .child( - h_flex() - .justify_between() - .child(self.render_follow_toggle(cx)) - .child(self.render_send_button(cx)), - ), - ) + .child(self.render_message_editor(window, cx)) } } diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 7f2fbce189..36851e44ba 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -11,6 +11,7 @@ use serde::{Deserialize, Serialize}; use crate::NewExternalAgentThread; use crate::agent_diff::AgentDiffThread; +use crate::message_editor::{MAX_EDITOR_LINES, MIN_EDITOR_LINES}; use crate::{ AddContextServer, AgentDiffPane, ContinueThread, ContinueWithBurnMode, DeleteRecentlyOpenThread, ExpandMessageEditor, Follow, InlineAssistant, NewTextThread, @@ -960,6 +961,8 @@ impl AgentPanel { workspace.clone(), project, message_history, + MIN_EDITOR_LINES, + Some(MAX_EDITOR_LINES), window, cx, ) diff --git a/crates/agent_ui/src/message_editor.rs b/crates/agent_ui/src/message_editor.rs index ce9cc87fe3..a2cf4aac48 100644 --- a/crates/agent_ui/src/message_editor.rs +++ b/crates/agent_ui/src/message_editor.rs @@ -65,6 +65,9 @@ use agent::{ thread_store::{TextThreadStore, ThreadStore}, }; +pub const MIN_EDITOR_LINES: usize = 4; +pub const MAX_EDITOR_LINES: usize = 8; + #[derive(RegisterComponent)] pub struct MessageEditor { thread: Entity, @@ -88,9 +91,6 @@ pub struct MessageEditor { _subscriptions: Vec, } -const MIN_EDITOR_LINES: usize = 4; -const MAX_EDITOR_LINES: usize = 8; - pub(crate) fn create_editor( workspace: WeakEntity, context_store: WeakEntity, @@ -711,11 +711,11 @@ impl MessageEditor { cx.listener(|this, _: &RejectAll, window, cx| this.handle_reject_all(window, cx)), ) .capture_action(cx.listener(Self::paste)) - .gap_2() .p_2() - .bg(editor_bg_color) + .gap_2() .border_t_1() .border_color(cx.theme().colors().border) + .bg(editor_bg_color) .child( h_flex() .justify_between() From 35b4a918c91bedac4968dde188929bb59523e769 Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Mon, 21 Jul 2025 15:43:51 +0200 Subject: [PATCH 0087/1052] chore: Bump taffy to 0.5.1 (#34817) We've had problems in the past with bumping past 0.5.2 due to perf regressions reported by @huacnlee; 0.5.1 was fine though. Hence, let's bump taffy to 0.5.1 as a safe bet and then try to push past 0.5.2 (after we identify the root cause of regression Related to #19189 Release Notes: - N/A --- Cargo.lock | 8 ++++---- crates/gpui/Cargo.toml | 2 +- crates/gpui/src/taffy.rs | 2 +- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index bc69de7a7c..5ceed10b19 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7396,9 +7396,9 @@ dependencies = [ [[package]] name = "grid" -version = "0.13.0" +version = "0.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d196ffc1627db18a531359249b2bf8416178d84b729f3cebeb278f285fb9b58c" +checksum = "be136d9dacc2a13cc70bb6c8f902b414fb2641f8db1314637c6b7933411a8f82" [[package]] name = "group" @@ -15936,9 +15936,9 @@ dependencies = [ [[package]] name = "taffy" -version = "0.4.4" +version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ec17858c2d465b2f734b798b920818a974faf0babb15d7fef81818a4b2d16f1" +checksum = "9cb893bff0f80ae17d3a57e030622a967b8dbc90e38284d9b4b1442e23873c94" dependencies = [ "arrayvec", "grid", diff --git a/crates/gpui/Cargo.toml b/crates/gpui/Cargo.toml index d3462e9e9c..9da01c5ff3 100644 --- a/crates/gpui/Cargo.toml +++ b/crates/gpui/Cargo.toml @@ -121,7 +121,7 @@ smallvec.workspace = true smol.workspace = true strum.workspace = true sum_tree.workspace = true -taffy = "0.4.3" +taffy = "0.5.1" thiserror.workspace = true util.workspace = true uuid.workspace = true diff --git a/crates/gpui/src/taffy.rs b/crates/gpui/src/taffy.rs index f12c62d504..6228a60490 100644 --- a/crates/gpui/src/taffy.rs +++ b/crates/gpui/src/taffy.rs @@ -182,7 +182,7 @@ impl TaffyLayoutEngine { .compute_layout_with_measure( id.into(), available_space.into(), - |known_dimensions, available_space, _id, node_context| { + |known_dimensions, available_space, _id, node_context, _style| { let Some(node_context) = node_context else { return taffy::geometry::Size::default(); }; From 405244d422e3e2baf3660749e21e4cb5fcc5e82d Mon Sep 17 00:00:00 2001 From: Agus Zubiaga Date: Mon, 21 Jul 2025 11:11:37 -0300 Subject: [PATCH 0088/1052] Display ACP plans (#34816) Release Notes: - N/A --------- Co-authored-by: Danilo Leal --- Cargo.lock | 4 +- Cargo.toml | 2 +- assets/icons/todo_complete.svg | 4 + assets/icons/todo_pending.svg | 10 + assets/icons/todo_progress.svg | 11 ++ crates/acp_thread/src/acp_thread.rs | 109 ++++++++++- crates/agent_servers/src/claude.rs | 19 +- crates/agent_servers/src/claude/tools.rs | 30 +++ crates/agent_ui/src/acp/thread_view.rs | 221 ++++++++++++++++++++--- crates/icons/src/icons.rs | 3 + 10 files changed, 379 insertions(+), 34 deletions(-) create mode 100644 assets/icons/todo_complete.svg create mode 100644 assets/icons/todo_pending.svg create mode 100644 assets/icons/todo_progress.svg diff --git a/Cargo.lock b/Cargo.lock index 5ceed10b19..a323fb70af 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -279,9 +279,9 @@ dependencies = [ [[package]] name = "agentic-coding-protocol" -version = "0.0.9" +version = "0.0.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0e276b798eddd02562a339340a96919d90bbfcf78de118fdddc932524646fac7" +checksum = "a3e6ae951b36fa2f8d9dd6e1af6da2fcaba13d7c866cf6a9e65deda9dc6c5fe4" dependencies = [ "anyhow", "chrono", diff --git a/Cargo.toml b/Cargo.toml index 0169d32eb6..c99ba3953d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -410,7 +410,7 @@ zlog_settings = { path = "crates/zlog_settings" } # External crates # -agentic-coding-protocol = "0.0.9" +agentic-coding-protocol = "0.0.10" aho-corasick = "1.1" alacritty_terminal = { git = "https://github.com/zed-industries/alacritty.git", branch = "add-hush-login-flag" } any_vec = "0.14" diff --git a/assets/icons/todo_complete.svg b/assets/icons/todo_complete.svg new file mode 100644 index 0000000000..9fa2e818bb --- /dev/null +++ b/assets/icons/todo_complete.svg @@ -0,0 +1,4 @@ + + + + diff --git a/assets/icons/todo_pending.svg b/assets/icons/todo_pending.svg new file mode 100644 index 0000000000..dfb013b52b --- /dev/null +++ b/assets/icons/todo_pending.svg @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/assets/icons/todo_progress.svg b/assets/icons/todo_progress.svg new file mode 100644 index 0000000000..9b2ed7375d --- /dev/null +++ b/assets/icons/todo_progress.svg @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/crates/acp_thread/src/acp_thread.rs b/crates/acp_thread/src/acp_thread.rs index ae22725d5e..9af1eeb187 100644 --- a/crates/acp_thread/src/acp_thread.rs +++ b/crates/acp_thread/src/acp_thread.rs @@ -453,9 +453,69 @@ impl Diff { } } +#[derive(Debug, Default)] +pub struct Plan { + pub entries: Vec, +} + +#[derive(Debug)] +pub struct PlanStats<'a> { + pub in_progress_entry: Option<&'a PlanEntry>, + pub pending: u32, + pub completed: u32, +} + +impl Plan { + pub fn is_empty(&self) -> bool { + self.entries.is_empty() + } + + pub fn stats(&self) -> PlanStats<'_> { + let mut stats = PlanStats { + in_progress_entry: None, + pending: 0, + completed: 0, + }; + + for entry in &self.entries { + match &entry.status { + acp::PlanEntryStatus::Pending => { + stats.pending += 1; + } + acp::PlanEntryStatus::InProgress => { + stats.in_progress_entry = stats.in_progress_entry.or(Some(entry)); + } + acp::PlanEntryStatus::Completed => { + stats.completed += 1; + } + } + } + + stats + } +} + +#[derive(Debug)] +pub struct PlanEntry { + pub content: Entity, + pub priority: acp::PlanEntryPriority, + pub status: acp::PlanEntryStatus, +} + +impl PlanEntry { + pub fn from_acp(entry: acp::PlanEntry, cx: &mut App) -> Self { + Self { + content: cx.new(|cx| Markdown::new_text(entry.content.into(), cx)), + priority: entry.priority, + status: entry.status, + } + } +} + pub struct AcpThread { - entries: Vec, title: SharedString, + entries: Vec, + plan: Plan, project: Entity, action_log: Entity, shared_buffers: HashMap, BufferSnapshot>, @@ -515,6 +575,7 @@ impl AcpThread { action_log, shared_buffers: Default::default(), entries: Default::default(), + plan: Default::default(), title, project, send_task: None, @@ -819,6 +880,29 @@ impl AcpThread { } } + pub fn plan(&self) -> &Plan { + &self.plan + } + + pub fn update_plan(&mut self, request: acp::UpdatePlanParams, cx: &mut Context) { + self.plan = Plan { + entries: request + .entries + .into_iter() + .map(|entry| PlanEntry::from_acp(entry, cx)) + .collect(), + }; + + cx.notify(); + } + + pub fn clear_completed_plan_entries(&mut self, cx: &mut Context) { + self.plan + .entries + .retain(|entry| !matches!(entry.status, acp::PlanEntryStatus::Completed)); + cx.notify(); + } + pub fn set_project_location(&self, location: ToolCallLocation, cx: &mut Context) { self.project.update(cx, |project, cx| { let Some(path) = project.project_path_for_absolute_path(&location.path, cx) else { @@ -1136,6 +1220,17 @@ impl AcpClientDelegate { Self { thread, cx } } + pub async fn clear_completed_plan_entries(&self) -> Result<()> { + let cx = &mut self.cx.clone(); + cx.update(|cx| { + self.thread + .update(cx, |thread, cx| thread.clear_completed_plan_entries(cx)) + })? + .context("Failed to update thread")?; + + Ok(()) + } + pub async fn request_existing_tool_call_confirmation( &self, tool_call_id: ToolCallId, @@ -1233,6 +1328,18 @@ impl acp::Client for AcpClientDelegate { Ok(()) } + async fn update_plan(&self, request: acp::UpdatePlanParams) -> Result<(), acp::Error> { + let cx = &mut self.cx.clone(); + + cx.update(|cx| { + self.thread + .update(cx, |thread, cx| thread.update_plan(request, cx)) + })? + .context("Failed to update thread")?; + + Ok(()) + } + async fn read_text_file( &self, request: acp::ReadTextFileParams, diff --git a/crates/agent_servers/src/claude.rs b/crates/agent_servers/src/claude.rs index 52c6012267..8b3d93a122 100644 --- a/crates/agent_servers/src/claude.rs +++ b/crates/agent_servers/src/claude.rs @@ -153,6 +153,7 @@ impl AgentServer for ClaudeCode { let handler_task = cx.foreground_executor().spawn({ let end_turn_tx = end_turn_tx.clone(); let tool_id_map = tool_id_map.clone(); + let delegate = delegate.clone(); async move { while let Some(message) = incoming_message_rx.next().await { ClaudeAgentConnection::handle_message( @@ -167,6 +168,7 @@ impl AgentServer for ClaudeCode { }); let mut connection = ClaudeAgentConnection { + delegate, outgoing_tx, end_turn_tx, _handler_task: handler_task, @@ -186,6 +188,7 @@ impl AgentConnection for ClaudeAgentConnection { &self, params: AnyAgentRequest, ) -> LocalBoxFuture<'static, Result> { + let delegate = self.delegate.clone(); let end_turn_tx = self.end_turn_tx.clone(); let outgoing_tx = self.outgoing_tx.clone(); async move { @@ -201,6 +204,8 @@ impl AgentConnection for ClaudeAgentConnection { Err(anyhow!("Authentication not supported")) } AnyAgentRequest::SendUserMessageParams(message) => { + delegate.clear_completed_plan_entries().await?; + let (tx, rx) = oneshot::channel(); end_turn_tx.borrow_mut().replace(tx); let mut content = String::new(); @@ -241,6 +246,7 @@ impl AgentConnection for ClaudeAgentConnection { } struct ClaudeAgentConnection { + delegate: AcpClientDelegate, outgoing_tx: UnboundedSender, end_turn_tx: Rc>>>>, _mcp_server: Option, @@ -267,8 +273,17 @@ impl ClaudeAgentConnection { .log_err(); } ContentChunk::ToolUse { id, name, input } => { - if let Some(resp) = delegate - .push_tool_call(ClaudeTool::infer(&name, input).as_acp()) + let claude_tool = ClaudeTool::infer(&name, input); + + if let ClaudeTool::TodoWrite(Some(params)) = claude_tool { + delegate + .update_plan(acp::UpdatePlanParams { + entries: params.todos.into_iter().map(Into::into).collect(), + }) + .await + .log_err(); + } else if let Some(resp) = delegate + .push_tool_call(claude_tool.as_acp()) .await .log_err() { diff --git a/crates/agent_servers/src/claude/tools.rs b/crates/agent_servers/src/claude/tools.rs index a2d6b487b2..9c82139a07 100644 --- a/crates/agent_servers/src/claude/tools.rs +++ b/crates/agent_servers/src/claude/tools.rs @@ -614,6 +614,16 @@ pub enum TodoPriority { Low, } +impl Into for TodoPriority { + fn into(self) -> acp::PlanEntryPriority { + match self { + TodoPriority::High => acp::PlanEntryPriority::High, + TodoPriority::Medium => acp::PlanEntryPriority::Medium, + TodoPriority::Low => acp::PlanEntryPriority::Low, + } + } +} + #[derive(Deserialize, Serialize, JsonSchema, Debug)] #[serde(rename_all = "snake_case")] pub enum TodoStatus { @@ -622,6 +632,16 @@ pub enum TodoStatus { Completed, } +impl Into for TodoStatus { + fn into(self) -> acp::PlanEntryStatus { + match self { + TodoStatus::Pending => acp::PlanEntryStatus::Pending, + TodoStatus::InProgress => acp::PlanEntryStatus::InProgress, + TodoStatus::Completed => acp::PlanEntryStatus::Completed, + } + } +} + #[derive(Deserialize, Serialize, JsonSchema, Debug)] pub struct Todo { /// Unique identifier @@ -634,6 +654,16 @@ pub struct Todo { pub status: TodoStatus, } +impl Into for Todo { + fn into(self) -> acp::PlanEntry { + acp::PlanEntry { + content: self.content, + priority: self.priority.into(), + status: self.status.into(), + } + } +} + #[derive(Deserialize, JsonSchema, Debug)] pub struct TodoWriteToolParams { pub todos: Vec, diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index d2903ab6eb..95f4f81205 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -1,3 +1,4 @@ +use acp_thread::Plan; use agent_servers::AgentServer; use std::cell::RefCell; use std::collections::BTreeMap; @@ -66,7 +67,8 @@ pub struct AcpThreadView { expanded_tool_calls: HashSet, expanded_thinking_blocks: HashSet<(usize, usize)>, edits_expanded: bool, - editor_is_expanded: bool, + plan_expanded: bool, + editor_expanded: bool, message_history: Rc>>, } @@ -186,7 +188,8 @@ impl AcpThreadView { expanded_tool_calls: HashSet::default(), expanded_thinking_blocks: HashSet::default(), edits_expanded: false, - editor_is_expanded: false, + plan_expanded: false, + editor_expanded: false, message_history, } } @@ -332,14 +335,14 @@ impl AcpThreadView { _window: &mut Window, cx: &mut Context, ) { - self.set_editor_is_expanded(!self.editor_is_expanded, cx); + self.set_editor_is_expanded(!self.editor_expanded, cx); cx.notify(); } fn set_editor_is_expanded(&mut self, is_expanded: bool, cx: &mut Context) { - self.editor_is_expanded = is_expanded; + self.editor_expanded = is_expanded; self.message_editor.update(cx, |editor, _| { - if self.editor_is_expanded { + if self.editor_expanded { editor.set_mode(EditorMode::Full { scale_ui_elements_with_buffer_font_size: false, show_active_line_background: false, @@ -1477,7 +1480,7 @@ impl AcpThreadView { container.into_any() } - fn render_edits_bar( + fn render_activity_bar( &self, thread_entity: &Entity, window: &mut Window, @@ -1486,8 +1489,9 @@ impl AcpThreadView { let thread = thread_entity.read(cx); let action_log = thread.action_log(); let changed_buffers = action_log.read(cx).changed_buffers(cx); + let plan = thread.plan(); - if changed_buffers.is_empty() { + if changed_buffers.is_empty() && plan.is_empty() { return None; } @@ -1496,7 +1500,6 @@ impl AcpThreadView { let bg_edit_files_disclosure = editor_bg_color.blend(active_color.opacity(0.3)); let pending_edits = thread.has_pending_edit_tool_calls(); - let expanded = self.edits_expanded; v_flex() .mt_1() @@ -1512,27 +1515,165 @@ impl AcpThreadView { blur_radius: px(3.), spread_radius: px(0.), }]) - .child(self.render_edits_bar_summary( - action_log, - &changed_buffers, - expanded, - pending_edits, - window, - cx, - )) - .when(expanded, |parent| { - parent.child(self.render_edits_bar_files( - action_log, - &changed_buffers, - pending_edits, - cx, - )) + .when(!plan.is_empty(), |this| { + this.child(self.render_plan_summary(plan, window, cx)) + .when(self.plan_expanded, |parent| { + parent.child(self.render_plan_entries(plan, window, cx)) + }) + }) + .when(!changed_buffers.is_empty(), |this| { + this.child(Divider::horizontal()) + .child(self.render_edits_summary( + action_log, + &changed_buffers, + self.edits_expanded, + pending_edits, + window, + cx, + )) + .when(self.edits_expanded, |parent| { + parent.child(self.render_edited_files( + action_log, + &changed_buffers, + pending_edits, + cx, + )) + }) }) .into_any() .into() } - fn render_edits_bar_summary( + fn render_plan_summary(&self, plan: &Plan, window: &mut Window, cx: &Context) -> Div { + let stats = plan.stats(); + + let title = if let Some(entry) = stats.in_progress_entry + && !self.plan_expanded + { + h_flex() + .w_full() + .gap_1() + .text_xs() + .text_color(cx.theme().colors().text_muted) + .justify_between() + .child( + h_flex() + .gap_1() + .child( + Label::new("Current:") + .size(LabelSize::Small) + .color(Color::Muted), + ) + .child(MarkdownElement::new( + entry.content.clone(), + plan_label_markdown_style(&entry.status, window, cx), + )), + ) + .when(stats.pending > 0, |this| { + this.child( + Label::new(format!("{} left", stats.pending)) + .size(LabelSize::Small) + .color(Color::Muted) + .mr_1(), + ) + }) + } else { + let status_label = if stats.pending == 0 { + "All Done".to_string() + } else if stats.completed == 0 { + format!("{}", plan.entries.len()) + } else { + format!("{}/{}", stats.completed, plan.entries.len()) + }; + + h_flex() + .w_full() + .gap_1() + .justify_between() + .child( + Label::new("Plan") + .size(LabelSize::Small) + .color(Color::Muted), + ) + .child( + Label::new(status_label) + .size(LabelSize::Small) + .color(Color::Muted) + .mr_1(), + ) + }; + + h_flex() + .p_1() + .justify_between() + .when(self.plan_expanded, |this| { + this.border_b_1().border_color(cx.theme().colors().border) + }) + .child( + h_flex() + .id("plan_summary") + .w_full() + .gap_1() + .child(Disclosure::new("plan_disclosure", self.plan_expanded)) + .child(title) + .on_click(cx.listener(|this, _, _, cx| { + this.plan_expanded = !this.plan_expanded; + cx.notify(); + })), + ) + } + + fn render_plan_entries(&self, plan: &Plan, window: &mut Window, cx: &Context) -> Div { + v_flex().children(plan.entries.iter().enumerate().flat_map(|(index, entry)| { + let element = h_flex() + .py_1() + .px_2() + .gap_2() + .justify_between() + .bg(cx.theme().colors().editor_background) + .when(index < plan.entries.len() - 1, |parent| { + parent.border_color(cx.theme().colors().border).border_b_1() + }) + .child( + h_flex() + .id(("plan_entry", index)) + .gap_1p5() + .max_w_full() + .overflow_x_scroll() + .text_xs() + .text_color(cx.theme().colors().text_muted) + .child(match entry.status { + acp::PlanEntryStatus::Pending => Icon::new(IconName::TodoPending) + .size(IconSize::Small) + .color(Color::Muted) + .into_any_element(), + acp::PlanEntryStatus::InProgress => Icon::new(IconName::TodoProgress) + .size(IconSize::Small) + .color(Color::Accent) + .with_animation( + "running", + Animation::new(Duration::from_secs(2)).repeat(), + |icon, delta| { + icon.transform(Transformation::rotate(percentage(delta))) + }, + ) + .into_any_element(), + acp::PlanEntryStatus::Completed => Icon::new(IconName::TodoComplete) + .size(IconSize::Small) + .color(Color::Success) + .into_any_element(), + }) + .child(MarkdownElement::new( + entry.content.clone(), + plan_label_markdown_style(&entry.status, window, cx), + )), + ); + + Some(element) + })) + } + + fn render_edits_summary( &self, action_log: &Entity, changed_buffers: &BTreeMap, Entity>, @@ -1678,7 +1819,7 @@ impl AcpThreadView { ) } - fn render_edits_bar_files( + fn render_edited_files( &self, action_log: &Entity, changed_buffers: &BTreeMap, Entity>, @@ -1831,7 +1972,7 @@ impl AcpThreadView { fn render_message_editor(&mut self, window: &mut Window, cx: &mut Context) -> AnyElement { let focus_handle = self.message_editor.focus_handle(cx); let editor_bg_color = cx.theme().colors().editor_background; - let (expand_icon, expand_tooltip) = if self.editor_is_expanded { + let (expand_icon, expand_tooltip) = if self.editor_expanded { (IconName::Minimize, "Minimize Message Editor") } else { (IconName::Maximize, "Expand Message Editor") @@ -1844,7 +1985,7 @@ impl AcpThreadView { .border_t_1() .border_color(cx.theme().colors().border) .bg(editor_bg_color) - .when(self.editor_is_expanded, |this| { + .when(self.editor_expanded, |this| { this.h(vh(0.8, window)).size_full().justify_between() }) .child( @@ -2243,7 +2384,7 @@ impl Render for AcpThreadView { .child(LoadingLabel::new("").size(LabelSize::Small)) .into(), }) - .children(self.render_edits_bar(&thread, window, cx)) + .children(self.render_activity_bar(&thread, window, cx)) } else { this.child(self.render_empty_state(cx)) } @@ -2409,3 +2550,27 @@ fn default_markdown_style(buffer_font: bool, window: &Window, cx: &App) -> Markd ..Default::default() } } + +fn plan_label_markdown_style( + status: &acp::PlanEntryStatus, + window: &Window, + cx: &App, +) -> MarkdownStyle { + let default_md_style = default_markdown_style(false, window, cx); + + MarkdownStyle { + base_text_style: TextStyle { + color: cx.theme().colors().text_muted, + strikethrough: if matches!(status, acp::PlanEntryStatus::Completed) { + Some(gpui::StrikethroughStyle { + thickness: px(1.), + color: Some(cx.theme().colors().text_muted.opacity(0.8)), + }) + } else { + None + }, + ..default_md_style.base_text_style + }, + ..default_md_style + } +} diff --git a/crates/icons/src/icons.rs b/crates/icons/src/icons.rs index 6834d56215..631ccc1af3 100644 --- a/crates/icons/src/icons.rs +++ b/crates/icons/src/icons.rs @@ -256,6 +256,9 @@ pub enum IconName { TextSnippet, ThumbsDown, ThumbsUp, + TodoComplete, + TodoPending, + TodoProgress, ToolBulb, ToolCopy, ToolDeleteFile, From cc561961525b5e47e2a6eba52b3382233b6d49a6 Mon Sep 17 00:00:00 2001 From: Agus Zubiaga Date: Mon, 21 Jul 2025 11:26:00 -0300 Subject: [PATCH 0089/1052] Fix loading agent server settings (#34662) Release Notes: - N/A --- crates/agent_servers/src/settings.rs | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/crates/agent_servers/src/settings.rs b/crates/agent_servers/src/settings.rs index 29dcf5eb8c..645674b5f1 100644 --- a/crates/agent_servers/src/settings.rs +++ b/crates/agent_servers/src/settings.rs @@ -29,9 +29,12 @@ impl settings::Settings for AllAgentServersSettings { fn load(sources: SettingsSources, _: &mut App) -> Result { let mut settings = AllAgentServersSettings::default(); - for value in sources.defaults_and_customizations() { - if value.gemini.is_some() { - settings.gemini = value.gemini.clone(); + for AllAgentServersSettings { gemini, claude } in sources.defaults_and_customizations() { + if gemini.is_some() { + settings.gemini = gemini.clone(); + } + if claude.is_some() { + settings.claude = claude.clone(); } } From c251f2a2d4f655b3380b532b74231e214398230f Mon Sep 17 00:00:00 2001 From: Kamal Ahmad Date: Mon, 21 Jul 2025 19:48:01 +0500 Subject: [PATCH 0090/1052] gpui: Throttle interactive resize events on Wayland (#34760) Wayland compositors can potentially generate thousands of resize requests when drag-resizing a window, which Zed is unable to keep up with. This commit changes the behavior to only resize once per vblank cycle, which helps significantly when resizing the window with a high poll-rate mouse (1000Hz is common these days) Here is an example of the behavior pre and post this commit, with some print-debugging added for tracking resize calls. I have a wireless mouse with a 2000Hz polling rate and a 165Hz display: Before: https://github.com/user-attachments/assets/4c657f90-5fd2-4809-97ef-363fd48e81b8 After: https://github.com/user-attachments/assets/4a0f5fbd-c3c4-40a1-9f71-3b4358c827cf Closes #20660 Release Notes: - Improved: Make resizing smoother on Wayland/Linux --- crates/gpui/src/platform/linux/wayland/window.rs | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/crates/gpui/src/platform/linux/wayland/window.rs b/crates/gpui/src/platform/linux/wayland/window.rs index 36e070b0b0..255ae9c372 100644 --- a/crates/gpui/src/platform/linux/wayland/window.rs +++ b/crates/gpui/src/platform/linux/wayland/window.rs @@ -76,6 +76,7 @@ struct InProgressConfigure { size: Option>, fullscreen: bool, maximized: bool, + resizing: bool, tiling: Tiling, } @@ -107,6 +108,7 @@ pub struct WaylandWindowState { active: bool, hovered: bool, in_progress_configure: Option, + resize_throttle: bool, in_progress_window_controls: Option, window_controls: WindowControls, inset: Option, @@ -176,6 +178,7 @@ impl WaylandWindowState { tiling: Tiling::default(), window_bounds: options.bounds, in_progress_configure: None, + resize_throttle: false, client, appearance, handle, @@ -335,6 +338,7 @@ impl WaylandWindowStatePtr { pub fn frame(&self) { let mut state = self.state.borrow_mut(); state.surface.frame(&state.globals.qh, state.surface.id()); + state.resize_throttle = false; drop(state); let mut cb = self.callbacks.borrow_mut(); @@ -366,6 +370,12 @@ impl WaylandWindowStatePtr { state.fullscreen = configure.fullscreen; state.maximized = configure.maximized; state.tiling = configure.tiling; + // Limit interactive resizes to once per vblank + if configure.resizing && state.resize_throttle { + return; + } else if configure.resizing { + state.resize_throttle = true; + } if !configure.fullscreen && !configure.maximized { configure.size = if got_unmaximized { Some(state.window_bounds.size) @@ -472,6 +482,7 @@ impl WaylandWindowStatePtr { let mut tiling = Tiling::default(); let mut fullscreen = false; let mut maximized = false; + let mut resizing = false; for state in states { match state { @@ -481,6 +492,7 @@ impl WaylandWindowStatePtr { xdg_toplevel::State::Fullscreen => { fullscreen = true; } + xdg_toplevel::State::Resizing => resizing = true, xdg_toplevel::State::TiledTop => { tiling.top = true; } @@ -508,6 +520,7 @@ impl WaylandWindowStatePtr { size, fullscreen, maximized, + resizing, tiling, }); From 97af7e1bd92eb5c3bdd038e596378dc4054902f6 Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Mon, 21 Jul 2025 11:29:16 -0400 Subject: [PATCH 0091/1052] collab: Remove `PUT /billing/preferences` endpoint (#34825) This PR removes the `PUT /billing/preferences` endpoint, as it has been moved to `cloud.zed.dev`. Release Notes: - N/A --- crates/collab/src/api/billing.rs | 110 +------------------------------ 1 file changed, 2 insertions(+), 108 deletions(-) diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs index 09f307c672..9aa6578b2a 100644 --- a/crates/collab/src/api/billing.rs +++ b/crates/collab/src/api/billing.rs @@ -1,12 +1,10 @@ use anyhow::{Context as _, bail}; -use axum::routing::put; use axum::{Extension, Json, Router, extract, routing::post}; -use chrono::{DateTime, SecondsFormat, Utc}; +use chrono::{DateTime, Utc}; use collections::{HashMap, HashSet}; use reqwest::StatusCode; use sea_orm::ActiveValue; use serde::{Deserialize, Serialize}; -use serde_json::json; use std::{str::FromStr, sync::Arc, time::Duration}; use stripe::{ BillingPortalSession, CancellationDetailsReason, CreateBillingPortalSession, @@ -20,7 +18,6 @@ use stripe::{ use util::{ResultExt, maybe}; use zed_llm_client::LanguageModelProvider; -use crate::api::events::SnowflakeRow; use crate::db::billing_subscription::{ StripeCancellationReason, StripeSubscriptionStatus, SubscriptionKind, }; @@ -36,14 +33,13 @@ use crate::{ db::{ BillingSubscriptionId, CreateBillingCustomerParams, CreateBillingSubscriptionParams, CreateProcessedStripeEventParams, UpdateBillingCustomerParams, - UpdateBillingPreferencesParams, UpdateBillingSubscriptionParams, billing_customer, + UpdateBillingSubscriptionParams, billing_customer, }, stripe_billing::StripeBilling, }; pub fn router() -> Router { Router::new() - .route("/billing/preferences", put(update_billing_preferences)) .route("/billing/subscriptions", post(create_billing_subscription)) .route( "/billing/subscriptions/manage", @@ -55,108 +51,6 @@ pub fn router() -> Router { ) } -#[derive(Debug, Serialize)] -struct BillingPreferencesResponse { - trial_started_at: Option, - max_monthly_llm_usage_spending_in_cents: i32, - model_request_overages_enabled: bool, - model_request_overages_spend_limit_in_cents: i32, -} - -#[derive(Debug, Deserialize)] -struct UpdateBillingPreferencesBody { - github_user_id: i32, - #[serde(default)] - max_monthly_llm_usage_spending_in_cents: i32, - #[serde(default)] - model_request_overages_enabled: bool, - #[serde(default)] - model_request_overages_spend_limit_in_cents: i32, -} - -async fn update_billing_preferences( - Extension(app): Extension>, - Extension(rpc_server): Extension>, - extract::Json(body): extract::Json, -) -> Result> { - let user = app - .db - .get_user_by_github_user_id(body.github_user_id) - .await? - .context("user not found")?; - - let billing_customer = app.db.get_billing_customer_by_user_id(user.id).await?; - - let max_monthly_llm_usage_spending_in_cents = - body.max_monthly_llm_usage_spending_in_cents.max(0); - let model_request_overages_spend_limit_in_cents = - body.model_request_overages_spend_limit_in_cents.max(0); - - let billing_preferences = - if let Some(_billing_preferences) = app.db.get_billing_preferences(user.id).await? { - app.db - .update_billing_preferences( - user.id, - &UpdateBillingPreferencesParams { - max_monthly_llm_usage_spending_in_cents: ActiveValue::set( - max_monthly_llm_usage_spending_in_cents, - ), - model_request_overages_enabled: ActiveValue::set( - body.model_request_overages_enabled, - ), - model_request_overages_spend_limit_in_cents: ActiveValue::set( - model_request_overages_spend_limit_in_cents, - ), - }, - ) - .await? - } else { - app.db - .create_billing_preferences( - user.id, - &crate::db::CreateBillingPreferencesParams { - max_monthly_llm_usage_spending_in_cents, - model_request_overages_enabled: body.model_request_overages_enabled, - model_request_overages_spend_limit_in_cents, - }, - ) - .await? - }; - - SnowflakeRow::new( - "Billing Preferences Updated", - Some(user.metrics_id), - user.admin, - None, - json!({ - "user_id": user.id, - "model_request_overages_enabled": billing_preferences.model_request_overages_enabled, - "model_request_overages_spend_limit_in_cents": billing_preferences.model_request_overages_spend_limit_in_cents, - "max_monthly_llm_usage_spending_in_cents": billing_preferences.max_monthly_llm_usage_spending_in_cents, - }), - ) - .write(&app.kinesis_client, &app.config.kinesis_stream) - .await - .log_err(); - - rpc_server.refresh_llm_tokens_for_user(user.id).await; - - Ok(Json(BillingPreferencesResponse { - trial_started_at: billing_customer - .and_then(|billing_customer| billing_customer.trial_started_at) - .map(|trial_started_at| { - trial_started_at - .and_utc() - .to_rfc3339_opts(SecondsFormat::Millis, true) - }), - max_monthly_llm_usage_spending_in_cents: billing_preferences - .max_monthly_llm_usage_spending_in_cents, - model_request_overages_enabled: billing_preferences.model_request_overages_enabled, - model_request_overages_spend_limit_in_cents: billing_preferences - .model_request_overages_spend_limit_in_cents, - })) -} - #[derive(Debug, PartialEq, Clone, Copy, Deserialize)] #[serde(rename_all = "snake_case")] enum ProductCode { From e14c9479e40e3ce83c4222b974fc22c0fb81c5e5 Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Mon, 21 Jul 2025 17:36:52 +0200 Subject: [PATCH 0092/1052] chore: Pin taffy version (#34827) Follow-up to 34817 Closes #ISSUE Release Notes: - N/A *or* Added/Fixed/Improved ... --- Cargo.lock | 4 ++-- crates/gpui/Cargo.toml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index a323fb70af..c0d8dabf09 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -15936,9 +15936,9 @@ dependencies = [ [[package]] name = "taffy" -version = "0.5.2" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9cb893bff0f80ae17d3a57e030622a967b8dbc90e38284d9b4b1442e23873c94" +checksum = "e8b61630cba2afd2c851821add2e1bb1b7851a2436e839ab73b56558b009035e" dependencies = [ "arrayvec", "grid", diff --git a/crates/gpui/Cargo.toml b/crates/gpui/Cargo.toml index 9da01c5ff3..878794647a 100644 --- a/crates/gpui/Cargo.toml +++ b/crates/gpui/Cargo.toml @@ -121,7 +121,7 @@ smallvec.workspace = true smol.workspace = true strum.workspace = true sum_tree.workspace = true -taffy = "0.5.1" +taffy = "=0.5.1" thiserror.workspace = true util.workspace = true uuid.workspace = true From bf8aba566ce81a5bb1dfc4c5c70810695076f339 Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Mon, 21 Jul 2025 11:47:40 -0400 Subject: [PATCH 0093/1052] collab: Remove unused billing preferences queries (#34830) This PR removes some billing preferences queries that are no longer in use. Release Notes: - N/A --- crates/collab/src/db.rs | 3 - .../src/db/queries/billing_preferences.rs | 74 ------------------- 2 files changed, 77 deletions(-) diff --git a/crates/collab/src/db.rs b/crates/collab/src/db.rs index cc29245697..8cd1e3ea83 100644 --- a/crates/collab/src/db.rs +++ b/crates/collab/src/db.rs @@ -42,9 +42,6 @@ pub use tests::TestDb; pub use ids::*; pub use queries::billing_customers::{CreateBillingCustomerParams, UpdateBillingCustomerParams}; -pub use queries::billing_preferences::{ - CreateBillingPreferencesParams, UpdateBillingPreferencesParams, -}; pub use queries::billing_subscriptions::{ CreateBillingSubscriptionParams, UpdateBillingSubscriptionParams, }; diff --git a/crates/collab/src/db/queries/billing_preferences.rs b/crates/collab/src/db/queries/billing_preferences.rs index 1a6fbe946a..f370964ecd 100644 --- a/crates/collab/src/db/queries/billing_preferences.rs +++ b/crates/collab/src/db/queries/billing_preferences.rs @@ -1,21 +1,5 @@ -use anyhow::Context as _; - use super::*; -#[derive(Debug)] -pub struct CreateBillingPreferencesParams { - pub max_monthly_llm_usage_spending_in_cents: i32, - pub model_request_overages_enabled: bool, - pub model_request_overages_spend_limit_in_cents: i32, -} - -#[derive(Debug, Default)] -pub struct UpdateBillingPreferencesParams { - pub max_monthly_llm_usage_spending_in_cents: ActiveValue, - pub model_request_overages_enabled: ActiveValue, - pub model_request_overages_spend_limit_in_cents: ActiveValue, -} - impl Database { /// Returns the billing preferences for the given user, if they exist. pub async fn get_billing_preferences( @@ -30,62 +14,4 @@ impl Database { }) .await } - - /// Creates new billing preferences for the given user. - pub async fn create_billing_preferences( - &self, - user_id: UserId, - params: &CreateBillingPreferencesParams, - ) -> Result { - self.transaction(|tx| async move { - let preferences = billing_preference::Entity::insert(billing_preference::ActiveModel { - user_id: ActiveValue::set(user_id), - max_monthly_llm_usage_spending_in_cents: ActiveValue::set( - params.max_monthly_llm_usage_spending_in_cents, - ), - model_request_overages_enabled: ActiveValue::set( - params.model_request_overages_enabled, - ), - model_request_overages_spend_limit_in_cents: ActiveValue::set( - params.model_request_overages_spend_limit_in_cents, - ), - ..Default::default() - }) - .exec_with_returning(&*tx) - .await?; - - Ok(preferences) - }) - .await - } - - /// Updates the billing preferences for the given user. - pub async fn update_billing_preferences( - &self, - user_id: UserId, - params: &UpdateBillingPreferencesParams, - ) -> Result { - self.transaction(|tx| async move { - let preferences = billing_preference::Entity::update_many() - .set(billing_preference::ActiveModel { - max_monthly_llm_usage_spending_in_cents: params - .max_monthly_llm_usage_spending_in_cents - .clone(), - model_request_overages_enabled: params.model_request_overages_enabled.clone(), - model_request_overages_spend_limit_in_cents: params - .model_request_overages_spend_limit_in_cents - .clone(), - ..Default::default() - }) - .filter(billing_preference::Column::UserId.eq(user_id)) - .exec_with_returning(&*tx) - .await?; - - Ok(preferences - .into_iter() - .next() - .context("billing preferences not found")?) - }) - .await - } } From bc5c5cf5d65654d3001bc27c43a8f511dee77952 Mon Sep 17 00:00:00 2001 From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com> Date: Mon, 21 Jul 2025 12:20:38 -0400 Subject: [PATCH 0094/1052] onboarding: Create basic onboarding page (#34723) Release Notes: - N/A --------- Co-authored-by: Ben Kunkle --- Cargo.lock | 18 ++ Cargo.toml | 2 + crates/onboarding/Cargo.toml | 28 +++ crates/onboarding/LICENSE-GPL | 1 + crates/onboarding/src/onboarding.rs | 352 ++++++++++++++++++++++++++++ crates/zed/Cargo.toml | 1 + crates/zed/src/main.rs | 6 + crates/zed/src/zed.rs | 1 + 8 files changed, 409 insertions(+) create mode 100644 crates/onboarding/Cargo.toml create mode 120000 crates/onboarding/LICENSE-GPL create mode 100644 crates/onboarding/src/onboarding.rs diff --git a/Cargo.lock b/Cargo.lock index c0d8dabf09..1dcfb87756 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10983,6 +10983,23 @@ dependencies = [ "workspace-hack", ] +[[package]] +name = "onboarding" +version = "0.1.0" +dependencies = [ + "anyhow", + "command_palette_hooks", + "db", + "feature_flags", + "fs", + "gpui", + "settings", + "theme", + "ui", + "workspace", + "workspace-hack", +] + [[package]] name = "once_cell" version = "1.21.3" @@ -20223,6 +20240,7 @@ dependencies = [ "nix 0.29.0", "node_runtime", "notifications", + "onboarding", "outline", "outline_panel", "parking_lot", diff --git a/Cargo.toml b/Cargo.toml index c99ba3953d..ea8690f2b3 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -108,6 +108,7 @@ members = [ "crates/node_runtime", "crates/notifications", "crates/ollama", + "crates/onboarding", "crates/open_ai", "crates/open_router", "crates/outline", @@ -325,6 +326,7 @@ net = { path = "crates/net" } node_runtime = { path = "crates/node_runtime" } notifications = { path = "crates/notifications" } ollama = { path = "crates/ollama" } +onboarding = { path = "crates/onboarding" } open_ai = { path = "crates/open_ai" } open_router = { path = "crates/open_router", features = ["schemars"] } outline = { path = "crates/outline" } diff --git a/crates/onboarding/Cargo.toml b/crates/onboarding/Cargo.toml new file mode 100644 index 0000000000..693e39d4ca --- /dev/null +++ b/crates/onboarding/Cargo.toml @@ -0,0 +1,28 @@ +[package] +name = "onboarding" +version = "0.1.0" +edition.workspace = true +publish.workspace = true +license = "GPL-3.0-or-later" + +[lints] +workspace = true + +[lib] +path = "src/onboarding.rs" + +[features] +default = [] + +[dependencies] +anyhow.workspace = true +command_palette_hooks.workspace = true +db.workspace = true +feature_flags.workspace = true +fs.workspace = true +gpui.workspace = true +settings.workspace = true +theme.workspace = true +ui.workspace = true +workspace.workspace = true +workspace-hack.workspace = true diff --git a/crates/onboarding/LICENSE-GPL b/crates/onboarding/LICENSE-GPL new file mode 120000 index 0000000000..dd648cce4f --- /dev/null +++ b/crates/onboarding/LICENSE-GPL @@ -0,0 +1 @@ +../../../LICENSE-GPL \ No newline at end of file diff --git a/crates/onboarding/src/onboarding.rs b/crates/onboarding/src/onboarding.rs new file mode 100644 index 0000000000..1ce236f941 --- /dev/null +++ b/crates/onboarding/src/onboarding.rs @@ -0,0 +1,352 @@ +use command_palette_hooks::CommandPaletteFilter; +use db::kvp::KEY_VALUE_STORE; +use feature_flags::{FeatureFlag, FeatureFlagViewExt as _}; +use fs::Fs; +use gpui::{ + AnyElement, App, AppContext, Context, Entity, EventEmitter, FocusHandle, Focusable, + IntoElement, Render, SharedString, Subscription, Task, WeakEntity, Window, actions, +}; +use settings::{Settings, SettingsStore, update_settings_file}; +use std::sync::Arc; +use theme::{ThemeMode, ThemeSettings}; +use ui::{ + ButtonCommon as _, ButtonSize, ButtonStyle, Clickable as _, Color, Divider, FluentBuilder, + Headline, InteractiveElement, KeyBinding, Label, LabelCommon, ParentElement as _, + StatefulInteractiveElement, Styled, ToggleButton, Toggleable as _, Vector, VectorName, div, + h_flex, rems, v_container, v_flex, +}; +use workspace::{ + AppState, Workspace, WorkspaceId, + dock::DockPosition, + item::{Item, ItemEvent}, + open_new, with_active_or_new_workspace, +}; + +pub struct OnBoardingFeatureFlag {} + +impl FeatureFlag for OnBoardingFeatureFlag { + const NAME: &'static str = "onboarding"; +} + +pub const FIRST_OPEN: &str = "first_open"; + +actions!( + zed, + [ + /// Opens the onboarding view. + OpenOnboarding + ] +); + +pub fn init(cx: &mut App) { + cx.on_action(|_: &OpenOnboarding, cx| { + with_active_or_new_workspace(cx, |workspace, window, cx| { + workspace + .with_local_workspace(window, cx, |workspace, window, cx| { + let existing = workspace + .active_pane() + .read(cx) + .items() + .find_map(|item| item.downcast::()); + + if let Some(existing) = existing { + workspace.activate_item(&existing, true, true, window, cx); + } else { + let settings_page = Onboarding::new(workspace.weak_handle(), cx); + workspace.add_item_to_active_pane( + Box::new(settings_page), + None, + true, + window, + cx, + ) + } + }) + .detach(); + }); + }); + cx.observe_new::(|_, window, cx| { + let Some(window) = window else { + return; + }; + + let onboarding_actions = [std::any::TypeId::of::()]; + + CommandPaletteFilter::update_global(cx, |filter, _cx| { + filter.hide_action_types(&onboarding_actions); + }); + + cx.observe_flag::(window, move |is_enabled, _, _, cx| { + if is_enabled { + CommandPaletteFilter::update_global(cx, |filter, _cx| { + filter.show_action_types(onboarding_actions.iter()); + }); + } else { + CommandPaletteFilter::update_global(cx, |filter, _cx| { + filter.hide_action_types(&onboarding_actions); + }); + } + }) + .detach(); + }) + .detach(); +} + +pub fn show_onboarding_view(app_state: Arc, cx: &mut App) -> Task> { + open_new( + Default::default(), + app_state, + cx, + |workspace, window, cx| { + { + workspace.toggle_dock(DockPosition::Left, window, cx); + let onboarding_page = Onboarding::new(workspace.weak_handle(), cx); + workspace.add_item_to_center(Box::new(onboarding_page.clone()), window, cx); + + window.focus(&onboarding_page.focus_handle(cx)); + + cx.notify(); + }; + db::write_and_log(cx, || { + KEY_VALUE_STORE.write_kvp(FIRST_OPEN.to_string(), "false".to_string()) + }); + }, + ) +} + +fn read_theme_selection(cx: &App) -> ThemeMode { + let settings = ThemeSettings::get_global(cx); + settings + .theme_selection + .as_ref() + .and_then(|selection| selection.mode()) + .unwrap_or_default() +} + +fn write_theme_selection(theme_mode: ThemeMode, cx: &App) { + let fs = ::global(cx); + + update_settings_file::(fs, cx, move |settings, _| { + settings.set_mode(theme_mode); + }); +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum SelectedPage { + Basics, + Editing, + AiSetup, +} + +struct Onboarding { + workspace: WeakEntity, + focus_handle: FocusHandle, + selected_page: SelectedPage, + _settings_subscription: Subscription, +} + +impl Onboarding { + fn new(workspace: WeakEntity, cx: &mut App) -> Entity { + cx.new(|cx| Self { + workspace, + focus_handle: cx.focus_handle(), + selected_page: SelectedPage::Basics, + _settings_subscription: cx.observe_global::(move |_, cx| cx.notify()), + }) + } + + fn render_page_nav( + &mut self, + page: SelectedPage, + _: &mut Window, + cx: &mut Context, + ) -> impl IntoElement { + let text = match page { + SelectedPage::Basics => "Basics", + SelectedPage::Editing => "Editing", + SelectedPage::AiSetup => "AI Setup", + }; + let binding = match page { + SelectedPage::Basics => { + KeyBinding::new(vec![gpui::Keystroke::parse("cmd-1").unwrap()], cx) + } + SelectedPage::Editing => { + KeyBinding::new(vec![gpui::Keystroke::parse("cmd-2").unwrap()], cx) + } + SelectedPage::AiSetup => { + KeyBinding::new(vec![gpui::Keystroke::parse("cmd-3").unwrap()], cx) + } + }; + let selected = self.selected_page == page; + h_flex() + .id(text) + .rounded_sm() + .child(text) + .child(binding) + .h_8() + .gap_2() + .px_2() + .py_0p5() + .w_full() + .justify_between() + .map(|this| { + if selected { + this.bg(Color::Selected.color(cx)) + .border_l_1() + .border_color(Color::Accent.color(cx)) + } else { + this.text_color(Color::Muted.color(cx)) + } + }) + .hover(|style| { + if selected { + style.bg(Color::Selected.color(cx).opacity(0.6)) + } else { + style.bg(Color::Selected.color(cx).opacity(0.3)) + } + }) + .on_click(cx.listener(move |this, _, _, cx| { + this.selected_page = page; + cx.notify(); + })) + } + + fn render_page(&mut self, window: &mut Window, cx: &mut Context) -> AnyElement { + match self.selected_page { + SelectedPage::Basics => self.render_basics_page(window, cx).into_any_element(), + SelectedPage::Editing => self.render_editing_page(window, cx).into_any_element(), + SelectedPage::AiSetup => self.render_ai_setup_page(window, cx).into_any_element(), + } + } + + fn render_basics_page(&mut self, _: &mut Window, cx: &mut Context) -> impl IntoElement { + let theme_mode = read_theme_selection(cx); + + v_container().child( + h_flex() + .items_center() + .justify_between() + .child(Label::new("Theme")) + .child( + h_flex() + .rounded_md() + .child( + ToggleButton::new("light", "Light") + .style(ButtonStyle::Filled) + .size(ButtonSize::Large) + .toggle_state(theme_mode == ThemeMode::Light) + .on_click(|_, _, cx| write_theme_selection(ThemeMode::Light, cx)) + .first(), + ) + .child( + ToggleButton::new("dark", "Dark") + .style(ButtonStyle::Filled) + .size(ButtonSize::Large) + .toggle_state(theme_mode == ThemeMode::Dark) + .on_click(|_, _, cx| write_theme_selection(ThemeMode::Dark, cx)) + .last(), + ) + .child( + ToggleButton::new("system", "System") + .style(ButtonStyle::Filled) + .size(ButtonSize::Large) + .toggle_state(theme_mode == ThemeMode::System) + .on_click(|_, _, cx| write_theme_selection(ThemeMode::System, cx)) + .middle(), + ), + ), + ) + } + + fn render_editing_page(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement { + // div().child("editing page") + "Right" + } + + fn render_ai_setup_page(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement { + div().child("ai setup page") + } +} + +impl Render for Onboarding { + fn render(&mut self, window: &mut Window, cx: &mut Context) -> impl IntoElement { + h_flex() + .image_cache(gpui::retain_all("onboarding-page")) + .key_context("onboarding-page") + .px_24() + .py_12() + .items_start() + .child( + v_flex() + .w_1_3() + .h_full() + .child( + h_flex() + .pt_0p5() + .child(Vector::square(VectorName::ZedLogo, rems(2.))) + .child( + v_flex() + .left_1() + .items_center() + .child(Headline::new("Welcome to Zed")) + .child( + Label::new("The editor for what's next") + .color(Color::Muted) + .italic(), + ), + ), + ) + .p_1() + .child(Divider::horizontal_dashed()) + .child( + v_flex().gap_1().children([ + self.render_page_nav(SelectedPage::Basics, window, cx) + .into_element(), + self.render_page_nav(SelectedPage::Editing, window, cx) + .into_element(), + self.render_page_nav(SelectedPage::AiSetup, window, cx) + .into_element(), + ]), + ), + ) + // .child(Divider::vertical_dashed()) + .child(div().w_2_3().h_full().child(self.render_page(window, cx))) + } +} + +impl EventEmitter for Onboarding {} + +impl Focusable for Onboarding { + fn focus_handle(&self, _: &App) -> gpui::FocusHandle { + self.focus_handle.clone() + } +} + +impl Item for Onboarding { + type Event = ItemEvent; + + fn tab_content_text(&self, _detail: usize, _cx: &App) -> SharedString { + "Onboarding".into() + } + + fn telemetry_event_text(&self) -> Option<&'static str> { + Some("Onboarding Page Opened") + } + + fn show_toolbar(&self) -> bool { + false + } + + fn clone_on_split( + &self, + _workspace_id: Option, + _: &mut Window, + cx: &mut Context, + ) -> Option> { + Some(Onboarding::new(self.workspace.clone(), cx)) + } + + fn to_item_events(event: &Self::Event, mut f: impl FnMut(workspace::item::ItemEvent)) { + f(*event) + } +} diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml index bbceb3f101..e565aba26b 100644 --- a/crates/zed/Cargo.toml +++ b/crates/zed/Cargo.toml @@ -99,6 +99,7 @@ nc.workspace = true nix = { workspace = true, features = ["pthread", "signal"] } node_runtime.workspace = true notifications.workspace = true +onboarding.workspace = true outline.workspace = true outline_panel.workspace = true parking_lot.workspace = true diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs index 89b9fad6bf..9d85923ca2 100644 --- a/crates/zed/src/main.rs +++ b/crates/zed/src/main.rs @@ -24,6 +24,7 @@ use reqwest_client::ReqwestClient; use assets::Assets; use node_runtime::{NodeBinaryOptions, NodeRuntime}; +use onboarding::show_onboarding_view; use parking_lot::Mutex; use project::project_settings::ProjectSettings; use recent_projects::{SshSettings, open_ssh_project}; @@ -619,6 +620,7 @@ pub fn main() { markdown_preview::init(cx); svg_preview::init(cx); welcome::init(cx); + onboarding::init(cx); settings_ui::init(cx); extensions_ui::init(cx); zeta::init(cx); @@ -1039,6 +1041,10 @@ async fn restore_or_create_workspace(app_state: Arc, cx: &mut AsyncApp ); } } + } else if matches!(KEY_VALUE_STORE.read_kvp(FIRST_OPEN), Ok(None)) { + let state = app_state.clone(); + cx.update(|cx| show_onboarding_view(state, cx))?.await?; + // cx.update(|cx| show_welcome_view(app_state, cx))?.await?; } else if matches!(KEY_VALUE_STORE.read_kvp(FIRST_OPEN), Ok(None)) { cx.update(|cx| show_welcome_view(app_state, cx))?.await?; } else { diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs index cc3906af4d..24c7ab5ba2 100644 --- a/crates/zed/src/zed.rs +++ b/crates/zed/src/zed.rs @@ -3957,6 +3957,7 @@ mod tests { language::init(cx); workspace::init(app_state.clone(), cx); welcome::init(cx); + onboarding::init(cx); Project::init_settings(cx); app_state }) From b6cf398eab34bbc515a94f77ec01d0cd44570c61 Mon Sep 17 00:00:00 2001 From: Balboa Codes <20909423+balboacodes@users.noreply.github.com> Date: Mon, 21 Jul 2025 13:25:59 -0400 Subject: [PATCH 0095/1052] docs: Fix PHP docs typo (#34836) This fixes a minor typo in the PHP docs. Release Notes: - N/A --- docs/src/languages/php.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/src/languages/php.md b/docs/src/languages/php.md index 9cb7c40762..4e94c13446 100644 --- a/docs/src/languages/php.md +++ b/docs/src/languages/php.md @@ -15,7 +15,7 @@ The PHP extension offers both `phpactor` and `intelephense` language server supp ## Phpactor -The Zed PHP Extension can install `phpactor` automatically but requires `php` to installed and available in your path: +The Zed PHP Extension can install `phpactor` automatically but requires `php` to be installed and available in your path: ```sh # brew install php # macOS From 254c7a330a9c95d4ca2d7251cf601a5dac165768 Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Mon, 21 Jul 2025 20:48:07 +0300 Subject: [PATCH 0096/1052] Regroup LSP context menu items by the worktree name (#34838) Also * remove the feature gate * open buffers with an error when no logs are present * adjust the hover text to indicate that difference image Release Notes: - N/A --- Cargo.lock | 1 - .../src/activity_indicator.rs | 4 +- crates/language_tools/Cargo.toml | 1 - crates/language_tools/src/lsp_tool.rs | 604 +++++++++++------- 4 files changed, 363 insertions(+), 247 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 1dcfb87756..4537d440cc 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -9165,7 +9165,6 @@ dependencies = [ "collections", "copilot", "editor", - "feature_flags", "futures 0.3.31", "gpui", "itertools 0.14.0", diff --git a/crates/activity_indicator/src/activity_indicator.rs b/crates/activity_indicator/src/activity_indicator.rs index aee25fc9e3..f8ea7173d8 100644 --- a/crates/activity_indicator/src/activity_indicator.rs +++ b/crates/activity_indicator/src/activity_indicator.rs @@ -231,7 +231,6 @@ impl ActivityIndicator { status, } => { let create_buffer = project.update(cx, |project, cx| project.create_buffer(cx)); - let project = project.clone(); let status = status.clone(); let server_name = server_name.clone(); cx.spawn_in(window, async move |workspace, cx| { @@ -247,8 +246,7 @@ impl ActivityIndicator { workspace.update_in(cx, |workspace, window, cx| { workspace.add_item_to_active_pane( Box::new(cx.new(|cx| { - let mut editor = - Editor::for_buffer(buffer, Some(project.clone()), window, cx); + let mut editor = Editor::for_buffer(buffer, None, window, cx); editor.set_read_only(true); editor })), diff --git a/crates/language_tools/Cargo.toml b/crates/language_tools/Cargo.toml index 45af7518d5..5aa914311a 100644 --- a/crates/language_tools/Cargo.toml +++ b/crates/language_tools/Cargo.toml @@ -18,7 +18,6 @@ client.workspace = true collections.workspace = true copilot.workspace = true editor.workspace = true -feature_flags.workspace = true futures.workspace = true gpui.workspace = true itertools.workspace = true diff --git a/crates/language_tools/src/lsp_tool.rs b/crates/language_tools/src/lsp_tool.rs index fd84391680..9e95ed4673 100644 --- a/crates/language_tools/src/lsp_tool.rs +++ b/crates/language_tools/src/lsp_tool.rs @@ -1,13 +1,17 @@ -use std::{collections::hash_map, path::PathBuf, rc::Rc, time::Duration}; +use std::{ + collections::{BTreeMap, HashMap}, + path::{Path, PathBuf}, + rc::Rc, + time::Duration, +}; use client::proto; -use collections::{HashMap, HashSet}; +use collections::HashSet; use editor::{Editor, EditorEvent}; -use feature_flags::FeatureFlagAppExt as _; use gpui::{Corner, Entity, Subscription, Task, WeakEntity, actions}; -use language::{BinaryStatus, BufferId, LocalFile, ServerHealth}; +use language::{BinaryStatus, BufferId, ServerHealth}; use lsp::{LanguageServerId, LanguageServerName, LanguageServerSelector}; -use project::{LspStore, LspStoreEvent, project_settings::ProjectSettings}; +use project::{LspStore, LspStoreEvent, Worktree, project_settings::ProjectSettings}; use settings::{Settings as _, SettingsStore}; use ui::{ Context, ContextMenu, ContextMenuEntry, ContextMenuItem, DocumentationAside, DocumentationSide, @@ -36,8 +40,7 @@ pub struct LspTool { #[derive(Debug)] struct LanguageServerState { - items: Vec, - other_servers_start_index: Option, + items: Vec, workspace: WeakEntity, lsp_store: WeakEntity, active_editor: Option, @@ -63,8 +66,13 @@ impl std::fmt::Debug for ActiveEditor { struct LanguageServers { health_statuses: HashMap, binary_statuses: HashMap, - servers_per_buffer_abs_path: - HashMap>>, + servers_per_buffer_abs_path: HashMap, +} + +#[derive(Debug, Clone)] +struct ServersForPath { + servers: HashMap>, + worktree: Option>, } #[derive(Debug, Clone)] @@ -120,8 +128,8 @@ impl LanguageServerState { }; let mut first_button_encountered = false; - for (i, item) in self.items.iter().enumerate() { - if let LspItem::ToggleServersButton { restart } = item { + for item in &self.items { + if let LspMenuItem::ToggleServersButton { restart } = item { let label = if *restart { "Restart All Servers" } else { @@ -140,22 +148,19 @@ impl LanguageServerState { }; let project = workspace.read(cx).project().clone(); let buffer_store = project.read(cx).buffer_store().clone(); - let worktree_store = project.read(cx).worktree_store(); - let buffers = state .read(cx) .language_servers .servers_per_buffer_abs_path - .keys() - .filter_map(|abs_path| { - worktree_store.read(cx).find_worktree(abs_path, cx) - }) - .filter_map(|(worktree, relative_path)| { - let entry = - worktree.read(cx).entry_for_path(&relative_path)?; - project.read(cx).path_for_entry(entry.id, cx) - }) - .filter_map(|project_path| { + .iter() + .filter_map(|(abs_path, servers)| { + let worktree = + servers.worktree.as_ref()?.upgrade()?.read(cx); + let relative_path = + abs_path.strip_prefix(&worktree.abs_path()).ok()?; + let entry = worktree.entry_for_path(&relative_path)?; + let project_path = + project.read(cx).path_for_entry(entry.id, cx)?; buffer_store.read(cx).get_by_path(&project_path) }) .collect(); @@ -165,13 +170,16 @@ impl LanguageServerState { .iter() // Do not try to use IDs as we have stopped all servers already, when allowing to restart them all .flat_map(|item| match item { - LspItem::ToggleServersButton { .. } => None, - LspItem::WithHealthCheck(_, status, ..) => Some( - LanguageServerSelector::Name(status.name.clone()), - ), - LspItem::WithBinaryStatus(_, server_name, ..) => Some( - LanguageServerSelector::Name(server_name.clone()), + LspMenuItem::Header { .. } => None, + LspMenuItem::ToggleServersButton { .. } => None, + LspMenuItem::WithHealthCheck { health, .. } => Some( + LanguageServerSelector::Name(health.name.clone()), ), + LspMenuItem::WithBinaryStatus { + server_name, .. + } => Some(LanguageServerSelector::Name( + server_name.clone(), + )), }) .collect(); lsp_store.restart_language_servers_for_buffers( @@ -190,13 +198,17 @@ impl LanguageServerState { } menu = menu.item(button); continue; - }; + } else if let LspMenuItem::Header { header, separator } = item { + menu = menu + .when(*separator, |menu| menu.separator()) + .when_some(header.as_ref(), |menu, header| menu.header(header)); + continue; + } let Some(server_info) = item.server_info() else { continue; }; - let workspace = self.workspace.clone(); let server_selector = server_info.server_selector(); // TODO currently, Zed remote does not work well with the LSP logs // https://github.com/zed-industries/zed/issues/28557 @@ -205,6 +217,7 @@ impl LanguageServerState { let status_color = server_info .binary_status + .as_ref() .and_then(|binary_status| match binary_status.status { BinaryStatus::None => None, BinaryStatus::CheckingForUpdate @@ -223,17 +236,20 @@ impl LanguageServerState { }) .unwrap_or(Color::Success); - if self - .other_servers_start_index - .is_some_and(|index| index == i) - { - menu = menu.separator().header("Other Buffers"); - } - - if i == 0 && self.other_servers_start_index.is_some() { - menu = menu.header("Current Buffer"); - } + let message = server_info + .message + .as_ref() + .or_else(|| server_info.binary_status.as_ref()?.message.as_ref()) + .cloned(); + let hover_label = if has_logs { + Some("View Logs") + } else if message.is_some() { + Some("View Message") + } else { + None + }; + let server_name = server_info.name.clone(); menu = menu.item(ContextMenuItem::custom_entry( move |_, _| { h_flex() @@ -245,42 +261,99 @@ impl LanguageServerState { h_flex() .gap_2() .child(Indicator::dot().color(status_color)) - .child(Label::new(server_info.name.0.clone())), - ) - .child( - h_flex() - .visible_on_hover("menu_item") - .child( - Label::new("View Logs") - .size(LabelSize::Small) - .color(Color::Muted), - ) - .child( - Icon::new(IconName::ChevronRight) - .size(IconSize::Small) - .color(Color::Muted), - ), + .child(Label::new(server_name.0.clone())), ) + .when_some(hover_label, |div, hover_label| { + div.child( + h_flex() + .visible_on_hover("menu_item") + .child( + Label::new(hover_label) + .size(LabelSize::Small) + .color(Color::Muted), + ) + .child( + Icon::new(IconName::ChevronRight) + .size(IconSize::Small) + .color(Color::Muted), + ), + ) + }) .into_any_element() }, { let lsp_logs = lsp_logs.clone(); + let message = message.clone(); + let server_selector = server_selector.clone(); + let server_name = server_info.name.clone(); + let workspace = self.workspace.clone(); move |window, cx| { - if !has_logs { + if has_logs { + lsp_logs.update(cx, |lsp_logs, cx| { + lsp_logs.open_server_trace( + workspace.clone(), + server_selector.clone(), + window, + cx, + ); + }); + } else if let Some(message) = &message { + let Some(create_buffer) = workspace + .update(cx, |workspace, cx| { + workspace + .project() + .update(cx, |project, cx| project.create_buffer(cx)) + }) + .ok() + else { + return; + }; + + let window = window.window_handle(); + let workspace = workspace.clone(); + let message = message.clone(); + let server_name = server_name.clone(); + cx.spawn(async move |cx| { + let buffer = create_buffer.await?; + buffer.update(cx, |buffer, cx| { + buffer.edit( + [( + 0..0, + format!("Language server {server_name}:\n\n{message}"), + )], + None, + cx, + ); + buffer.set_capability(language::Capability::ReadOnly, cx); + })?; + + workspace.update(cx, |workspace, cx| { + window.update(cx, |_, window, cx| { + workspace.add_item_to_active_pane( + Box::new(cx.new(|cx| { + let mut editor = + Editor::for_buffer(buffer, None, window, cx); + editor.set_read_only(true); + editor + })), + None, + true, + window, + cx, + ); + }) + })??; + + anyhow::Ok(()) + }) + .detach(); + } else { cx.propagate(); return; } - lsp_logs.update(cx, |lsp_logs, cx| { - lsp_logs.open_server_trace( - workspace.clone(), - server_selector.clone(), - window, - cx, - ); - }); } }, - server_info.message.map(|server_message| { + message.map(|server_message| { DocumentationAside::new( DocumentationSide::Right, Rc::new(move |_| Label::new(server_message.clone()).into_any_element()), @@ -345,81 +418,95 @@ impl LanguageServers { #[derive(Debug)] enum ServerData<'a> { - WithHealthCheck( - LanguageServerId, - &'a LanguageServerHealthStatus, - Option<&'a LanguageServerBinaryStatus>, - ), - WithBinaryStatus( - Option, - &'a LanguageServerName, - &'a LanguageServerBinaryStatus, - ), -} - -#[derive(Debug)] -enum LspItem { - WithHealthCheck( - LanguageServerId, - LanguageServerHealthStatus, - Option, - ), - WithBinaryStatus( - Option, - LanguageServerName, - LanguageServerBinaryStatus, - ), - ToggleServersButton { - restart: bool, + WithHealthCheck { + server_id: LanguageServerId, + health: &'a LanguageServerHealthStatus, + binary_status: Option<&'a LanguageServerBinaryStatus>, + }, + WithBinaryStatus { + server_id: Option, + server_name: &'a LanguageServerName, + binary_status: &'a LanguageServerBinaryStatus, }, } -impl LspItem { +#[derive(Debug)] +enum LspMenuItem { + WithHealthCheck { + server_id: LanguageServerId, + health: LanguageServerHealthStatus, + binary_status: Option, + }, + WithBinaryStatus { + server_id: Option, + server_name: LanguageServerName, + binary_status: LanguageServerBinaryStatus, + }, + ToggleServersButton { + restart: bool, + }, + Header { + header: Option, + separator: bool, + }, +} + +impl LspMenuItem { fn server_info(&self) -> Option { match self { - LspItem::ToggleServersButton { .. } => None, - LspItem::WithHealthCheck( - language_server_id, - language_server_health_status, - language_server_binary_status, - ) => Some(ServerInfo { - name: language_server_health_status.name.clone(), - id: Some(*language_server_id), - health: language_server_health_status.health(), - binary_status: language_server_binary_status.clone(), - message: language_server_health_status.message(), - }), - LspItem::WithBinaryStatus( + Self::Header { .. } => None, + Self::ToggleServersButton { .. } => None, + Self::WithHealthCheck { server_id, - language_server_name, - language_server_binary_status, - ) => Some(ServerInfo { - name: language_server_name.clone(), + health, + binary_status, + .. + } => Some(ServerInfo { + name: health.name.clone(), + id: Some(*server_id), + health: health.health(), + binary_status: binary_status.clone(), + message: health.message(), + }), + Self::WithBinaryStatus { + server_id, + server_name, + binary_status, + .. + } => Some(ServerInfo { + name: server_name.clone(), id: *server_id, health: None, - binary_status: Some(language_server_binary_status.clone()), - message: language_server_binary_status.message.clone(), + binary_status: Some(binary_status.clone()), + message: binary_status.message.clone(), }), } } } impl ServerData<'_> { - fn name(&self) -> &LanguageServerName { + fn into_lsp_item(self) -> LspMenuItem { match self { - Self::WithHealthCheck(_, state, _) => &state.name, - Self::WithBinaryStatus(_, name, ..) => name, - } - } - - fn into_lsp_item(self) -> LspItem { - match self { - Self::WithHealthCheck(id, name, status) => { - LspItem::WithHealthCheck(id, name.clone(), status.cloned()) - } - Self::WithBinaryStatus(server_id, name, status) => { - LspItem::WithBinaryStatus(server_id, name.clone(), status.clone()) - } + Self::WithHealthCheck { + server_id, + health, + binary_status, + .. + } => LspMenuItem::WithHealthCheck { + server_id, + health: health.clone(), + binary_status: binary_status.cloned(), + }, + Self::WithBinaryStatus { + server_id, + server_name, + binary_status, + .. + } => LspMenuItem::WithBinaryStatus { + server_id, + server_name: server_name.clone(), + binary_status: binary_status.clone(), + }, } } } @@ -452,7 +539,6 @@ impl LspTool { let state = cx.new(|_| LanguageServerState { workspace: workspace.weak_handle(), items: Vec::new(), - other_servers_start_index: None, lsp_store: lsp_store.downgrade(), active_editor: None, language_servers: LanguageServers::default(), @@ -542,13 +628,28 @@ impl LspTool { message: proto::update_language_server::Variant::RegisteredForBuffer(update), .. } => { - self.server_state.update(cx, |state, _| { - state + self.server_state.update(cx, |state, cx| { + let Ok(worktree) = state.workspace.update(cx, |workspace, cx| { + workspace + .project() + .read(cx) + .find_worktree(Path::new(&update.buffer_abs_path), cx) + .map(|(worktree, _)| worktree.downgrade()) + }) else { + return; + }; + let entry = state .language_servers .servers_per_buffer_abs_path .entry(PathBuf::from(&update.buffer_abs_path)) - .or_default() - .insert(*language_server_id, name.clone()); + .or_insert_with(|| ServersForPath { + servers: HashMap::default(), + worktree: worktree.clone(), + }); + entry.servers.insert(*language_server_id, name.clone()); + if worktree.is_some() { + entry.worktree = worktree; + } }); updated = true; } @@ -562,94 +663,95 @@ impl LspTool { fn regenerate_items(&mut self, cx: &mut App) { self.server_state.update(cx, |state, cx| { - let editor_buffers = state + let active_worktrees = state .active_editor .as_ref() - .map(|active_editor| active_editor.editor_buffers.clone()) - .unwrap_or_default(); - let editor_buffer_paths = editor_buffers - .iter() - .filter_map(|buffer_id| { - let buffer_path = state - .lsp_store - .update(cx, |lsp_store, cx| { - Some( - project::File::from_dyn( - lsp_store - .buffer_store() - .read(cx) - .get(*buffer_id)? - .read(cx) - .file(), - )? - .abs_path(cx), - ) + .into_iter() + .flat_map(|active_editor| { + active_editor + .editor + .upgrade() + .into_iter() + .flat_map(|active_editor| { + active_editor + .read(cx) + .buffer() + .read(cx) + .all_buffers() + .into_iter() + .filter_map(|buffer| { + project::File::from_dyn(buffer.read(cx).file()) + }) + .map(|buffer_file| buffer_file.worktree.clone()) }) - .ok()??; - Some(buffer_path) }) - .collect::>(); + .collect::>(); - let mut servers_with_health_checks = HashSet::default(); - let mut server_ids_with_health_checks = HashSet::default(); - let mut buffer_servers = - Vec::with_capacity(state.language_servers.health_statuses.len()); - let mut other_servers = - Vec::with_capacity(state.language_servers.health_statuses.len()); - let buffer_server_ids = editor_buffer_paths - .iter() - .filter_map(|buffer_path| { - state - .language_servers - .servers_per_buffer_abs_path - .get(buffer_path) - }) - .flatten() - .fold(HashMap::default(), |mut acc, (server_id, name)| { - match acc.entry(*server_id) { - hash_map::Entry::Occupied(mut o) => { - let old_name: &mut Option<&LanguageServerName> = o.get_mut(); - if old_name.is_none() { - *old_name = name.as_ref(); - } - } - hash_map::Entry::Vacant(v) => { - v.insert(name.as_ref()); + let mut server_ids_to_worktrees = + HashMap::>::default(); + let mut server_names_to_worktrees = HashMap::< + LanguageServerName, + HashSet<(Entity, LanguageServerId)>, + >::default(); + for servers_for_path in state.language_servers.servers_per_buffer_abs_path.values() { + if let Some(worktree) = servers_for_path + .worktree + .as_ref() + .and_then(|worktree| worktree.upgrade()) + { + for (server_id, server_name) in &servers_for_path.servers { + server_ids_to_worktrees.insert(*server_id, worktree.clone()); + if let Some(server_name) = server_name { + server_names_to_worktrees + .entry(server_name.clone()) + .or_default() + .insert((worktree.clone(), *server_id)); } } - acc + } + } + + let mut servers_per_worktree = BTreeMap::>::new(); + let mut servers_without_worktree = Vec::::new(); + let mut servers_with_health_checks = HashSet::default(); + + for (server_id, health) in &state.language_servers.health_statuses { + let worktree = server_ids_to_worktrees.get(server_id).or_else(|| { + let worktrees = server_names_to_worktrees.get(&health.name)?; + worktrees + .iter() + .find(|(worktree, _)| active_worktrees.contains(worktree)) + .or_else(|| worktrees.iter().next()) + .map(|(worktree, _)| worktree) }); - for (server_id, server_state) in &state.language_servers.health_statuses { - let binary_status = state - .language_servers - .binary_statuses - .get(&server_state.name); - servers_with_health_checks.insert(&server_state.name); - server_ids_with_health_checks.insert(*server_id); - if buffer_server_ids.contains_key(server_id) { - buffer_servers.push(ServerData::WithHealthCheck( - *server_id, - server_state, - binary_status, - )); - } else { - other_servers.push(ServerData::WithHealthCheck( - *server_id, - server_state, - binary_status, - )); + servers_with_health_checks.insert(&health.name); + let worktree_name = + worktree.map(|worktree| SharedString::new(worktree.read(cx).root_name())); + + let binary_status = state.language_servers.binary_statuses.get(&health.name); + let server_data = ServerData::WithHealthCheck { + server_id: *server_id, + health, + binary_status, + }; + match worktree_name { + Some(worktree_name) => servers_per_worktree + .entry(worktree_name.clone()) + .or_default() + .push(server_data), + None => servers_without_worktree.push(server_data), } } let mut can_stop_all = !state.language_servers.health_statuses.is_empty(); let mut can_restart_all = state.language_servers.health_statuses.is_empty(); - for (server_name, status) in state + for (server_name, binary_status) in state .language_servers .binary_statuses .iter() .filter(|(name, _)| !servers_with_health_checks.contains(name)) { - match status.status { + match binary_status.status { BinaryStatus::None => { can_restart_all = false; can_stop_all |= true; @@ -674,52 +776,73 @@ impl LspTool { BinaryStatus::Failed { .. } => {} } - let matching_server_id = state - .language_servers - .servers_per_buffer_abs_path - .iter() - .filter(|(path, _)| editor_buffer_paths.contains(path)) - .flat_map(|(_, server_associations)| server_associations.iter()) - .find_map(|(id, name)| { - if name.as_ref() == Some(server_name) { - Some(*id) - } else { - None + match server_names_to_worktrees.get(server_name) { + Some(worktrees_for_name) => { + match worktrees_for_name + .iter() + .find(|(worktree, _)| active_worktrees.contains(worktree)) + .or_else(|| worktrees_for_name.iter().next()) + { + Some((worktree, server_id)) => { + let worktree_name = + SharedString::new(worktree.read(cx).root_name()); + servers_per_worktree + .entry(worktree_name.clone()) + .or_default() + .push(ServerData::WithBinaryStatus { + server_name, + binary_status, + server_id: Some(*server_id), + }); + } + None => servers_without_worktree.push(ServerData::WithBinaryStatus { + server_name, + binary_status, + server_id: None, + }), } - }); - if let Some(server_id) = matching_server_id { - buffer_servers.push(ServerData::WithBinaryStatus( - Some(server_id), + } + None => servers_without_worktree.push(ServerData::WithBinaryStatus { server_name, - status, - )); - } else { - other_servers.push(ServerData::WithBinaryStatus(None, server_name, status)); + binary_status, + server_id: None, + }), } } - buffer_servers.sort_by_key(|data| data.name().clone()); - other_servers.sort_by_key(|data| data.name().clone()); - - let mut other_servers_start_index = None; let mut new_lsp_items = - Vec::with_capacity(buffer_servers.len() + other_servers.len() + 1); - new_lsp_items.extend(buffer_servers.into_iter().map(ServerData::into_lsp_item)); - if !new_lsp_items.is_empty() { - other_servers_start_index = Some(new_lsp_items.len()); + Vec::with_capacity(servers_per_worktree.len() + servers_without_worktree.len() + 2); + for (worktree_name, worktree_servers) in servers_per_worktree { + if worktree_servers.is_empty() { + continue; + } + new_lsp_items.push(LspMenuItem::Header { + header: Some(worktree_name), + separator: false, + }); + new_lsp_items.extend(worktree_servers.into_iter().map(ServerData::into_lsp_item)); + } + if !servers_without_worktree.is_empty() { + new_lsp_items.push(LspMenuItem::Header { + header: Some(SharedString::from("Unknown worktree")), + separator: false, + }); + new_lsp_items.extend( + servers_without_worktree + .into_iter() + .map(ServerData::into_lsp_item), + ); } - new_lsp_items.extend(other_servers.into_iter().map(ServerData::into_lsp_item)); if !new_lsp_items.is_empty() { if can_stop_all { - new_lsp_items.push(LspItem::ToggleServersButton { restart: true }); - new_lsp_items.push(LspItem::ToggleServersButton { restart: false }); + new_lsp_items.push(LspMenuItem::ToggleServersButton { restart: true }); + new_lsp_items.push(LspMenuItem::ToggleServersButton { restart: false }); } else if can_restart_all { - new_lsp_items.push(LspItem::ToggleServersButton { restart: true }); + new_lsp_items.push(LspMenuItem::ToggleServersButton { restart: true }); } } state.items = new_lsp_items; - state.other_servers_start_index = other_servers_start_index; }); } @@ -841,10 +964,7 @@ impl StatusItemView for LspTool { impl Render for LspTool { fn render(&mut self, _: &mut Window, cx: &mut Context) -> impl ui::IntoElement { - if !cx.is_staff() - || self.server_state.read(cx).language_servers.is_empty() - || self.lsp_menu.is_none() - { + if self.server_state.read(cx).language_servers.is_empty() || self.lsp_menu.is_none() { return div(); } @@ -852,12 +972,12 @@ impl Render for LspTool { let mut has_warnings = false; let mut has_other_notifications = false; let state = self.server_state.read(cx); - for server in state.language_servers.health_statuses.values() { - if let Some(binary_status) = &state.language_servers.binary_statuses.get(&server.name) { - has_errors |= matches!(binary_status.status, BinaryStatus::Failed { .. }); - has_other_notifications |= binary_status.message.is_some(); - } + for binary_status in state.language_servers.binary_statuses.values() { + has_errors |= matches!(binary_status.status, BinaryStatus::Failed { .. }); + has_other_notifications |= binary_status.message.is_some(); + } + for server in state.language_servers.health_statuses.values() { if let Some((message, health)) = &server.health { has_other_notifications |= message.is_some(); match health { From 589af59dfe6fe5f54e37c4b99f9aa944ff864f30 Mon Sep 17 00:00:00 2001 From: Bennet Bo Fenner Date: Mon, 21 Jul 2025 20:02:28 +0200 Subject: [PATCH 0097/1052] collab: Refresh the LLM token once the terms of service have been accepted (#34833) Release Notes: - N/A --- crates/collab/src/rpc.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs index 7a454e11cf..924784109b 100644 --- a/crates/collab/src/rpc.rs +++ b/crates/collab/src/rpc.rs @@ -4167,6 +4167,13 @@ async fn accept_terms_of_service( response.send(proto::AcceptTermsOfServiceResponse { accepted_tos_at: accepted_tos_at.timestamp() as u64, })?; + + // When the user accepts the terms of service, we want to refresh their LLM + // token to grant access. + session + .peer + .send(session.connection_id, proto::RefreshLlmToken {})?; + Ok(()) } From da8bf9ad795312fb83eb030586c9e369852d1f38 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 21 Jul 2025 14:32:22 -0400 Subject: [PATCH 0098/1052] Auto-retry agent errors by default (#34842) Now we explicitly carve out exceptions for which HTTP responses we do *not* retry for, and retry at least once on all others. Release Notes: - The Agent panel now automatically retries failed requests under more circumstances. --- crates/agent/src/thread.rs | 75 ++++++++++++++++++++++++-------------- 1 file changed, 47 insertions(+), 28 deletions(-) diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs index 180cc88390..e50763535a 100644 --- a/crates/agent/src/thread.rs +++ b/crates/agent/src/thread.rs @@ -51,7 +51,7 @@ use util::{ResultExt as _, debug_panic, post_inc}; use uuid::Uuid; use zed_llm_client::{CompletionIntent, CompletionRequestStatus, UsageLimit}; -const MAX_RETRY_ATTEMPTS: u8 = 3; +const MAX_RETRY_ATTEMPTS: u8 = 4; const BASE_RETRY_DELAY: Duration = Duration::from_secs(5); #[derive(Debug, Clone)] @@ -2182,8 +2182,8 @@ impl Thread { // General strategy here: // - If retrying won't help (e.g. invalid API key or payload too large), return None so we don't retry at all. - // - If it's a time-based issue (e.g. server overloaded, rate limit exceeded), try multiple times with exponential backoff. - // - If it's an issue that *might* be fixed by retrying (e.g. internal server error), just retry once. + // - If it's a time-based issue (e.g. server overloaded, rate limit exceeded), retry up to 4 times with exponential backoff. + // - If it's an issue that *might* be fixed by retrying (e.g. internal server error), retry up to 3 times. match error { HttpResponseError { status_code: StatusCode::TOO_MANY_REQUESTS, @@ -2211,8 +2211,8 @@ impl Thread { } StatusCode::INTERNAL_SERVER_ERROR => Some(RetryStrategy::Fixed { delay: retry_after.unwrap_or(BASE_RETRY_DELAY), - // Internal Server Error could be anything, so only retry once. - max_attempts: 1, + // Internal Server Error could be anything, retry up to 3 times. + max_attempts: 3, }), status => { // There is no StatusCode variant for the unofficial HTTP 529 ("The service is overloaded"), @@ -2223,20 +2223,23 @@ impl Thread { max_attempts: MAX_RETRY_ATTEMPTS, }) } else { - None + Some(RetryStrategy::Fixed { + delay: retry_after.unwrap_or(BASE_RETRY_DELAY), + max_attempts: 2, + }) } } }, ApiInternalServerError { .. } => Some(RetryStrategy::Fixed { delay: BASE_RETRY_DELAY, - max_attempts: 1, + max_attempts: 3, }), ApiReadResponseError { .. } | HttpSend { .. } | DeserializeResponse { .. } | BadRequestFormat { .. } => Some(RetryStrategy::Fixed { delay: BASE_RETRY_DELAY, - max_attempts: 1, + max_attempts: 3, }), // Retrying these errors definitely shouldn't help. HttpResponseError { @@ -2244,24 +2247,31 @@ impl Thread { StatusCode::PAYLOAD_TOO_LARGE | StatusCode::FORBIDDEN | StatusCode::UNAUTHORIZED, .. } - | SerializeRequest { .. } + | AuthenticationError { .. } + | PermissionError { .. } => None, + // These errors might be transient, so retry them + SerializeRequest { .. } | BuildRequestBody { .. } | PromptTooLarge { .. } - | AuthenticationError { .. } - | PermissionError { .. } | ApiEndpointNotFound { .. } - | NoApiKey { .. } => None, + | NoApiKey { .. } => Some(RetryStrategy::Fixed { + delay: BASE_RETRY_DELAY, + max_attempts: 2, + }), // Retry all other 4xx and 5xx errors once. HttpResponseError { status_code, .. } if status_code.is_client_error() || status_code.is_server_error() => { Some(RetryStrategy::Fixed { delay: BASE_RETRY_DELAY, - max_attempts: 1, + max_attempts: 3, }) } // Conservatively assume that any other errors are non-retryable - HttpResponseError { .. } | Other(..) => None, + HttpResponseError { .. } | Other(..) => Some(RetryStrategy::Fixed { + delay: BASE_RETRY_DELAY, + max_attempts: 2, + }), } } @@ -4352,7 +4362,7 @@ fn main() {{ let retry_state = thread.retry_state.as_ref().unwrap(); assert_eq!(retry_state.attempt, 1, "Should be first retry attempt"); assert_eq!( - retry_state.max_attempts, 1, + retry_state.max_attempts, 3, "Should have correct max attempts" ); }); @@ -4368,8 +4378,9 @@ fn main() {{ if let MessageSegment::Text(text) = seg { text.contains("internal") && text.contains("Fake") - && text.contains("Retrying in") - && !text.contains("attempt") + && text.contains("Retrying") + && text.contains("attempt 1 of 3") + && text.contains("seconds") } else { false } @@ -4464,8 +4475,8 @@ fn main() {{ let retry_state = thread.retry_state.as_ref().unwrap(); assert_eq!(retry_state.attempt, 1, "Should be first retry attempt"); assert_eq!( - retry_state.max_attempts, 1, - "Internal server errors should only retry once" + retry_state.max_attempts, 3, + "Internal server errors should retry up to 3 times" ); }); @@ -4473,7 +4484,15 @@ fn main() {{ cx.executor().advance_clock(BASE_RETRY_DELAY); cx.run_until_parked(); - // Should have scheduled second retry - count retry messages + // Advance clock for second retry + cx.executor().advance_clock(BASE_RETRY_DELAY); + cx.run_until_parked(); + + // Advance clock for third retry + cx.executor().advance_clock(BASE_RETRY_DELAY); + cx.run_until_parked(); + + // Should have completed all retries - count retry messages let retry_count = thread.update(cx, |thread, _| { thread .messages @@ -4491,24 +4510,24 @@ fn main() {{ .count() }); assert_eq!( - retry_count, 1, - "Should have only one retry for internal server errors" + retry_count, 3, + "Should have 3 retries for internal server errors" ); - // For internal server errors, we only retry once and then give up - // Check that retry_state is cleared after the single retry + // For internal server errors, we retry 3 times and then give up + // Check that retry_state is cleared after all retries thread.read_with(cx, |thread, _| { assert!( thread.retry_state.is_none(), - "Retry state should be cleared after single retry" + "Retry state should be cleared after all retries" ); }); - // Verify total attempts (1 initial + 1 retry) + // Verify total attempts (1 initial + 3 retries) assert_eq!( *completion_count.lock(), - 2, - "Should have attempted once plus 1 retry" + 4, + "Should have attempted once plus 3 retries" ); } From 3e50d997ddfb5e0fa483c4010cf1b1f4de6fc93c Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Mon, 21 Jul 2025 20:44:45 +0200 Subject: [PATCH 0099/1052] agent: Fix double-lease panic when clicking on thread to jump (#34843) Closes #ISSUE Release Notes: - N/A *or* Added/Fixed/Improved ... --- crates/agent_ui/src/active_thread.rs | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/crates/agent_ui/src/active_thread.rs b/crates/agent_ui/src/active_thread.rs index 14e7cf05b5..bfed81f5b7 100644 --- a/crates/agent_ui/src/active_thread.rs +++ b/crates/agent_ui/src/active_thread.rs @@ -3724,8 +3724,11 @@ pub(crate) fn open_context( AgentContextHandle::Thread(thread_context) => workspace.update(cx, |workspace, cx| { if let Some(panel) = workspace.panel::(cx) { - panel.update(cx, |panel, cx| { - panel.open_thread(thread_context.thread.clone(), window, cx); + let thread = thread_context.thread.clone(); + window.defer(cx, move |window, cx| { + panel.update(cx, |panel, cx| { + panel.open_thread(thread, window, cx); + }); }); } }), @@ -3733,8 +3736,11 @@ pub(crate) fn open_context( AgentContextHandle::TextThread(text_thread_context) => { workspace.update(cx, |workspace, cx| { if let Some(panel) = workspace.panel::(cx) { - panel.update(cx, |panel, cx| { - panel.open_prompt_editor(text_thread_context.context.clone(), window, cx) + let context = text_thread_context.context.clone(); + window.defer(cx, move |window, cx| { + panel.update(cx, |panel, cx| { + panel.open_prompt_editor(context, window, cx) + }); }); } }) From 6ea09beea8b5038c6101f0fed2715acb80faa735 Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Mon, 21 Jul 2025 20:51:27 +0200 Subject: [PATCH 0100/1052] terminal: Handle spaces in cwds of remote terminals (#34844) Closes #34807 Release Notes: - Fixed "Open in terminal" action not working with paths that contain spaces in SSH projects. --- crates/project/src/terminals.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/project/src/terminals.rs b/crates/project/src/terminals.rs index 3d62b4156b..8cfbdff311 100644 --- a/crates/project/src/terminals.rs +++ b/crates/project/src/terminals.rs @@ -662,7 +662,7 @@ pub fn wrap_for_ssh( format!("cd \"$HOME/{trimmed_path}\"; {env_changes} {to_run}") } else { - format!("cd {path}; {env_changes} {to_run}") + format!("cd \"{path}\"; {env_changes} {to_run}") } } else { format!("cd; {env_changes} {to_run}") From 241acbe4be9dff7320a10817faafb9fd2518049d Mon Sep 17 00:00:00 2001 From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com> Date: Mon, 21 Jul 2025 15:02:02 -0400 Subject: [PATCH 0101/1052] Stop onboarding page from showing up instead of welcome page (#34845) This is from PR #34723 where I was working on developing the onboarding page, but I forgot to switch the first page back to our current version. Release Notes: - N/A --- crates/zed/src/main.rs | 5 ----- 1 file changed, 5 deletions(-) diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs index 9d85923ca2..a9d3d63381 100644 --- a/crates/zed/src/main.rs +++ b/crates/zed/src/main.rs @@ -24,7 +24,6 @@ use reqwest_client::ReqwestClient; use assets::Assets; use node_runtime::{NodeBinaryOptions, NodeRuntime}; -use onboarding::show_onboarding_view; use parking_lot::Mutex; use project::project_settings::ProjectSettings; use recent_projects::{SshSettings, open_ssh_project}; @@ -1041,10 +1040,6 @@ async fn restore_or_create_workspace(app_state: Arc, cx: &mut AsyncApp ); } } - } else if matches!(KEY_VALUE_STORE.read_kvp(FIRST_OPEN), Ok(None)) { - let state = app_state.clone(); - cx.update(|cx| show_onboarding_view(state, cx))?.await?; - // cx.update(|cx| show_welcome_view(app_state, cx))?.await?; } else if matches!(KEY_VALUE_STORE.read_kvp(FIRST_OPEN), Ok(None)) { cx.update(|cx| show_welcome_view(app_state, cx))?.await?; } else { From 1a1715766f0f5af9d1ae5df23d58cb1763bd886d Mon Sep 17 00:00:00 2001 From: Ben Kunkle Date: Mon, 21 Jul 2025 14:16:47 -0500 Subject: [PATCH 0102/1052] Fix enter to select model in agent panel (#34846) Broken by #34664 Release Notes: - N/A *or* Added/Fixed/Improved ... --- assets/keymaps/default-linux.json | 4 ++-- assets/keymaps/default-macos.json | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index 6aba27fec8..9585bcdecd 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -277,7 +277,7 @@ } }, { - "context": "MessageEditor > Editor && !use_modifier_to_send", + "context": "MessageEditor && !Picker > Editor && !use_modifier_to_send", "bindings": { "enter": "agent::Chat", "ctrl-enter": "agent::ChatWithFollow", @@ -288,7 +288,7 @@ } }, { - "context": "MessageEditor > Editor && use_modifier_to_send", + "context": "MessageEditor && !Picker > Editor && use_modifier_to_send", "bindings": { "ctrl-enter": "agent::Chat", "enter": "editor::Newline", diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index ba903c0782..9a72bc912c 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -318,7 +318,7 @@ } }, { - "context": "MessageEditor > Editor && !use_modifier_to_send", + "context": "MessageEditor && !Picker > Editor && !use_modifier_to_send", "use_key_equivalents": true, "bindings": { "enter": "agent::Chat", @@ -330,7 +330,7 @@ } }, { - "context": "MessageEditor > Editor && use_modifier_to_send", + "context": "MessageEditor && !Picker > Editor && use_modifier_to_send", "use_key_equivalents": true, "bindings": { "cmd-enter": "agent::Chat", From 8eca7f32e2041c648c3c9b0ac1e8b686fec4e5df Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Mon, 21 Jul 2025 16:09:02 -0400 Subject: [PATCH 0103/1052] Fix for vim bindings in Pickers on Linux (#34840) Closes: https://github.com/zed-industries/zed/issues/34780 Also relocated undo/redo selection in the keymap (no-op) as they are from Sublime, not VSCode. Release Notes: - vim: Fixed an issue so `ctrl-w` / `ctrl-h` and `ctrl-u` work in pickers on Linux when Vim mode is enabled. --- assets/keymaps/default-linux.json | 4 ++-- assets/keymaps/default-macos.json | 4 ++-- assets/keymaps/vim.json | 8 ++++++++ 3 files changed, 12 insertions(+), 4 deletions(-) diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index 9585bcdecd..377a26242b 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -484,8 +484,6 @@ "ctrl-k ctrl-shift-d": ["editor::SelectPrevious", { "replace_newest": true }], // editor.action.moveSelectionToPreviousFindMatch "ctrl-k ctrl-i": "editor::Hover", "ctrl-/": ["editor::ToggleComments", { "advance_downwards": false }], - "ctrl-u": "editor::UndoSelection", - "ctrl-shift-u": "editor::RedoSelection", "f8": ["editor::GoToDiagnostic", { "severity": { "min": "hint", "max": "error" } }], "shift-f8": ["editor::GoToPreviousDiagnostic", { "severity": { "min": "hint", "max": "error" } }], "f2": "editor::Rename", @@ -663,6 +661,8 @@ { "context": "Editor", "bindings": { + "ctrl-u": "editor::UndoSelection", + "ctrl-shift-u": "editor::RedoSelection", "ctrl-shift-j": "editor::JoinLines", "ctrl-alt-backspace": "editor::DeleteToPreviousSubwordStart", "ctrl-alt-h": "editor::DeleteToPreviousSubwordStart", diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index 9a72bc912c..712d73b8ec 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -538,8 +538,6 @@ "cmd-k ctrl-cmd-d": ["editor::SelectPrevious", { "replace_newest": true }], // editor.action.moveSelectionToPreviousFindMatch "cmd-k cmd-i": "editor::Hover", "cmd-/": ["editor::ToggleComments", { "advance_downwards": false }], - "cmd-u": "editor::UndoSelection", - "cmd-shift-u": "editor::RedoSelection", "f8": ["editor::GoToDiagnostic", { "severity": { "min": "hint", "max": "error" } }], "shift-f8": ["editor::GoToPreviousDiagnostic", { "severity": { "min": "hint", "max": "error" } }], "f2": "editor::Rename", @@ -726,6 +724,8 @@ "context": "Editor", "use_key_equivalents": true, "bindings": { + "cmd-u": "editor::UndoSelection", + "cmd-shift-u": "editor::RedoSelection", "ctrl-j": "editor::JoinLines", "ctrl-alt-backspace": "editor::DeleteToPreviousSubwordStart", "ctrl-alt-h": "editor::DeleteToPreviousSubwordStart", diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json index 2ef282c21e..04e6b0bcd4 100644 --- a/assets/keymaps/vim.json +++ b/assets/keymaps/vim.json @@ -858,6 +858,14 @@ "shift-n": null } }, + { + "context": "Picker > Editor", + "bindings": { + "ctrl-h": "editor::Backspace", + "ctrl-u": "editor::DeleteToBeginningOfLine", + "ctrl-w": "editor::DeleteToPreviousWordStart" + } + }, { "context": "GitCommit > Editor && VimControl && vim_mode == normal", "bindings": { From 5b3e37181240d8ed1ef8e04aa0593c7ca5f46a6c Mon Sep 17 00:00:00 2001 From: Finn Evers Date: Mon, 21 Jul 2025 22:24:33 +0200 Subject: [PATCH 0104/1052] gpui: Round `scroll_max` to two decimal places (#34832) Follow up to #31836 After enabling rounding in the Taffy layout engine, we frequently run into cases where the bounds produced by Taffy and ours slightly differ after 5 or more decimal places. This leads to cases where containers become scrollable for less than 0.0000x Pixels. In case this happens for e.g. hover popovers, we render a scrollbar due to the container being technically scrollable, even though the scroll amount here will in practice never be visible. This change fixes this by rounding the `scroll_max` by which we clamp the current scroll position to two decimal places. We don't benefit from the additional floating point precision here at all and it stops such containers from becoming scrollable altogether. Furthermore, we now store the `scroll_max` instead of the `padded_content_size` as the former gives a much better idea on whether the corresponding container is scrollable or not. | `main` | After these changes | | -- | -- | | main | scroll_max_rounded | Release Notes: - Fixed an issue where scrollbars would appear in containers where no scrolling was possible. --- crates/gpui/src/elements/div.rs | 29 ++++++++++++----- crates/gpui/src/elements/list.rs | 6 ++-- .../terminal_view/src/terminal_scrollbar.rs | 11 +++++-- crates/ui/src/components/scrollbar.rs | 31 ++++++++++--------- crates/workspace/src/pane.rs | 11 +++---- 5 files changed, 55 insertions(+), 33 deletions(-) diff --git a/crates/gpui/src/elements/div.rs b/crates/gpui/src/elements/div.rs index ed1666c530..4655c92409 100644 --- a/crates/gpui/src/elements/div.rs +++ b/crates/gpui/src/elements/div.rs @@ -1664,6 +1664,11 @@ impl Interactivity { window: &mut Window, _cx: &mut App, ) -> Point { + fn round_to_two_decimals(pixels: Pixels) -> Pixels { + const ROUNDING_FACTOR: f32 = 100.0; + (pixels * ROUNDING_FACTOR).round() / ROUNDING_FACTOR + } + if let Some(scroll_offset) = self.scroll_offset.as_ref() { let mut scroll_to_bottom = false; let mut tracked_scroll_handle = self @@ -1678,8 +1683,16 @@ impl Interactivity { let rem_size = window.rem_size(); let padding = style.padding.to_pixels(bounds.size.into(), rem_size); let padding_size = size(padding.left + padding.right, padding.top + padding.bottom); + // The floating point values produced by Taffy and ours often vary + // slightly after ~5 decimal places. This can lead to cases where after + // subtracting these, the container becomes scrollable for less than + // 0.00000x pixels. As we generally don't benefit from a precision that + // high for the maximum scroll, we round the scroll max to 2 decimal + // places here. let padded_content_size = self.content_size + padding_size; - let scroll_max = (padded_content_size - bounds.size).max(&Size::default()); + let scroll_max = (padded_content_size - bounds.size) + .map(round_to_two_decimals) + .max(&Default::default()); // Clamp scroll offset in case scroll max is smaller now (e.g., if children // were removed or the bounds became larger). let mut scroll_offset = scroll_offset.borrow_mut(); @@ -1692,7 +1705,7 @@ impl Interactivity { } if let Some(mut scroll_handle_state) = tracked_scroll_handle { - scroll_handle_state.padded_content_size = padded_content_size; + scroll_handle_state.max_offset = scroll_max; } *scroll_offset @@ -2936,7 +2949,7 @@ impl ScrollAnchor { struct ScrollHandleState { offset: Rc>>, bounds: Bounds, - padded_content_size: Size, + max_offset: Size, child_bounds: Vec>, scroll_to_bottom: bool, overflow: Point, @@ -2965,6 +2978,11 @@ impl ScrollHandle { *self.0.borrow().offset.borrow() } + /// Get the maximum scroll offset. + pub fn max_offset(&self) -> Size { + self.0.borrow().max_offset + } + /// Get the top child that's scrolled into view. pub fn top_item(&self) -> usize { let state = self.0.borrow(); @@ -2999,11 +3017,6 @@ impl ScrollHandle { self.0.borrow().child_bounds.get(ix).cloned() } - /// Get the size of the content with padding of the container. - pub fn padded_content_size(&self) -> Size { - self.0.borrow().padded_content_size - } - /// scroll_to_item scrolls the minimal amount to ensure that the child is /// fully visible pub fn scroll_to_item(&self, ix: usize) { diff --git a/crates/gpui/src/elements/list.rs b/crates/gpui/src/elements/list.rs index 35a3b622b2..f24d38794f 100644 --- a/crates/gpui/src/elements/list.rs +++ b/crates/gpui/src/elements/list.rs @@ -411,9 +411,9 @@ impl ListState { self.0.borrow_mut().set_offset_from_scrollbar(point); } - /// Returns the size of items we have measured. + /// Returns the maximum scroll offset according to the items we have measured. /// This value remains constant while dragging to prevent the scrollbar from moving away unexpectedly. - pub fn content_size_for_scrollbar(&self) -> Size { + pub fn max_offset_for_scrollbar(&self) -> Size { let state = self.0.borrow(); let bounds = state.last_layout_bounds.unwrap_or_default(); @@ -421,7 +421,7 @@ impl ListState { .scrollbar_drag_start_height .unwrap_or_else(|| state.items.summary().height); - Size::new(bounds.size.width, height) + Size::new(Pixels::ZERO, Pixels::ZERO.max(height - bounds.size.height)) } /// Returns the current scroll offset adjusted for the scrollbar diff --git a/crates/terminal_view/src/terminal_scrollbar.rs b/crates/terminal_view/src/terminal_scrollbar.rs index 18e135be2e..c8565a42be 100644 --- a/crates/terminal_view/src/terminal_scrollbar.rs +++ b/crates/terminal_view/src/terminal_scrollbar.rs @@ -46,9 +46,16 @@ impl TerminalScrollHandle { } impl ScrollableHandle for TerminalScrollHandle { - fn content_size(&self) -> Size { + fn max_offset(&self) -> Size { let state = self.state.borrow(); - size(Pixels::ZERO, state.total_lines as f32 * state.line_height) + size( + Pixels::ZERO, + state + .total_lines + .checked_sub(state.viewport_lines) + .unwrap_or(0) as f32 + * state.line_height, + ) } fn offset(&self) -> Point { diff --git a/crates/ui/src/components/scrollbar.rs b/crates/ui/src/components/scrollbar.rs index 2a8c4885ac..17ab2e788f 100644 --- a/crates/ui/src/components/scrollbar.rs +++ b/crates/ui/src/components/scrollbar.rs @@ -29,8 +29,8 @@ impl ThumbState { } impl ScrollableHandle for UniformListScrollHandle { - fn content_size(&self) -> Size { - self.0.borrow().base_handle.content_size() + fn max_offset(&self) -> Size { + self.0.borrow().base_handle.max_offset() } fn set_offset(&self, point: Point) { @@ -47,8 +47,8 @@ impl ScrollableHandle for UniformListScrollHandle { } impl ScrollableHandle for ListState { - fn content_size(&self) -> Size { - self.content_size_for_scrollbar() + fn max_offset(&self) -> Size { + self.max_offset_for_scrollbar() } fn set_offset(&self, point: Point) { @@ -73,8 +73,8 @@ impl ScrollableHandle for ListState { } impl ScrollableHandle for ScrollHandle { - fn content_size(&self) -> Size { - self.padded_content_size() + fn max_offset(&self) -> Size { + self.max_offset() } fn set_offset(&self, point: Point) { @@ -91,7 +91,10 @@ impl ScrollableHandle for ScrollHandle { } pub trait ScrollableHandle: Any + Debug { - fn content_size(&self) -> Size; + fn content_size(&self) -> Size { + self.viewport().size + self.max_offset() + } + fn max_offset(&self) -> Size; fn set_offset(&self, point: Point); fn offset(&self) -> Point; fn viewport(&self) -> Bounds; @@ -149,17 +152,17 @@ impl ScrollbarState { fn thumb_range(&self, axis: ScrollbarAxis) -> Option> { const MINIMUM_THUMB_SIZE: Pixels = px(25.); - let content_size = self.scroll_handle.content_size().along(axis); + let max_offset = self.scroll_handle.max_offset().along(axis); let viewport_size = self.scroll_handle.viewport().size.along(axis); - if content_size.is_zero() || viewport_size.is_zero() || content_size <= viewport_size { + if max_offset.is_zero() || viewport_size.is_zero() { return None; } + let content_size = viewport_size + max_offset; let visible_percentage = viewport_size / content_size; let thumb_size = MINIMUM_THUMB_SIZE.max(viewport_size * visible_percentage); if thumb_size > viewport_size { return None; } - let max_offset = content_size - viewport_size; let current_offset = self .scroll_handle .offset() @@ -307,7 +310,7 @@ impl Element for Scrollbar { let compute_click_offset = move |event_position: Point, - item_size: Size, + max_offset: Size, event_type: ScrollbarMouseEvent| { let viewport_size = padded_bounds.size.along(axis); @@ -323,7 +326,7 @@ impl Element for Scrollbar { - thumb_offset) .clamp(px(0.), viewport_size - thumb_size); - let max_offset = (item_size.along(axis) - viewport_size).max(px(0.)); + let max_offset = max_offset.along(axis); let percentage = if viewport_size > thumb_size { thumb_start / (viewport_size - thumb_size) } else { @@ -347,7 +350,7 @@ impl Element for Scrollbar { } else { let click_offset = compute_click_offset( event.position, - scroll.content_size(), + scroll.max_offset(), ScrollbarMouseEvent::GutterClick, ); scroll.set_offset(scroll.offset().apply_along(axis, |_| click_offset)); @@ -373,7 +376,7 @@ impl Element for Scrollbar { ThumbState::Dragging(drag_state) if event.dragging() => { let drag_offset = compute_click_offset( event.position, - scroll.content_size(), + scroll.max_offset(), ScrollbarMouseEvent::ThumbDrag(drag_state), ); scroll.set_offset(scroll.offset().apply_along(axis, |_| drag_offset)); diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs index 7cc10c27f7..e57b103c61 100644 --- a/crates/workspace/src/pane.rs +++ b/crates/workspace/src/pane.rs @@ -18,7 +18,7 @@ use futures::{StreamExt, stream::FuturesUnordered}; use gpui::{ Action, AnyElement, App, AsyncWindowContext, ClickEvent, ClipboardItem, Context, Corner, Div, DragMoveEvent, Entity, EntityId, EventEmitter, ExternalPaths, FocusHandle, FocusOutEvent, - Focusable, KeyContext, MouseButton, MouseDownEvent, NavigationDirection, Pixels, Point, + Focusable, IsZero, KeyContext, MouseButton, MouseDownEvent, NavigationDirection, Pixels, Point, PromptLevel, Render, ScrollHandle, Subscription, Task, WeakEntity, WeakFocusHandle, Window, actions, anchored, deferred, prelude::*, }; @@ -46,8 +46,8 @@ use theme::ThemeSettings; use ui::{ ButtonSize, Color, ContextMenu, ContextMenuEntry, ContextMenuItem, DecoratedIcon, IconButton, IconButtonShape, IconDecoration, IconDecorationKind, IconName, IconSize, Indicator, Label, - PopoverMenu, PopoverMenuHandle, ScrollableHandle, Tab, TabBar, TabPosition, Tooltip, - prelude::*, right_click_menu, + PopoverMenu, PopoverMenuHandle, Tab, TabBar, TabPosition, Tooltip, prelude::*, + right_click_menu, }; use util::{ResultExt, debug_panic, maybe, truncate_and_remove_front}; @@ -2865,10 +2865,9 @@ impl Pane { } }) .children(pinned_tabs.len().ne(&0).then(|| { - let content_width = self.tab_bar_scroll_handle.content_size().width; - let viewport_width = self.tab_bar_scroll_handle.viewport().size.width; + let max_scroll = self.tab_bar_scroll_handle.max_offset().width; // We need to check both because offset returns delta values even when the scroll handle is not scrollable - let is_scrollable = content_width > viewport_width; + let is_scrollable = !max_scroll.is_zero(); let is_scrolled = self.tab_bar_scroll_handle.offset().x < px(0.); let has_active_unpinned_tab = self.active_item_index >= self.pinned_tab_count; h_flex() From 722a05bc21aaa451908e208c674a45f0b1139b1c Mon Sep 17 00:00:00 2001 From: Agus Zubiaga Date: Mon, 21 Jul 2025 17:33:59 -0300 Subject: [PATCH 0105/1052] Wire up stop button in claude threads (#34839) Release Notes: - N/A --------- Co-authored-by: Ben Brandt --- Cargo.lock | 3 + crates/agent_servers/Cargo.toml | 5 + crates/agent_servers/src/claude.rs | 189 +++++++++++++++++++++-------- 3 files changed, 145 insertions(+), 52 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 4537d440cc..ad6c40bcf2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -150,7 +150,9 @@ dependencies = [ "indoc", "itertools 0.14.0", "language", + "libc", "log", + "nix 0.29.0", "paths", "project", "schemars", @@ -162,6 +164,7 @@ dependencies = [ "tempfile", "ui", "util", + "uuid", "watch", "which 6.0.3", "workspace-hack", diff --git a/crates/agent_servers/Cargo.toml b/crates/agent_servers/Cargo.toml index f3df25f709..4714245b94 100644 --- a/crates/agent_servers/Cargo.toml +++ b/crates/agent_servers/Cargo.toml @@ -37,10 +37,15 @@ strum.workspace = true tempfile.workspace = true ui.workspace = true util.workspace = true +uuid.workspace = true watch.workspace = true which.workspace = true workspace-hack.workspace = true +[target.'cfg(unix)'.dependencies] +libc.workspace = true +nix.workspace = true + [dev-dependencies] env_logger.workspace = true language.workspace = true diff --git a/crates/agent_servers/src/claude.rs b/crates/agent_servers/src/claude.rs index 8b3d93a122..835efbd655 100644 --- a/crates/agent_servers/src/claude.rs +++ b/crates/agent_servers/src/claude.rs @@ -4,10 +4,13 @@ mod tools; use collections::HashMap; use project::Project; use settings::SettingsStore; +use smol::process::Child; use std::cell::RefCell; use std::fmt::Display; use std::path::Path; +use std::pin::pin; use std::rc::Rc; +use uuid::Uuid; use agentic_coding_protocol::{ self as acp, AnyAgentRequest, AnyAgentResult, Client, ProtocolVersion, @@ -16,7 +19,7 @@ use agentic_coding_protocol::{ use anyhow::{Result, anyhow}; use futures::channel::oneshot; use futures::future::LocalBoxFuture; -use futures::{AsyncBufReadExt, AsyncWriteExt}; +use futures::{AsyncBufReadExt, AsyncWriteExt, SinkExt}; use futures::{ AsyncRead, AsyncWrite, FutureExt, StreamExt, channel::mpsc::{self, UnboundedReceiver, UnboundedSender}, @@ -69,13 +72,12 @@ impl AgentServer for ClaudeCode { let (mut delegate_tx, delegate_rx) = watch::channel(None); let tool_id_map = Rc::new(RefCell::new(HashMap::default())); - let permission_mcp_server = - ClaudeMcpServer::new(delegate_rx, tool_id_map.clone(), cx).await?; + let mcp_server = ClaudeMcpServer::new(delegate_rx, tool_id_map.clone(), cx).await?; let mut mcp_servers = HashMap::default(); mcp_servers.insert( mcp_server::SERVER_NAME.to_string(), - permission_mcp_server.server_config()?, + mcp_server.server_config()?, ); let mcp_config = McpConfig { mcp_servers }; @@ -98,50 +100,58 @@ impl AgentServer for ClaudeCode { anyhow::bail!("Failed to find claude binary"); }; - let mut child = util::command::new_smol_command(&command.path) - .args( - [ - "--input-format", - "stream-json", - "--output-format", - "stream-json", - "--print", - "--verbose", - "--mcp-config", - mcp_config_path.to_string_lossy().as_ref(), - "--permission-prompt-tool", - &format!( - "mcp__{}__{}", - mcp_server::SERVER_NAME, - mcp_server::PERMISSION_TOOL - ), - "--allowedTools", - "mcp__zed__Read,mcp__zed__Edit", - "--disallowedTools", - "Read,Edit", - ] - .into_iter() - .chain(command.args.iter().map(|arg| arg.as_str())), - ) - .current_dir(root_dir) - .stdin(std::process::Stdio::piped()) - .stdout(std::process::Stdio::piped()) - .stderr(std::process::Stdio::inherit()) - .kill_on_drop(true) - .spawn()?; - - let stdin = child.stdin.take().unwrap(); - let stdout = child.stdout.take().unwrap(); - let (incoming_message_tx, mut incoming_message_rx) = mpsc::unbounded(); let (outgoing_tx, outgoing_rx) = mpsc::unbounded(); + let (cancel_tx, mut cancel_rx) = mpsc::unbounded::>>(); + + let session_id = Uuid::new_v4(); + + log::trace!("Starting session with id: {}", session_id); - let io_task = - ClaudeAgentConnection::handle_io(outgoing_rx, incoming_message_tx, stdin, stdout); cx.background_spawn(async move { - io_task.await.log_err(); + let mut outgoing_rx = Some(outgoing_rx); + let mut mode = ClaudeSessionMode::Start; + + loop { + let mut child = + spawn_claude(&command, mode, session_id, &mcp_config_path, &root_dir) + .await?; + mode = ClaudeSessionMode::Resume; + + let pid = child.id(); + log::trace!("Spawned (pid: {})", pid); + + let mut io_fut = pin!( + ClaudeAgentConnection::handle_io( + outgoing_rx.take().unwrap(), + incoming_message_tx.clone(), + child.stdin.take().unwrap(), + child.stdout.take().unwrap(), + ) + .fuse() + ); + + select_biased! { + done_tx = cancel_rx.next() => { + if let Some(done_tx) = done_tx { + log::trace!("Interrupted (pid: {})", pid); + let result = send_interrupt(pid as i32); + outgoing_rx.replace(io_fut.await?); + done_tx.send(result).log_err(); + continue; + } + } + result = io_fut => { + result?; + } + } + + log::trace!("Stopped (pid: {})", pid); + break; + } + drop(mcp_config_path); - drop(child); + anyhow::Ok(()) }) .detach(); @@ -171,17 +181,32 @@ impl AgentServer for ClaudeCode { delegate, outgoing_tx, end_turn_tx, + cancel_tx, + session_id, _handler_task: handler_task, _mcp_server: None, }; - connection._mcp_server = Some(permission_mcp_server); + connection._mcp_server = Some(mcp_server); acp_thread::AcpThread::new(connection, title, None, project.clone(), cx) }) }) } } +#[cfg(unix)] +fn send_interrupt(pid: libc::pid_t) -> anyhow::Result<()> { + let pid = nix::unistd::Pid::from_raw(pid); + + nix::sys::signal::kill(pid, nix::sys::signal::SIGINT) + .map_err(|e| anyhow!("Failed to interrupt process: {}", e)) +} + +#[cfg(windows)] +fn send_interrupt(_pid: i32) -> anyhow::Result<()> { + panic!("Cancel not implemented on Windows") +} + impl AgentConnection for ClaudeAgentConnection { /// Send a request to the agent and wait for a response. fn request_any( @@ -191,6 +216,8 @@ impl AgentConnection for ClaudeAgentConnection { let delegate = self.delegate.clone(); let end_turn_tx = self.end_turn_tx.clone(); let outgoing_tx = self.outgoing_tx.clone(); + let mut cancel_tx = self.cancel_tx.clone(); + let session_id = self.session_id; async move { match params { // todo: consider sending an empty request so we get the init response? @@ -229,26 +256,83 @@ impl AgentConnection for ClaudeAgentConnection { stop_sequence: None, usage: None, }, - session_id: None, + session_id: Some(session_id), })?; rx.await??; Ok(AnyAgentResult::SendUserMessageResponse( acp::SendUserMessageResponse, )) } - AnyAgentRequest::CancelSendMessageParams(_) => Ok( - AnyAgentResult::CancelSendMessageResponse(acp::CancelSendMessageResponse), - ), + AnyAgentRequest::CancelSendMessageParams(_) => { + let (done_tx, done_rx) = oneshot::channel(); + cancel_tx.send(done_tx).await?; + done_rx.await??; + + Ok(AnyAgentResult::CancelSendMessageResponse( + acp::CancelSendMessageResponse, + )) + } } } .boxed_local() } } +#[derive(Clone, Copy)] +enum ClaudeSessionMode { + Start, + Resume, +} + +async fn spawn_claude( + command: &AgentServerCommand, + mode: ClaudeSessionMode, + session_id: Uuid, + mcp_config_path: &Path, + root_dir: &Path, +) -> Result { + let child = util::command::new_smol_command(&command.path) + .args([ + "--input-format", + "stream-json", + "--output-format", + "stream-json", + "--print", + "--verbose", + "--mcp-config", + mcp_config_path.to_string_lossy().as_ref(), + "--permission-prompt-tool", + &format!( + "mcp__{}__{}", + mcp_server::SERVER_NAME, + mcp_server::PERMISSION_TOOL + ), + "--allowedTools", + "mcp__zed__Read,mcp__zed__Edit", + "--disallowedTools", + "Read,Edit", + ]) + .args(match mode { + ClaudeSessionMode::Start => ["--session-id".to_string(), session_id.to_string()], + ClaudeSessionMode::Resume => ["--resume".to_string(), session_id.to_string()], + }) + .args(command.args.iter().map(|arg| arg.as_str())) + .current_dir(root_dir) + .stdin(std::process::Stdio::piped()) + .stdout(std::process::Stdio::piped()) + .stderr(std::process::Stdio::inherit()) + .kill_on_drop(true) + .spawn()?; + + Ok(child) +} + struct ClaudeAgentConnection { delegate: AcpClientDelegate, + session_id: Uuid, outgoing_tx: UnboundedSender, end_turn_tx: Rc>>>>, + cancel_tx: UnboundedSender>>, _mcp_server: Option, _handler_task: Task<()>, } @@ -350,7 +434,7 @@ impl ClaudeAgentConnection { incoming_tx: UnboundedSender, mut outgoing_bytes: impl Unpin + AsyncWrite, incoming_bytes: impl Unpin + AsyncRead, - ) -> Result<()> { + ) -> Result> { let mut output_reader = BufReader::new(incoming_bytes); let mut outgoing_line = Vec::new(); let mut incoming_line = String::new(); @@ -384,7 +468,8 @@ impl ClaudeAgentConnection { } } } - Ok(()) + + Ok(outgoing_rx) } } @@ -507,14 +592,14 @@ enum SdkMessage { Assistant { message: Message, // from Anthropic SDK #[serde(skip_serializing_if = "Option::is_none")] - session_id: Option, + session_id: Option, }, // A user message User { message: Message, // from Anthropic SDK #[serde(skip_serializing_if = "Option::is_none")] - session_id: Option, + session_id: Option, }, // Emitted as the last message in a conversation From 19ab1eb79258759e3ee0fef7017d259345b912e6 Mon Sep 17 00:00:00 2001 From: Sergei Surovtsev <97428129+stillonearth@users.noreply.github.com> Date: Tue, 22 Jul 2025 02:16:44 +0300 Subject: [PATCH 0106/1052] Fix an issue where xkb defined hotkeys for arrows would not work (#34823) Addresses https://github.com/zed-industries/zed/pull/34053#issuecomment-3096447601 where custom-defined arrows would stop working in Zed. How to reproduce: 1. Define custom keyboard layout ```bash cd /usr/share/X11/xkb/symbols/ sudo nano mykbd ``` ``` default partial alphanumeric_keys xkb_symbols "custom" { name[Group1]= "Custom Layout"; key { [ q, Q, Escape, Escape ] }; key { [ w, W, Home, Home ] }; key { [ e, E, Up, Up ] }; key { [ r, R, End, End ] }; key { [ t, T, Tab, Tab ] }; key { [ a, A, Return, Return ] }; key { [ s, S, Left, Left ] }; key { [ d, D, Down, Down ] }; key { [ f, F, Right, Right ] }; key { [ g, G, BackSpace, BackSpace ] }; // include a base layout to inherit the rest include "us(basic)" }; ``` 2. Activate custom layout with win-key as AltGr ```bash setxkbmap mykbd -variant custom -option lv3:win_switch ``` 3. Now Win-S should produce left arrow, Win-F right arrow 4. Test whether it works in Zed Release Notes: - linux: xkb-defined hotkeys for arrow keys should behave as expected. --------- Co-authored-by: Conrad Irwin --- crates/gpui/src/platform/linux/platform.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/crates/gpui/src/platform/linux/platform.rs b/crates/gpui/src/platform/linux/platform.rs index a52841e1af..d65118e994 100644 --- a/crates/gpui/src/platform/linux/platform.rs +++ b/crates/gpui/src/platform/linux/platform.rs @@ -828,6 +828,13 @@ impl crate::Keystroke { Keysym::Delete => "delete".to_owned(), Keysym::Escape => "escape".to_owned(), + Keysym::Left => "left".to_owned(), + Keysym::Right => "right".to_owned(), + Keysym::Up => "up".to_owned(), + Keysym::Down => "down".to_owned(), + Keysym::Home => "home".to_owned(), + Keysym::End => "end".to_owned(), + _ => { let name = xkb::keysym_get_name(key_sym).to_lowercase(); if key_sym.is_keypad_key() { From 8515487bbce339414940dd2deeac8e962f14118d Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Mon, 21 Jul 2025 20:39:29 -0300 Subject: [PATCH 0107/1052] agent: Add new thread start buttons to the empty state (#34829) Release Notes: - N/A --- assets/icons/ai_claude.svg | 4 +- assets/icons/ai_gemini.svg | 4 +- assets/icons/new_from_summary.svg | 7 + assets/icons/new_text_thread.svg | 7 + assets/icons/new_thread.svg | 3 + crates/agent_ui/src/agent_panel.rs | 230 +++++++++++++++++--- crates/agent_ui/src/ui.rs | 2 + crates/agent_ui/src/ui/new_thread_button.rs | 75 +++++++ crates/icons/src/icons.rs | 3 + 9 files changed, 297 insertions(+), 38 deletions(-) create mode 100644 assets/icons/new_from_summary.svg create mode 100644 assets/icons/new_text_thread.svg create mode 100644 assets/icons/new_thread.svg create mode 100644 crates/agent_ui/src/ui/new_thread_button.rs diff --git a/assets/icons/ai_claude.svg b/assets/icons/ai_claude.svg index 423a963eba..a3e3e1f4cd 100644 --- a/assets/icons/ai_claude.svg +++ b/assets/icons/ai_claude.svg @@ -1,3 +1,3 @@ - - + + diff --git a/assets/icons/ai_gemini.svg b/assets/icons/ai_gemini.svg index 60197dc4ad..bdde44ed24 100644 --- a/assets/icons/ai_gemini.svg +++ b/assets/icons/ai_gemini.svg @@ -1 +1,3 @@ -Google Gemini + + + diff --git a/assets/icons/new_from_summary.svg b/assets/icons/new_from_summary.svg new file mode 100644 index 0000000000..3b61ca51a0 --- /dev/null +++ b/assets/icons/new_from_summary.svg @@ -0,0 +1,7 @@ + + + + + + + diff --git a/assets/icons/new_text_thread.svg b/assets/icons/new_text_thread.svg new file mode 100644 index 0000000000..75afa934a0 --- /dev/null +++ b/assets/icons/new_text_thread.svg @@ -0,0 +1,7 @@ + + + + + + + diff --git a/assets/icons/new_thread.svg b/assets/icons/new_thread.svg new file mode 100644 index 0000000000..8c2596a4c9 --- /dev/null +++ b/assets/icons/new_thread.svg @@ -0,0 +1,3 @@ + + + diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 36851e44ba..57d16d6e59 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -12,6 +12,7 @@ use serde::{Deserialize, Serialize}; use crate::NewExternalAgentThread; use crate::agent_diff::AgentDiffThread; use crate::message_editor::{MAX_EDITOR_LINES, MIN_EDITOR_LINES}; +use crate::ui::NewThreadButton; use crate::{ AddContextServer, AgentDiffPane, ContinueThread, ContinueWithBurnMode, DeleteRecentlyOpenThread, ExpandMessageEditor, Follow, InlineAssistant, NewTextThread, @@ -66,8 +67,8 @@ use theme::ThemeSettings; use time::UtcOffset; use ui::utils::WithRemSize; use ui::{ - Banner, Callout, ContextMenu, ElevationIndex, KeyBinding, PopoverMenu, PopoverMenuHandle, - ProgressBar, Tab, Tooltip, prelude::*, + Banner, Callout, ContextMenu, ContextMenuEntry, ElevationIndex, KeyBinding, PopoverMenu, + PopoverMenuHandle, ProgressBar, Tab, Tooltip, prelude::*, }; use util::ResultExt as _; use workspace::{ @@ -1906,16 +1907,39 @@ impl AgentPanel { .when(cx.has_flag::(), |this| { this.header("Zed Agent") }) - .action("New Thread", NewThread::default().boxed_clone()) - .action("New Text Thread", NewTextThread.boxed_clone()) + .item( + ContextMenuEntry::new("New Thread") + .icon(IconName::NewThread) + .icon_color(Color::Muted) + .handler(move |window, cx| { + window.dispatch_action(NewThread::default().boxed_clone(), cx); + }), + ) + .item( + ContextMenuEntry::new("New Text Thread") + .icon(IconName::NewTextThread) + .icon_color(Color::Muted) + .handler(move |window, cx| { + window.dispatch_action(NewTextThread.boxed_clone(), cx); + }), + ) .when_some(active_thread, |this, active_thread| { let thread = active_thread.read(cx); + if !thread.is_empty() { - this.action( - "New From Summary", - Box::new(NewThread { - from_thread_id: Some(thread.id().clone()), - }), + let thread_id = thread.id().clone(); + this.item( + ContextMenuEntry::new("New From Summary") + .icon(IconName::NewFromSummary) + .icon_color(Color::Muted) + .handler(move |window, cx| { + window.dispatch_action( + Box::new(NewThread { + from_thread_id: Some(thread_id.clone()), + }), + cx, + ); + }), ) } else { this @@ -1924,19 +1948,33 @@ impl AgentPanel { .when(cx.has_flag::(), |this| { this.separator() .header("External Agents") - .action( - "New Gemini Thread", - NewExternalAgentThread { - agent: Some(crate::ExternalAgent::Gemini), - } - .boxed_clone(), + .item( + ContextMenuEntry::new("New Gemini Thread") + .icon(IconName::AiGemini) + .icon_color(Color::Muted) + .handler(move |window, cx| { + window.dispatch_action( + NewExternalAgentThread { + agent: Some(crate::ExternalAgent::Gemini), + } + .boxed_clone(), + cx, + ); + }), ) - .action( - "New Claude Code Thread", - NewExternalAgentThread { - agent: Some(crate::ExternalAgent::ClaudeCode), - } - .boxed_clone(), + .item( + ContextMenuEntry::new("New Claude Code Thread") + .icon(IconName::AiClaude) + .icon_color(Color::Muted) + .handler(move |window, cx| { + window.dispatch_action( + NewExternalAgentThread { + agent: Some(crate::ExternalAgent::ClaudeCode), + } + .boxed_clone(), + cx, + ); + }), ) }); menu @@ -2285,6 +2323,28 @@ impl AgentPanel { }))) } + fn render_empty_state_section_header( + &self, + label: impl Into, + action_slot: Option, + cx: &mut Context, + ) -> impl IntoElement { + h_flex() + .mt_2() + .pl_1p5() + .pb_1() + .w_full() + .justify_between() + .border_b_1() + .border_color(cx.theme().colors().border_variant) + .child( + Label::new(label.into()) + .size(LabelSize::Small) + .color(Color::Muted), + ) + .children(action_slot) + } + fn render_thread_empty_state( &self, window: &mut Window, @@ -2407,19 +2467,9 @@ impl AgentPanel { .justify_end() .gap_1() .child( - h_flex() - .pl_1p5() - .pb_1() - .w_full() - .justify_between() - .border_b_1() - .border_color(cx.theme().colors().border_variant) - .child( - Label::new("Recent") - .size(LabelSize::Small) - .color(Color::Muted), - ) - .child( + self.render_empty_state_section_header( + "Recent", + Some( Button::new("view-history", "View All") .style(ButtonStyle::Subtle) .label_size(LabelSize::Small) @@ -2434,8 +2484,11 @@ impl AgentPanel { ) .on_click(move |_event, window, cx| { window.dispatch_action(OpenHistory.boxed_clone(), cx); - }), + }) + .into_any_element(), ), + cx, + ), ) .child( v_flex() @@ -2463,6 +2516,113 @@ impl AgentPanel { }, )), ) + .child(self.render_empty_state_section_header("Start", None, cx)) + .child( + v_flex() + .p_1() + .gap_2() + .child( + h_flex() + .w_full() + .gap_2() + .child( + NewThreadButton::new( + "new-thread-btn", + "New Thread", + IconName::NewThread, + ) + .keybinding(KeyBinding::for_action_in( + &NewThread::default(), + &self.focus_handle(cx), + window, + cx, + )) + .on_click( + |window, cx| { + window.dispatch_action( + NewThread::default().boxed_clone(), + cx, + ) + }, + ), + ) + .child( + NewThreadButton::new( + "new-text-thread-btn", + "New Text Thread", + IconName::NewTextThread, + ) + .keybinding(KeyBinding::for_action_in( + &NewTextThread, + &self.focus_handle(cx), + window, + cx, + )) + .on_click( + |window, cx| { + window.dispatch_action(Box::new(NewTextThread), cx) + }, + ), + ), + ) + .when(cx.has_flag::(), |this| { + this.child( + h_flex() + .w_full() + .gap_2() + .child( + NewThreadButton::new( + "new-gemini-thread-btn", + "New Gemini Thread", + IconName::AiGemini, + ) + // .keybinding(KeyBinding::for_action_in( + // &OpenHistory, + // &self.focus_handle(cx), + // window, + // cx, + // )) + .on_click( + |window, cx| { + window.dispatch_action( + Box::new(NewExternalAgentThread { + agent: Some( + crate::ExternalAgent::Gemini, + ), + }), + cx, + ) + }, + ), + ) + .child( + NewThreadButton::new( + "new-claude-thread-btn", + "New Claude Code Thread", + IconName::AiClaude, + ) + // .keybinding(KeyBinding::for_action_in( + // &OpenHistory, + // &self.focus_handle(cx), + // window, + // cx, + // )) + .on_click( + |window, cx| { + window.dispatch_action( + Box::new(NewExternalAgentThread { + agent: Some( + crate::ExternalAgent::ClaudeCode, + ), + }), + cx, + ) + }, + ), + ), + ) + }), + ) .when_some(configuration_error.as_ref(), |this, err| { this.child(self.render_configuration_error(err, &focus_handle, window, cx)) }) diff --git a/crates/agent_ui/src/ui.rs b/crates/agent_ui/src/ui.rs index 6398f64abb..15f2e28e58 100644 --- a/crates/agent_ui/src/ui.rs +++ b/crates/agent_ui/src/ui.rs @@ -2,6 +2,7 @@ mod agent_notification; mod burn_mode_tooltip; mod context_pill; mod end_trial_upsell; +mod new_thread_button; mod onboarding_modal; pub mod preview; mod upsell; @@ -10,4 +11,5 @@ pub use agent_notification::*; pub use burn_mode_tooltip::*; pub use context_pill::*; pub use end_trial_upsell::*; +pub use new_thread_button::*; pub use onboarding_modal::*; diff --git a/crates/agent_ui/src/ui/new_thread_button.rs b/crates/agent_ui/src/ui/new_thread_button.rs new file mode 100644 index 0000000000..7764144150 --- /dev/null +++ b/crates/agent_ui/src/ui/new_thread_button.rs @@ -0,0 +1,75 @@ +use gpui::{ClickEvent, ElementId, IntoElement, ParentElement, Styled}; +use ui::prelude::*; + +#[derive(IntoElement)] +pub struct NewThreadButton { + id: ElementId, + label: SharedString, + icon: IconName, + keybinding: Option, + on_click: Option>, +} + +impl NewThreadButton { + pub fn new(id: impl Into, label: impl Into, icon: IconName) -> Self { + Self { + id: id.into(), + label: label.into(), + icon, + keybinding: None, + on_click: None, + } + } + + pub fn keybinding(mut self, keybinding: Option) -> Self { + self.keybinding = keybinding; + self + } + + pub fn on_click(mut self, handler: F) -> Self + where + F: Fn(&mut Window, &mut App) + 'static, + { + self.on_click = Some(Box::new( + move |_: &ClickEvent, window: &mut Window, cx: &mut App| handler(window, cx), + )); + self + } +} + +impl RenderOnce for NewThreadButton { + fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement { + h_flex() + .id(self.id) + .w_full() + .py_1p5() + .px_2() + .gap_1() + .justify_between() + .rounded_md() + .border_1() + .border_color(cx.theme().colors().border.opacity(0.4)) + .bg(cx.theme().colors().element_active.opacity(0.2)) + .hover(|style| { + style + .bg(cx.theme().colors().element_hover) + .border_color(cx.theme().colors().border) + }) + .child( + h_flex() + .gap_1p5() + .child( + Icon::new(self.icon) + .size(IconSize::XSmall) + .color(Color::Muted), + ) + .child(Label::new(self.label).size(LabelSize::Small)), + ) + .when_some(self.keybinding, |this, keybinding| { + this.child(keybinding.size(rems_from_px(10.))) + }) + .when_some(self.on_click, |this, on_click| { + this.on_click(move |event, window, cx| on_click(event, window, cx)) + }) + } +} diff --git a/crates/icons/src/icons.rs b/crates/icons/src/icons.rs index 631ccc1af3..b85e5b517d 100644 --- a/crates/icons/src/icons.rs +++ b/crates/icons/src/icons.rs @@ -181,6 +181,9 @@ pub enum IconName { MicMute, Microscope, Minimize, + NewFromSummary, + NewTextThread, + NewThread, Option, PageDown, PageUp, From 5289b815fe8b386a737b21ec837fb4827381de07 Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Mon, 21 Jul 2025 19:58:16 -0400 Subject: [PATCH 0108/1052] ai_onboarding: Send users directly into the trial checkout flow when starting the trial (#34859) This PR makes it so users will be sent immediately into the trial checkout flow (by hitting zed.dev/account/start-trial) when they click the "Start Pro Trial" button. Release Notes: - N/A --- crates/ai_onboarding/src/ai_onboarding.rs | 2 +- crates/client/src/zed_urls.rs | 8 ++++++++ 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/crates/ai_onboarding/src/ai_onboarding.rs b/crates/ai_onboarding/src/ai_onboarding.rs index f19b8821fa..9c53078e5a 100644 --- a/crates/ai_onboarding/src/ai_onboarding.rs +++ b/crates/ai_onboarding/src/ai_onboarding.rs @@ -146,7 +146,7 @@ impl ZedAiOnboarding { let (button_label, button_url) = if self.account_too_young { ("Start with Pro", zed_urls::upgrade_to_zed_pro_url(cx)) } else { - ("Start Pro Trial", zed_urls::account_url(cx)) + ("Start Pro Trial", zed_urls::start_trial_url(cx)) }; v_flex() diff --git a/crates/client/src/zed_urls.rs b/crates/client/src/zed_urls.rs index 442875b451..e36f5f65da 100644 --- a/crates/client/src/zed_urls.rs +++ b/crates/client/src/zed_urls.rs @@ -18,6 +18,14 @@ pub fn account_url(cx: &App) -> String { format!("{server_url}/account", server_url = server_url(cx)) } +/// Returns the URL to the start trial page on zed.dev. +pub fn start_trial_url(cx: &App) -> String { + format!( + "{server_url}/account/start-trial", + server_url = server_url(cx) + ) +} + /// Returns the URL to the upgrade page on zed.dev. pub fn upgrade_to_zed_pro_url(cx: &App) -> String { format!("{server_url}/account/upgrade", server_url = server_url(cx)) From 15353630e4f8f1f3db8f230e078de2f42bdbfb7b Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Mon, 21 Jul 2025 21:11:11 -0400 Subject: [PATCH 0109/1052] zed: Add `OpenRequestKind` (#34860) This PR refactors the `OpenRequest` to introduce an `OpenRequestKind` enum. It seems most of the fields on `OpenRequest` are mutually-exclusive, so it is better to model it as an enum rather than using a bunch of `Option`s. There are likely more of the existing fields that can be converted into `OpenRequestKind` variants, but I'm being conservative for this first pass. Release Notes: - N/A --- crates/zed/src/main.rs | 54 ++++++++++++++++------------- crates/zed/src/zed/open_listener.rs | 23 ++++++++---- 2 files changed, 45 insertions(+), 32 deletions(-) diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs index a9d3d63381..c7856931ef 100644 --- a/crates/zed/src/main.rs +++ b/crates/zed/src/main.rs @@ -55,6 +55,8 @@ use zed::{ inline_completion_registry, open_paths_with_positions, }; +use crate::zed::OpenRequestKind; + #[cfg(feature = "mimalloc")] #[global_allocator] static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc; @@ -746,32 +748,34 @@ pub fn main() { } fn handle_open_request(request: OpenRequest, app_state: Arc, cx: &mut App) { - if let Some(connection) = request.cli_connection { - let app_state = app_state.clone(); - cx.spawn(async move |cx| handle_cli_connection(connection, app_state, cx).await) - .detach(); - return; - } + if let Some(kind) = request.kind { + match kind { + OpenRequestKind::CliConnection(connection) => { + let app_state = app_state.clone(); + cx.spawn(async move |cx| handle_cli_connection(connection, app_state, cx).await) + .detach(); + } + OpenRequestKind::Extension { extension_id } => { + cx.spawn(async move |cx| { + let workspace = + workspace::get_any_active_workspace(app_state, cx.clone()).await?; + workspace.update(cx, |_, window, cx| { + window.dispatch_action( + Box::new(zed_actions::Extensions { + category_filter: None, + id: Some(extension_id), + }), + cx, + ); + }) + }) + .detach_and_log_err(cx); + } + OpenRequestKind::DockMenuAction { index } => { + cx.perform_dock_menu_action(index); + } + } - if let Some(action_index) = request.dock_menu_action { - cx.perform_dock_menu_action(action_index); - return; - } - - if let Some(extension) = request.extension_id { - cx.spawn(async move |cx| { - let workspace = workspace::get_any_active_workspace(app_state, cx.clone()).await?; - workspace.update(cx, |_, window, cx| { - window.dispatch_action( - Box::new(zed_actions::Extensions { - category_filter: None, - id: Some(extension), - }), - cx, - ); - }) - }) - .detach_and_log_err(cx); return; } diff --git a/crates/zed/src/zed/open_listener.rs b/crates/zed/src/zed/open_listener.rs index 42eb8198a4..af646465be 100644 --- a/crates/zed/src/zed/open_listener.rs +++ b/crates/zed/src/zed/open_listener.rs @@ -30,14 +30,19 @@ use workspace::{AppState, OpenOptions, SerializedWorkspaceLocation, Workspace}; #[derive(Default, Debug)] pub struct OpenRequest { - pub cli_connection: Option<(mpsc::Receiver, IpcSender)>, + pub kind: Option, pub open_paths: Vec, pub diff_paths: Vec<[String; 2]>, pub open_channel_notes: Vec<(u64, Option)>, pub join_channel: Option, pub ssh_connection: Option, - pub dock_menu_action: Option, - pub extension_id: Option, +} + +#[derive(Debug)] +pub enum OpenRequestKind { + CliConnection((mpsc::Receiver, IpcSender)), + Extension { extension_id: String }, + DockMenuAction { index: usize }, } impl OpenRequest { @@ -45,9 +50,11 @@ impl OpenRequest { let mut this = Self::default(); for url in request.urls { if let Some(server_name) = url.strip_prefix("zed-cli://") { - this.cli_connection = Some(connect_to_cli(server_name)?); + this.kind = Some(OpenRequestKind::CliConnection(connect_to_cli(server_name)?)); } else if let Some(action_index) = url.strip_prefix("zed-dock-action://") { - this.dock_menu_action = Some(action_index.parse()?); + this.kind = Some(OpenRequestKind::DockMenuAction { + index: action_index.parse()?, + }); } else if let Some(file) = url.strip_prefix("file://") { this.parse_file_path(file) } else if let Some(file) = url.strip_prefix("zed://file") { @@ -55,8 +62,10 @@ impl OpenRequest { } else if let Some(file) = url.strip_prefix("zed://ssh") { let ssh_url = "ssh:/".to_string() + file; this.parse_ssh_file_path(&ssh_url, cx)? - } else if let Some(file) = url.strip_prefix("zed://extension/") { - this.extension_id = Some(file.to_string()) + } else if let Some(extension_id) = url.strip_prefix("zed://extension/") { + this.kind = Some(OpenRequestKind::Extension { + extension_id: extension_id.to_string(), + }); } else if url.starts_with("ssh://") { this.parse_ssh_file_path(&url, cx)? } else if let Some(request_path) = parse_zed_link(&url, cx) { From 233e66d35f888a84f76317f5e23ab14a279ae806 Mon Sep 17 00:00:00 2001 From: Daste Date: Tue, 22 Jul 2025 03:30:23 +0200 Subject: [PATCH 0110/1052] Add `editor::BlameHover` action for triggering the blame popover via keyboard (#32096) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Make the git blame popover available via the keymap by making it an action. The blame popover stays open after being shown via the action, similar to the `editor::Hover` action. I added a default vim-mode key binding for `g b`, which goes in hand with `g h` for hover. I'm not sure what the keybind would be for regular layouts, if any would be set by default. I'm opening this as a draft because I coludn't figure out a way to position the popover correctly above/under the cursor head. I saw some uses of `content_origin` in other places for calculating absolute pixel positions, but I'm not sure how to make use of it here without doing a big refactor of the blame popover code 🤔. I would appreciate some help/tips with positioning, because it seems like the last thing to implement here. Opening as a draft for now because I think without the correct positioning this feature is not complete. Closes https://github.com/zed-industries/zed/discussions/26447 Release Notes: - Added `editor::BlameHover` action for showing the git blame popover under the cursor. By default bound to `ctrl-k ctrl-b` and to `g h` in vim mode. --- assets/keymaps/default-linux.json | 1 + assets/keymaps/default-macos.json | 1 + assets/keymaps/vim.json | 1 + crates/editor/src/actions.rs | 2 ++ crates/editor/src/editor.rs | 44 ++++++++++++++++++++++++++++--- crates/editor/src/element.rs | 9 +++++-- 6 files changed, 52 insertions(+), 6 deletions(-) diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index 377a26242b..4918e654fc 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -483,6 +483,7 @@ "ctrl-k ctrl-d": ["editor::SelectNext", { "replace_newest": true }], // editor.action.moveSelectionToNextFindMatch / find_under_expand_skip "ctrl-k ctrl-shift-d": ["editor::SelectPrevious", { "replace_newest": true }], // editor.action.moveSelectionToPreviousFindMatch "ctrl-k ctrl-i": "editor::Hover", + "ctrl-k ctrl-b": "editor::BlameHover", "ctrl-/": ["editor::ToggleComments", { "advance_downwards": false }], "f8": ["editor::GoToDiagnostic", { "severity": { "min": "hint", "max": "error" } }], "shift-f8": ["editor::GoToPreviousDiagnostic", { "severity": { "min": "hint", "max": "error" } }], diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index 712d73b8ec..60f29b1da1 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -537,6 +537,7 @@ "ctrl-cmd-d": ["editor::SelectPrevious", { "replace_newest": false }], // editor.action.addSelectionToPreviousFindMatch "cmd-k ctrl-cmd-d": ["editor::SelectPrevious", { "replace_newest": true }], // editor.action.moveSelectionToPreviousFindMatch "cmd-k cmd-i": "editor::Hover", + "cmd-k cmd-b": "editor::BlameHover", "cmd-/": ["editor::ToggleComments", { "advance_downwards": false }], "f8": ["editor::GoToDiagnostic", { "severity": { "min": "hint", "max": "error" } }], "shift-f8": ["editor::GoToPreviousDiagnostic", { "severity": { "min": "hint", "max": "error" } }], diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json index 04e6b0bcd4..d0cf4621a5 100644 --- a/assets/keymaps/vim.json +++ b/assets/keymaps/vim.json @@ -124,6 +124,7 @@ "g r a": "editor::ToggleCodeActions", "g g": "vim::StartOfDocument", "g h": "editor::Hover", + "g B": "editor::BlameHover", "g t": "pane::ActivateNextItem", "g shift-t": "pane::ActivatePreviousItem", "g d": "editor::GoToDefinition", diff --git a/crates/editor/src/actions.rs b/crates/editor/src/actions.rs index 87463d246d..8557b57f46 100644 --- a/crates/editor/src/actions.rs +++ b/crates/editor/src/actions.rs @@ -322,6 +322,8 @@ actions!( ApplyDiffHunk, /// Deletes the character before the cursor. Backspace, + /// Shows git blame information for the current line. + BlameHover, /// Cancels the current operation. Cancel, /// Cancels the running flycheck operation. diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index b8dcdd35e0..1f985eeb7c 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -950,6 +950,7 @@ struct InlineBlamePopover { hide_task: Option>, popover_bounds: Option>, popover_state: InlineBlamePopoverState, + keyboard_grace: bool, } enum SelectionDragState { @@ -6517,21 +6518,55 @@ impl Editor { } } + pub fn blame_hover(&mut self, _: &BlameHover, window: &mut Window, cx: &mut Context) { + let snapshot = self.snapshot(window, cx); + let cursor = self.selections.newest::(cx).head(); + let Some((buffer, point, _)) = snapshot.buffer_snapshot.point_to_buffer_point(cursor) + else { + return; + }; + + let Some(blame) = self.blame.as_ref() else { + return; + }; + + let row_info = RowInfo { + buffer_id: Some(buffer.remote_id()), + buffer_row: Some(point.row), + ..Default::default() + }; + let Some(blame_entry) = blame + .update(cx, |blame, cx| blame.blame_for_rows(&[row_info], cx).next()) + .flatten() + else { + return; + }; + + let anchor = self.selections.newest_anchor().head(); + let position = self.to_pixel_point(anchor, &snapshot, window); + if let (Some(position), Some(last_bounds)) = (position, self.last_bounds) { + self.show_blame_popover(&blame_entry, position + last_bounds.origin, true, cx); + }; + } + fn show_blame_popover( &mut self, blame_entry: &BlameEntry, position: gpui::Point, + ignore_timeout: bool, cx: &mut Context, ) { if let Some(state) = &mut self.inline_blame_popover { state.hide_task.take(); } else { - let delay = EditorSettings::get_global(cx).hover_popover_delay; + let blame_popover_delay = EditorSettings::get_global(cx).hover_popover_delay; let blame_entry = blame_entry.clone(); let show_task = cx.spawn(async move |editor, cx| { - cx.background_executor() - .timer(std::time::Duration::from_millis(delay)) - .await; + if !ignore_timeout { + cx.background_executor() + .timer(std::time::Duration::from_millis(blame_popover_delay)) + .await; + } editor .update(cx, |editor, cx| { editor.inline_blame_popover_show_task.take(); @@ -6560,6 +6595,7 @@ impl Editor { commit_message: details, markdown, }, + keyboard_grace: ignore_timeout, }); cx.notify(); }) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index fef185bb15..cbff544c7e 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -216,6 +216,7 @@ impl EditorElement { register_action(editor, window, Editor::newline_above); register_action(editor, window, Editor::newline_below); register_action(editor, window, Editor::backspace); + register_action(editor, window, Editor::blame_hover); register_action(editor, window, Editor::delete); register_action(editor, window, Editor::tab); register_action(editor, window, Editor::backtab); @@ -1143,10 +1144,14 @@ impl EditorElement { .as_ref() .and_then(|state| state.popover_bounds) .map_or(false, |bounds| bounds.contains(&event.position)); + let keyboard_grace = editor + .inline_blame_popover + .as_ref() + .map_or(false, |state| state.keyboard_grace); if mouse_over_inline_blame || mouse_over_popover { - editor.show_blame_popover(&blame_entry, event.position, cx); - } else { + editor.show_blame_popover(&blame_entry, event.position, false, cx); + } else if !keyboard_grace { editor.hide_blame_popover(cx); } } else { From 5a530ecd39f8be386a98cabef45c13163ff1da19 Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Mon, 21 Jul 2025 21:40:33 -0400 Subject: [PATCH 0111/1052] zed: Add support for `zed://agent` links (#34862) This PR adds support for `zed://agent` links for opening the Agent Panel. Release Notes: - N/A --- crates/zed/src/main.rs | 15 ++++++++++++++- crates/zed/src/zed/open_listener.rs | 3 +++ 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs index c7856931ef..c9b8eebff6 100644 --- a/crates/zed/src/main.rs +++ b/crates/zed/src/main.rs @@ -1,6 +1,7 @@ mod reliability; mod zed; +use agent_ui::AgentPanel; use anyhow::{Context as _, Result}; use clap::{Parser, command}; use cli::FORCE_CLI_MODE_ENV_VAR_NAME; @@ -14,7 +15,7 @@ use extension_host::ExtensionStore; use fs::{Fs, RealFs}; use futures::{StreamExt, channel::oneshot, future}; use git::GitHostingProviderRegistry; -use gpui::{App, AppContext as _, Application, AsyncApp, UpdateGlobal as _}; +use gpui::{App, AppContext as _, Application, AsyncApp, Focusable as _, UpdateGlobal as _}; use gpui_tokio::Tokio; use http_client::{Url, read_proxy_from_env}; @@ -771,6 +772,18 @@ fn handle_open_request(request: OpenRequest, app_state: Arc, cx: &mut }) .detach_and_log_err(cx); } + OpenRequestKind::AgentPanel => { + cx.spawn(async move |cx| { + let workspace = + workspace::get_any_active_workspace(app_state, cx.clone()).await?; + workspace.update(cx, |workspace, window, cx| { + if let Some(panel) = workspace.panel::(cx) { + panel.focus_handle(cx).focus(window); + } + }) + }) + .detach_and_log_err(cx); + } OpenRequestKind::DockMenuAction { index } => { cx.perform_dock_menu_action(index); } diff --git a/crates/zed/src/zed/open_listener.rs b/crates/zed/src/zed/open_listener.rs index af646465be..b6feb0073e 100644 --- a/crates/zed/src/zed/open_listener.rs +++ b/crates/zed/src/zed/open_listener.rs @@ -42,6 +42,7 @@ pub struct OpenRequest { pub enum OpenRequestKind { CliConnection((mpsc::Receiver, IpcSender)), Extension { extension_id: String }, + AgentPanel, DockMenuAction { index: usize }, } @@ -66,6 +67,8 @@ impl OpenRequest { this.kind = Some(OpenRequestKind::Extension { extension_id: extension_id.to_string(), }); + } else if url == "zed://agent" { + this.kind = Some(OpenRequestKind::AgentPanel); } else if url.starts_with("ssh://") { this.parse_ssh_file_path(&url, cx)? } else if let Some(request_path) = parse_zed_link(&url, cx) { From eaccd542fd5e03a93fd1b2f7d02c874f3d491abf Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Tue, 22 Jul 2025 02:09:05 -0300 Subject: [PATCH 0112/1052] Add fast-follows to the AI onboarding flow (#34737) Follow-up to https://github.com/zed-industries/zed/pull/33738. Release Notes: - N/A --------- Co-authored-by: Bennet Bo Fenner --- crates/agent_ui/src/agent_panel.rs | 30 +- crates/agent_ui/src/message_editor.rs | 23 +- .../src/agent_api_keys_onboarding.rs | 135 ++++++++ .../src/agent_panel_onboarding_card.rs | 8 +- .../src/agent_panel_onboarding_content.rs | 114 ++----- crates/ai_onboarding/src/ai_onboarding.rs | 291 +++++++++++------- .../ai_onboarding/src/young_account_banner.rs | 2 +- crates/client/src/zed_urls.rs | 5 + crates/language_model/src/registry.rs | 4 +- crates/language_models/src/provider/cloud.rs | 12 +- 10 files changed, 409 insertions(+), 215 deletions(-) create mode 100644 crates/ai_onboarding/src/agent_api_keys_onboarding.rs diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 57d16d6e59..fc803c730e 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -2300,7 +2300,20 @@ impl AgentPanel { return None; } - Some(div().size_full().child(self.onboarding.clone())) + let thread_view = matches!(&self.active_view, ActiveView::Thread { .. }); + let text_thread_view = matches!(&self.active_view, ActiveView::TextThread { .. }); + + Some( + div() + .size_full() + .when(thread_view, |this| { + this.bg(cx.theme().colors().panel_background) + }) + .when(text_thread_view, |this| { + this.bg(cx.theme().colors().editor_background) + }) + .child(self.onboarding.clone()), + ) } fn render_trial_end_upsell( @@ -3237,7 +3250,20 @@ impl Render for AgentPanel { .into_any(), ) }) - .child(h_flex().child(message_editor.clone())) + .child(h_flex().relative().child(message_editor.clone()).when( + !LanguageModelRegistry::read_global(cx).has_authenticated_provider(cx), + |this| { + this.child( + div() + .size_full() + .absolute() + .inset_0() + .bg(cx.theme().colors().panel_background) + .opacity(0.8) + .block_mouse_except_scroll(), + ) + }, + )) .child(self.render_drag_target(cx)), ActiveView::ExternalAgentThread { thread_view, .. } => parent .relative() diff --git a/crates/agent_ui/src/message_editor.rs b/crates/agent_ui/src/message_editor.rs index a2cf4aac48..69eae982f8 100644 --- a/crates/agent_ui/src/message_editor.rs +++ b/crates/agent_ui/src/message_editor.rs @@ -14,6 +14,7 @@ use agent::{ context_store::ContextStoreEvent, }; use agent_settings::{AgentSettings, CompletionMode}; +use ai_onboarding::ApiKeysWithProviders; use buffer_diff::BufferDiff; use client::UserStore; use collections::{HashMap, HashSet}; @@ -33,7 +34,8 @@ use gpui::{ }; use language::{Buffer, Language, Point}; use language_model::{ - ConfiguredModel, LanguageModelRequestMessage, MessageContent, ZED_CLOUD_PROVIDER_ID, + ConfiguredModel, LanguageModelRegistry, LanguageModelRequestMessage, MessageContent, + ZED_CLOUD_PROVIDER_ID, }; use multi_buffer; use project::Project; @@ -1655,9 +1657,28 @@ impl Render for MessageEditor { let line_height = TextSize::Small.rems(cx).to_pixels(window.rem_size()) * 1.5; + let enrolled_in_trial = matches!( + self.user_store.read(cx).current_plan(), + Some(proto::Plan::ZedProTrial) + ); + + let configured_providers: Vec<(IconName, SharedString)> = + LanguageModelRegistry::read_global(cx) + .providers() + .iter() + .filter(|provider| { + provider.is_authenticated(cx) && provider.id() != ZED_CLOUD_PROVIDER_ID + }) + .map(|provider| (provider.icon(), provider.name().0.clone())) + .collect(); + let has_existing_providers = configured_providers.len() > 0; + v_flex() .size_full() .bg(cx.theme().colors().panel_background) + .when(has_existing_providers && !enrolled_in_trial, |this| { + this.child(cx.new(ApiKeysWithProviders::new)) + }) .when(changed_buffers.len() > 0, |parent| { parent.child(self.render_edits_bar(&changed_buffers, window, cx)) }) diff --git a/crates/ai_onboarding/src/agent_api_keys_onboarding.rs b/crates/ai_onboarding/src/agent_api_keys_onboarding.rs new file mode 100644 index 0000000000..4f9e20cf77 --- /dev/null +++ b/crates/ai_onboarding/src/agent_api_keys_onboarding.rs @@ -0,0 +1,135 @@ +use gpui::{Action, IntoElement, ParentElement, RenderOnce, point}; +use language_model::{LanguageModelRegistry, ZED_CLOUD_PROVIDER_ID}; +use ui::{Divider, List, prelude::*}; + +use crate::BulletItem; + +pub struct ApiKeysWithProviders { + configured_providers: Vec<(IconName, SharedString)>, +} + +impl ApiKeysWithProviders { + pub fn new(cx: &mut Context) -> Self { + cx.subscribe( + &LanguageModelRegistry::global(cx), + |this: &mut Self, _registry, event: &language_model::Event, cx| match event { + language_model::Event::ProviderStateChanged + | language_model::Event::AddedProvider(_) + | language_model::Event::RemovedProvider(_) => { + this.configured_providers = Self::compute_configured_providers(cx) + } + _ => {} + }, + ) + .detach(); + + Self { + configured_providers: Self::compute_configured_providers(cx), + } + } + + fn compute_configured_providers(cx: &App) -> Vec<(IconName, SharedString)> { + LanguageModelRegistry::read_global(cx) + .providers() + .iter() + .filter(|provider| { + provider.is_authenticated(cx) && provider.id() != ZED_CLOUD_PROVIDER_ID + }) + .map(|provider| (provider.icon(), provider.name().0.clone())) + .collect() + } + + pub fn has_providers(&self) -> bool { + !self.configured_providers.is_empty() + } +} + +impl Render for ApiKeysWithProviders { + fn render(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement { + let configured_providers_list = + self.configured_providers + .iter() + .cloned() + .map(|(icon, name)| { + h_flex() + .gap_1p5() + .child(Icon::new(icon).size(IconSize::Small).color(Color::Muted)) + .child(Label::new(name)) + }); + + h_flex() + .mx_2p5() + .p_1() + .pb_0() + .gap_2() + .rounded_t_lg() + .border_t_1() + .border_x_1() + .border_color(cx.theme().colors().border.opacity(0.5)) + .bg(cx.theme().colors().background.alpha(0.5)) + .shadow(vec![gpui::BoxShadow { + color: gpui::black().opacity(0.15), + offset: point(px(1.), px(-1.)), + blur_radius: px(3.), + spread_radius: px(0.), + }]) + .child( + h_flex() + .px_2p5() + .py_1p5() + .gap_2() + .flex_wrap() + .rounded_t(px(5.)) + .overflow_hidden() + .border_t_1() + .border_x_1() + .border_color(cx.theme().colors().border) + .bg(cx.theme().colors().panel_background) + .child(Icon::new(IconName::Info).size(IconSize::XSmall).color(Color::Muted)) + .child(Label::new("Or start now using API keys from your environment for the following providers:").color(Color::Muted)) + .children(configured_providers_list) + ) + } +} + +#[derive(IntoElement)] +pub struct ApiKeysWithoutProviders; + +impl ApiKeysWithoutProviders { + pub fn new() -> Self { + Self + } +} + +impl RenderOnce for ApiKeysWithoutProviders { + fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement { + v_flex() + .mt_2() + .gap_1() + .child( + h_flex() + .gap_2() + .child( + Label::new("API Keys") + .size(LabelSize::Small) + .color(Color::Muted) + .buffer_font(cx), + ) + .child(Divider::horizontal()), + ) + .child(List::new().child(BulletItem::new( + "You can also use AI in Zed by bringing your own API keys", + ))) + .child( + Button::new("configure-providers", "Configure Providers") + .full_width() + .style(ButtonStyle::Outlined) + .on_click(move |_, window, cx| { + window.dispatch_action( + zed_actions::agent::OpenConfiguration.boxed_clone(), + cx, + ); + }), + ) + } +} diff --git a/crates/ai_onboarding/src/agent_panel_onboarding_card.rs b/crates/ai_onboarding/src/agent_panel_onboarding_card.rs index 8ec9ccfe22..c63c592642 100644 --- a/crates/ai_onboarding/src/agent_panel_onboarding_card.rs +++ b/crates/ai_onboarding/src/agent_panel_onboarding_card.rs @@ -24,7 +24,7 @@ impl ParentElement for AgentPanelOnboardingCard { impl RenderOnce for AgentPanelOnboardingCard { fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement { div() - .m_4() + .m_2p5() .p(px(3.)) .elevation_2(cx) .rounded_lg() @@ -49,6 +49,7 @@ impl RenderOnce for AgentPanelOnboardingCard { .right_0() .w(px(400.)) .h(px(92.)) + .rounded_md() .child( Vector::new( VectorName::AiGrid, @@ -61,11 +62,12 @@ impl RenderOnce for AgentPanelOnboardingCard { .child( div() .absolute() - .top_0() - .right_0() + .top_0p5() + .right_0p5() .w(px(660.)) .h(px(401.)) .overflow_hidden() + .rounded_md() .bg(linear_gradient( 75., linear_color_stop( diff --git a/crates/ai_onboarding/src/agent_panel_onboarding_content.rs b/crates/ai_onboarding/src/agent_panel_onboarding_content.rs index f3f7d6c3d7..771482abf3 100644 --- a/crates/ai_onboarding/src/agent_panel_onboarding_content.rs +++ b/crates/ai_onboarding/src/agent_panel_onboarding_content.rs @@ -1,12 +1,11 @@ use std::sync::Arc; use client::{Client, UserStore}; -use gpui::{Action, ClickEvent, Entity, IntoElement, ParentElement}; +use gpui::{Entity, IntoElement, ParentElement}; use language_model::{LanguageModelRegistry, ZED_CLOUD_PROVIDER_ID}; -use ui::{Divider, List, prelude::*}; -use zed_actions::agent::{OpenConfiguration, ToggleModelSelector}; +use ui::prelude::*; -use crate::{AgentPanelOnboardingCard, BulletItem, ZedAiOnboarding}; +use crate::{AgentPanelOnboardingCard, ApiKeysWithoutProviders, ZedAiOnboarding}; pub struct AgentPanelOnboarding { user_store: Entity, @@ -53,93 +52,34 @@ impl AgentPanelOnboarding { .map(|provider| (provider.icon(), provider.name().0.clone())) .collect() } - - fn configure_providers(&mut self, _: &ClickEvent, window: &mut Window, cx: &mut Context) { - window.dispatch_action(OpenConfiguration.boxed_clone(), cx); - cx.notify(); - } - - fn render_api_keys_section(&mut self, cx: &mut Context) -> impl IntoElement { - let has_existing_providers = self.configured_providers.len() > 0; - let configure_provider_label = if has_existing_providers { - "Configure Other Provider" - } else { - "Configure Providers" - }; - - let content = if has_existing_providers { - List::new() - .child(BulletItem::new( - "Or start now using API keys from your environment for the following providers:" - )) - .child( - h_flex() - .px_5() - .gap_2() - .flex_wrap() - .children(self.configured_providers.iter().cloned().map(|(icon, name)| - h_flex() - .gap_1p5() - .child(Icon::new(icon).size(IconSize::Small).color(Color::Muted)) - .child(Label::new(name)) - )) - ) - .child(BulletItem::new( - "No need for any of the plans or even to sign in", - )) - } else { - List::new() - .child(BulletItem::new( - "You can also use AI in Zed by bringing your own API keys", - )) - .child(BulletItem::new( - "No need for any of the plans or even to sign in", - )) - }; - - v_flex() - .mt_2() - .gap_1() - .child( - h_flex() - .gap_2() - .child( - Label::new("API Keys") - .size(LabelSize::Small) - .color(Color::Muted) - .buffer_font(cx), - ) - .child(Divider::horizontal()), - ) - .child(content) - .when(has_existing_providers, |this| { - this.child( - Button::new("pick-model", "Choose Model") - .full_width() - .style(ButtonStyle::Outlined) - .on_click(|_event, window, cx| { - window.dispatch_action(ToggleModelSelector.boxed_clone(), cx) - }), - ) - }) - .child( - Button::new("configure-providers", configure_provider_label) - .full_width() - .style(ButtonStyle::Outlined) - .on_click(cx.listener(Self::configure_providers)), - ) - } } impl Render for AgentPanelOnboarding { fn render(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement { + let enrolled_in_trial = matches!( + self.user_store.read(cx).current_plan(), + Some(proto::Plan::ZedProTrial) + ); + AgentPanelOnboardingCard::new() - .child(ZedAiOnboarding::new( - self.client.clone(), - &self.user_store, - self.continue_with_zed_ai.clone(), - cx, - )) - .child(self.render_api_keys_section(cx)) + .child( + ZedAiOnboarding::new( + self.client.clone(), + &self.user_store, + self.continue_with_zed_ai.clone(), + cx, + ) + .with_dismiss({ + let callback = self.continue_with_zed_ai.clone(); + move |window, cx| callback(window, cx) + }), + ) + .map(|this| { + if enrolled_in_trial || self.configured_providers.len() >= 1 { + this + } else { + this.child(ApiKeysWithoutProviders::new()) + } + }) } } diff --git a/crates/ai_onboarding/src/ai_onboarding.rs b/crates/ai_onboarding/src/ai_onboarding.rs index 9c53078e5a..88c962c1ba 100644 --- a/crates/ai_onboarding/src/ai_onboarding.rs +++ b/crates/ai_onboarding/src/ai_onboarding.rs @@ -1,8 +1,10 @@ +mod agent_api_keys_onboarding; mod agent_panel_onboarding_card; mod agent_panel_onboarding_content; mod edit_prediction_onboarding_content; mod young_account_banner; +pub use agent_api_keys_onboarding::{ApiKeysWithProviders, ApiKeysWithoutProviders}; pub use agent_panel_onboarding_card::AgentPanelOnboardingCard; pub use agent_panel_onboarding_content::AgentPanelOnboarding; pub use edit_prediction_onboarding_content::EditPredictionOnboarding; @@ -12,7 +14,7 @@ use std::sync::Arc; use client::{Client, UserStore, zed_urls}; use gpui::{AnyElement, Entity, IntoElement, ParentElement, SharedString}; -use ui::{Divider, List, ListItem, RegisterComponent, TintColor, prelude::*}; +use ui::{Divider, List, ListItem, RegisterComponent, TintColor, Tooltip, prelude::*}; pub struct BulletItem { label: SharedString, @@ -69,6 +71,7 @@ pub struct ZedAiOnboarding { pub continue_with_zed_ai: Arc, pub sign_in: Arc, pub accept_terms_of_service: Arc, + pub dismiss_onboarding: Option>, } impl ZedAiOnboarding { @@ -80,6 +83,7 @@ impl ZedAiOnboarding { ) -> Self { let store = user_store.read(cx); let status = *client.status().borrow(); + Self { sign_in_status: status.into(), has_accepted_terms_of_service: store.current_user_has_accepted_terms().unwrap_or(false), @@ -102,14 +106,22 @@ impl ZedAiOnboarding { }) .detach(); }), + dismiss_onboarding: None, } } - fn render_free_plan_section(&self, cx: &mut App) -> impl IntoElement { + pub fn with_dismiss( + mut self, + dismiss_callback: impl Fn(&mut Window, &mut App) + 'static, + ) -> Self { + self.dismiss_onboarding = Some(Arc::new(dismiss_callback)); + self + } + + fn free_plan_definition(&self, cx: &mut App) -> impl IntoElement { v_flex() .mt_2() .gap_1() - .when(self.account_too_young, |this| this.opacity(0.4)) .child( h_flex() .gap_2() @@ -119,6 +131,12 @@ impl ZedAiOnboarding { .color(Color::Muted) .buffer_font(cx), ) + .child( + Label::new("(Current Plan)") + .size(LabelSize::Small) + .color(Color::Custom(cx.theme().colors().text_muted.opacity(0.6))) + .buffer_font(cx), + ) .child(Divider::horizontal()), ) .child( @@ -130,65 +148,89 @@ impl ZedAiOnboarding { "2000 accepted edit predictions using our open-source Zeta model", )), ) - .child( - Button::new("continue", "Continue Free") - .disabled(self.account_too_young) - .full_width() - .style(ButtonStyle::Outlined) - .on_click({ - let callback = self.continue_with_zed_ai.clone(); - move |_, window, cx| callback(window, cx) - }), - ) } - fn render_pro_plan_section(&self, cx: &mut App) -> impl IntoElement { - let (button_label, button_url) = if self.account_too_young { - ("Start with Pro", zed_urls::upgrade_to_zed_pro_url(cx)) - } else { - ("Start Pro Trial", zed_urls::start_trial_url(cx)) - }; - - v_flex() - .mt_2() - .gap_1() - .child( - h_flex() - .gap_2() - .child( - Label::new("Pro") - .size(LabelSize::Small) - .color(Color::Accent) - .buffer_font(cx), - ) - .child(Divider::horizontal()), - ) - .child( - List::new() - .child(BulletItem::new("500 prompts per month with Claude models")) - .child(BulletItem::new("Unlimited edit predictions")) - .when(!self.account_too_young, |this| { - this.child(BulletItem::new( - "Try it out for 14 days with no charge, no credit card required", - )) - }), - ) - .child( - Button::new("pro", button_label) - .full_width() - .style(ButtonStyle::Tinted(ui::TintColor::Accent)) - .on_click(move |_, _window, cx| cx.open_url(&button_url)), - ) - } - - fn render_accept_terms_of_service(&self) -> Div { - v_flex() - .w_full() - .gap_1() - .child(Headline::new("Before starting…")) - .child(Label::new( - "Make sure you have read and accepted Zed AI's terms of service.", + fn pro_trial_definition(&self) -> impl IntoElement { + List::new() + .child(BulletItem::new( + "150 prompts per month with the Claude models", )) + .child(BulletItem::new( + "Unlimited accepted edit predictions using our open-source Zeta model", + )) + } + + fn pro_plan_definition(&self, cx: &mut App) -> impl IntoElement { + v_flex().mt_2().gap_1().map(|this| { + if self.account_too_young { + this.child( + h_flex() + .gap_2() + .child( + Label::new("Pro") + .size(LabelSize::Small) + .color(Color::Accent) + .buffer_font(cx), + ) + .child(Divider::horizontal()), + ) + .child( + List::new() + .child(BulletItem::new("500 prompts per month with Claude models")) + .child(BulletItem::new( + "Unlimited accepted edit predictions using our open-source Zeta model", + )) + .child(BulletItem::new("USD $20 per month")), + ) + .child( + Button::new("pro", "Start with Pro") + .full_width() + .style(ButtonStyle::Tinted(ui::TintColor::Accent)) + .on_click(move |_, _window, cx| { + cx.open_url(&zed_urls::upgrade_to_zed_pro_url(cx)) + }), + ) + } else { + this.child( + h_flex() + .gap_2() + .child( + Label::new("Pro Trial") + .size(LabelSize::Small) + .color(Color::Accent) + .buffer_font(cx), + ) + .child(Divider::horizontal()), + ) + .child( + List::new() + .child(self.pro_trial_definition()) + .child(BulletItem::new( + "Try it out for 14 days with no charge and no credit card required", + )), + ) + .child( + Button::new("pro", "Start Pro Trial") + .full_width() + .style(ButtonStyle::Tinted(ui::TintColor::Accent)) + .on_click(move |_, _window, cx| { + cx.open_url(&zed_urls::start_trial_url(cx)) + }), + ) + } + }) + } + + fn render_accept_terms_of_service(&self) -> AnyElement { + v_flex() + .gap_1() + .w_full() + .child(Headline::new("Before starting…")) + .child( + Label::new("Make sure you have read and accepted Zed AI's terms of service.") + .color(Color::Muted) + .mb_2(), + ) .child( Button::new("terms_of_service", "View and Read the Terms of Service") .full_width() @@ -196,9 +238,7 @@ impl ZedAiOnboarding { .icon(IconName::ArrowUpRight) .icon_color(Color::Muted) .icon_size(IconSize::XSmall) - .on_click(move |_, _window, cx| { - cx.open_url("https://zed.dev/terms-of-service") - }), + .on_click(move |_, _window, cx| cx.open_url(&zed_urls::terms_of_service(cx))), ) .child( Button::new("accept_terms", "I've read it and accept it") @@ -209,23 +249,23 @@ impl ZedAiOnboarding { move |_, window, cx| (callback)(window, cx) }), ) + .into_any_element() } - fn render_sign_in_disclaimer(&self, _cx: &mut App) -> Div { - const SIGN_IN_DISCLAIMER: &str = - "To start using AI in Zed with our hosted models, sign in and subscribe to a plan."; + fn render_sign_in_disclaimer(&self, _cx: &mut App) -> AnyElement { let signing_in = matches!(self.sign_in_status, SignInStatus::SigningIn); v_flex() - .gap_2() + .gap_1() .child(Headline::new("Welcome to Zed AI")) - .child(div().w_full().child(Label::new(SIGN_IN_DISCLAIMER))) .child( - Button::new("sign_in", "Sign In with GitHub") - .icon(IconName::Github) - .icon_position(IconPosition::Start) - .icon_size(IconSize::Small) - .icon_color(Color::Muted) + Label::new("Sign in to start using AI in Zed with a free trial of the Pro plan, which includes:") + .color(Color::Muted) + .mb_2(), + ) + .child(self.pro_trial_definition()) + .child( + Button::new("sign_in", "Sign in to Start Trial") .disabled(signing_in) .full_width() .style(ButtonStyle::Tinted(ui::TintColor::Accent)) @@ -234,36 +274,55 @@ impl ZedAiOnboarding { move |_, window, cx| callback(window, cx) }), ) + .into_any_element() } - fn render_free_plan_onboarding(&self, cx: &mut App) -> Div { - const PLANS_DESCRIPTION: &str = "Choose how you want to start."; + fn render_free_plan_state(&self, cx: &mut App) -> AnyElement { let young_account_banner = YoungAccountBanner; v_flex() + .relative() + .gap_1() .child(Headline::new("Welcome to Zed AI")) .child( - Label::new(PLANS_DESCRIPTION) - .size(LabelSize::Small) + Label::new("Choose how you want to start.") .color(Color::Muted) - .mt_1() - .mb_3(), + .mb_2(), ) - .when(self.account_too_young, |this| { - this.child(young_account_banner) + .map(|this| { + if self.account_too_young { + this.child(young_account_banner) + } else { + this.child(self.free_plan_definition(cx)).when_some( + self.dismiss_onboarding.as_ref(), + |this, dismiss_callback| { + let callback = dismiss_callback.clone(); + + this.child( + h_flex().absolute().top_0().right_0().child( + IconButton::new("dismiss_onboarding", IconName::Close) + .icon_size(IconSize::Small) + .tooltip(Tooltip::text("Dismiss")) + .on_click(move |_, window, cx| callback(window, cx)), + ), + ) + }, + ) + } }) - .child(self.render_free_plan_section(cx)) - .child(self.render_pro_plan_section(cx)) + .child(self.pro_plan_definition(cx)) + .into_any_element() } - fn render_trial_onboarding(&self, _cx: &mut App) -> Div { + fn render_trial_state(&self, _cx: &mut App) -> AnyElement { v_flex() - .child(Headline::new("Welcome to the trial of Zed Pro")) + .relative() + .gap_1() + .child(Headline::new("Welcome to the Zed Pro free trial")) .child( Label::new("Here's what you get for the next 14 days:") - .size(LabelSize::Small) .color(Color::Muted) - .mt_1(), + .mb_2(), ) .child( List::new() @@ -272,25 +331,31 @@ impl ZedAiOnboarding { "Unlimited edit predictions with Zeta, our open-source model", )), ) - .child( - Button::new("trial", "Start Trial") - .full_width() - .style(ButtonStyle::Outlined) - .on_click({ - let callback = self.continue_with_zed_ai.clone(); - move |_, window, cx| callback(window, cx) - }), + .when_some( + self.dismiss_onboarding.as_ref(), + |this, dismiss_callback| { + let callback = dismiss_callback.clone(); + this.child( + h_flex().absolute().top_0().right_0().child( + IconButton::new("dismiss_onboarding", IconName::Close) + .icon_size(IconSize::Small) + .tooltip(Tooltip::text("Dismiss")) + .on_click(move |_, window, cx| callback(window, cx)), + ), + ) + }, ) + .into_any_element() } - fn render_pro_plan_onboarding(&self, _cx: &mut App) -> Div { + fn render_pro_plan_state(&self, _cx: &mut App) -> AnyElement { v_flex() + .gap_1() .child(Headline::new("Welcome to Zed Pro")) .child( Label::new("Here's what you get:") - .size(LabelSize::Small) .color(Color::Muted) - .mt_1(), + .mb_2(), ) .child( List::new() @@ -306,6 +371,7 @@ impl ZedAiOnboarding { move |_, window, cx| callback(window, cx) }), ) + .into_any_element() } } @@ -314,9 +380,9 @@ impl RenderOnce for ZedAiOnboarding { if matches!(self.sign_in_status, SignInStatus::SignedIn) { if self.has_accepted_terms_of_service { match self.plan { - None | Some(proto::Plan::Free) => self.render_free_plan_onboarding(cx), - Some(proto::Plan::ZedProTrial) => self.render_trial_onboarding(cx), - Some(proto::Plan::ZedPro) => self.render_pro_plan_onboarding(cx), + None | Some(proto::Plan::Free) => self.render_free_plan_state(cx), + Some(proto::Plan::ZedProTrial) => self.render_trial_state(cx), + Some(proto::Plan::ZedPro) => self.render_pro_plan_state(cx), } } else { self.render_accept_terms_of_service() @@ -339,18 +405,17 @@ impl Component for ZedAiOnboarding { plan: Option, account_too_young: bool, ) -> AnyElement { - div() - .w(px(800.)) - .child(ZedAiOnboarding { - sign_in_status, - has_accepted_terms_of_service, - plan, - account_too_young, - continue_with_zed_ai: Arc::new(|_, _| {}), - sign_in: Arc::new(|_, _| {}), - accept_terms_of_service: Arc::new(|_, _| {}), - }) - .into_any_element() + ZedAiOnboarding { + sign_in_status, + has_accepted_terms_of_service, + plan, + account_too_young, + continue_with_zed_ai: Arc::new(|_, _| {}), + sign_in: Arc::new(|_, _| {}), + accept_terms_of_service: Arc::new(|_, _| {}), + dismiss_onboarding: None, + } + .into_any_element() } Some( @@ -368,7 +433,7 @@ impl Component for ZedAiOnboarding { ), single_example( "Account too young", - onboarding(SignInStatus::SignedIn, true, None, true), + onboarding(SignInStatus::SignedIn, false, None, true), ), single_example( "Free Plan", diff --git a/crates/ai_onboarding/src/young_account_banner.rs b/crates/ai_onboarding/src/young_account_banner.rs index f6e1446fd0..1e1ed3a865 100644 --- a/crates/ai_onboarding/src/young_account_banner.rs +++ b/crates/ai_onboarding/src/young_account_banner.rs @@ -6,7 +6,7 @@ pub struct YoungAccountBanner; impl RenderOnce for YoungAccountBanner { fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement { - const YOUNG_ACCOUNT_DISCLAIMER: &str = "Given your GitHub account was created less than 30 days ago, we cannot put you in the Free plan or offer you a free trial of the Pro plan. We hope you'll understand, as this is unfortunately required to prevent abuse of our service. To continue, upgrade to Pro or use your own API keys for other providers."; + const YOUNG_ACCOUNT_DISCLAIMER: &str = "To prevent abuse of our service, we cannot offer plans to GitHub accounts created fewer than 30 days ago. To request an exception, reach out to billing@zed.dev."; let label = div() .w_full() diff --git a/crates/client/src/zed_urls.rs b/crates/client/src/zed_urls.rs index e36f5f65da..693c7bf836 100644 --- a/crates/client/src/zed_urls.rs +++ b/crates/client/src/zed_urls.rs @@ -30,3 +30,8 @@ pub fn start_trial_url(cx: &App) -> String { pub fn upgrade_to_zed_pro_url(cx: &App) -> String { format!("{server_url}/account/upgrade", server_url = server_url(cx)) } + +/// Returns the URL to Zed's terms of service. +pub fn terms_of_service(cx: &App) -> String { + format!("{server_url}/terms-of-service", server_url = server_url(cx)) +} diff --git a/crates/language_model/src/registry.rs b/crates/language_model/src/registry.rs index 840fda38de..6e8e8e9108 100644 --- a/crates/language_model/src/registry.rs +++ b/crates/language_model/src/registry.rs @@ -206,8 +206,8 @@ impl LanguageModelRegistry { None } - /// Check that we have at least one provider that is authenticated. - fn has_authenticated_provider(&self, cx: &App) -> bool { + /// Returns `true` if at least one provider that is authenticated. + pub fn has_authenticated_provider(&self, cx: &App) -> bool { self.providers.values().any(|p| p.is_authenticated(cx)) } diff --git a/crates/language_models/src/provider/cloud.rs b/crates/language_models/src/provider/cloud.rs index 736107570b..fac8810714 100644 --- a/crates/language_models/src/provider/cloud.rs +++ b/crates/language_models/src/provider/cloud.rs @@ -1140,19 +1140,19 @@ impl RenderOnce for ZedAiConfiguration { let is_pro = self.plan == Some(proto::Plan::ZedPro); let subscription_text = match (self.plan, self.subscription_period) { (Some(proto::Plan::ZedPro), Some(_)) => { - "You have access to Zed's hosted LLMs through your Pro subscription." + "You have access to Zed's hosted models through your Pro subscription." } (Some(proto::Plan::ZedProTrial), Some(_)) => { - "You have access to Zed's hosted LLMs through your Pro trial." + "You have access to Zed's hosted models through your Pro trial." } (Some(proto::Plan::Free), Some(_)) => { - "You have basic access to Zed's hosted LLMs through the Free plan." + "You have basic access to Zed's hosted models through the Free plan." } _ => { if self.eligible_for_trial { - "Subscribe for access to Zed's hosted LLMs. Start with a 14 day free trial." + "Subscribe for access to Zed's hosted models. Start with a 14 day free trial." } else { - "Subscribe for access to Zed's hosted LLMs." + "Subscribe for access to Zed's hosted models." } } }; @@ -1166,7 +1166,7 @@ impl RenderOnce for ZedAiConfiguration { Button::new("start_trial", "Start 14-day Free Pro Trial") .style(ui::ButtonStyle::Tinted(ui::TintColor::Accent)) .full_width() - .on_click(|_, _, cx| cx.open_url(&zed_urls::account_url(cx))) + .on_click(|_, _, cx| cx.open_url(&zed_urls::start_trial_url(cx))) .into_any_element() } else { Button::new("upgrade", "Upgrade to Pro") From 2b671a46f23e2f5d1393e58973f7305e6b78494d Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Tue, 22 Jul 2025 02:39:22 -0300 Subject: [PATCH 0113/1052] ai onboarding: Don't show API keys section if user is already in Pro (#34867) Release Notes: - N/A --- crates/agent_ui/src/message_editor.rs | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/crates/agent_ui/src/message_editor.rs b/crates/agent_ui/src/message_editor.rs index 69eae982f8..7803753292 100644 --- a/crates/agent_ui/src/message_editor.rs +++ b/crates/agent_ui/src/message_editor.rs @@ -1657,11 +1657,16 @@ impl Render for MessageEditor { let line_height = TextSize::Small.rems(cx).to_pixels(window.rem_size()) * 1.5; - let enrolled_in_trial = matches!( + let in_pro_trial = matches!( self.user_store.read(cx).current_plan(), Some(proto::Plan::ZedProTrial) ); + let pro_user = matches!( + self.user_store.read(cx).current_plan(), + Some(proto::Plan::ZedPro) + ); + let configured_providers: Vec<(IconName, SharedString)> = LanguageModelRegistry::read_global(cx) .providers() @@ -1676,9 +1681,10 @@ impl Render for MessageEditor { v_flex() .size_full() .bg(cx.theme().colors().panel_background) - .when(has_existing_providers && !enrolled_in_trial, |this| { - this.child(cx.new(ApiKeysWithProviders::new)) - }) + .when( + has_existing_providers && !in_pro_trial && !pro_user, + |this| this.child(cx.new(ApiKeysWithProviders::new)), + ) .when(changed_buffers.len() > 0, |parent| { parent.child(self.render_edits_bar(&changed_buffers, window, cx)) }) From 87014cec71335c6ae20fbe3fe6299f95542103c4 Mon Sep 17 00:00:00 2001 From: Bret Comnes <166301+bcomnes@users.noreply.github.com> Date: Tue, 22 Jul 2025 02:50:26 -0700 Subject: [PATCH 0114/1052] theme: Add `panel.overlay_background` and `panel.overlay_hover` (#34655) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit In https://github.com/zed-industries/zed/pull/33994 sticky scroll was added to project_panel. I love this feature! This introduces a new element layering not seen before. On themes that use transparency, the overlapping elements can make it difficult to read project panel entries. This PR introduces a new selector: ~~panel.sticky_entry.background~~ `panel.overlay_background` This selector lets you set the background of entries when they become sticky. Closes https://github.com/zed-industries/zed/issues/34654 Before: Screenshot 2025-07-17 at 10 19 11 AM After: Screenshot 2025-07-17 at 11 46 57 AM Screenshot 2025-07-17 at 11 39 57 AM Screenshot 2025-07-17 at 11 39 29 AM Release Notes: - Add `panel.sticky_entry.background` theme selector for modifying project panel entries when they become sticky when scrolling and overlap with entries below them. --------- Co-authored-by: Smit Barmase --- crates/project_panel/src/project_panel.rs | 16 ++++++++--- crates/theme/src/default_colors.rs | 4 +++ crates/theme/src/fallback_themes.rs | 9 ++++-- crates/theme/src/schema.rs | 34 +++++++++++++++++------ crates/theme/src/styles/colors.rs | 10 +++++++ 5 files changed, 58 insertions(+), 15 deletions(-) diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs index b6fdcd6fa5..44f4e8985a 100644 --- a/crates/project_panel/src/project_panel.rs +++ b/crates/project_panel/src/project_panel.rs @@ -384,12 +384,20 @@ struct ItemColors { focused: Hsla, } -fn get_item_color(cx: &App) -> ItemColors { +fn get_item_color(is_sticky: bool, cx: &App) -> ItemColors { let colors = cx.theme().colors(); ItemColors { - default: colors.panel_background, - hover: colors.element_hover, + default: if is_sticky { + colors.panel_overlay_background + } else { + colors.panel_background + }, + hover: if is_sticky { + colors.panel_overlay_hover + } else { + colors.element_hover + }, marked: colors.element_selected, focused: colors.panel_focused_border, drag_over: colors.drop_target_background, @@ -3903,7 +3911,7 @@ impl ProjectPanel { let filename_text_color = details.filename_text_color; let diagnostic_severity = details.diagnostic_severity; - let item_colors = get_item_color(cx); + let item_colors = get_item_color(is_sticky, cx); let canonical_path = details .canonical_path diff --git a/crates/theme/src/default_colors.rs b/crates/theme/src/default_colors.rs index 3424e0fe04..1c3f48b548 100644 --- a/crates/theme/src/default_colors.rs +++ b/crates/theme/src/default_colors.rs @@ -83,6 +83,8 @@ impl ThemeColors { panel_indent_guide: neutral().light_alpha().step_5(), panel_indent_guide_hover: neutral().light_alpha().step_6(), panel_indent_guide_active: neutral().light_alpha().step_6(), + panel_overlay_background: neutral().light().step_2(), + panel_overlay_hover: neutral().light_alpha().step_4(), pane_focused_border: blue().light().step_5(), pane_group_border: neutral().light().step_6(), scrollbar_thumb_background: neutral().light_alpha().step_3(), @@ -206,6 +208,8 @@ impl ThemeColors { panel_indent_guide: neutral().dark_alpha().step_4(), panel_indent_guide_hover: neutral().dark_alpha().step_6(), panel_indent_guide_active: neutral().dark_alpha().step_6(), + panel_overlay_background: neutral().dark().step_2(), + panel_overlay_hover: neutral().dark_alpha().step_4(), pane_focused_border: blue().dark().step_5(), pane_group_border: neutral().dark().step_6(), scrollbar_thumb_background: neutral().dark_alpha().step_3(), diff --git a/crates/theme/src/fallback_themes.rs b/crates/theme/src/fallback_themes.rs index 5e9967d460..4d77dd5d81 100644 --- a/crates/theme/src/fallback_themes.rs +++ b/crates/theme/src/fallback_themes.rs @@ -59,6 +59,7 @@ pub(crate) fn zed_default_dark() -> Theme { let bg = hsla(215. / 360., 12. / 100., 15. / 100., 1.); let editor = hsla(220. / 360., 12. / 100., 18. / 100., 1.); let elevated_surface = hsla(225. / 360., 12. / 100., 17. / 100., 1.); + let hover = hsla(225.0 / 360., 11.8 / 100., 26.7 / 100., 1.0); let blue = hsla(207.8 / 360., 81. / 100., 66. / 100., 1.0); let gray = hsla(218.8 / 360., 10. / 100., 40. / 100., 1.0); @@ -108,14 +109,14 @@ pub(crate) fn zed_default_dark() -> Theme { surface_background: bg, background: bg, element_background: hsla(223.0 / 360., 13. / 100., 21. / 100., 1.0), - element_hover: hsla(225.0 / 360., 11.8 / 100., 26.7 / 100., 1.0), + element_hover: hover, element_active: hsla(220.0 / 360., 11.8 / 100., 20.0 / 100., 1.0), element_selected: hsla(224.0 / 360., 11.3 / 100., 26.1 / 100., 1.0), element_disabled: SystemColors::default().transparent, element_selection_background: player.local().selection.alpha(0.25), drop_target_background: hsla(220.0 / 360., 8.3 / 100., 21.4 / 100., 1.0), ghost_element_background: SystemColors::default().transparent, - ghost_element_hover: hsla(225.0 / 360., 11.8 / 100., 26.7 / 100., 1.0), + ghost_element_hover: hover, ghost_element_active: hsla(220.0 / 360., 11.8 / 100., 20.0 / 100., 1.0), ghost_element_selected: hsla(224.0 / 360., 11.3 / 100., 26.1 / 100., 1.0), ghost_element_disabled: SystemColors::default().transparent, @@ -202,10 +203,12 @@ pub(crate) fn zed_default_dark() -> Theme { panel_indent_guide: hsla(228. / 360., 8. / 100., 25. / 100., 1.), panel_indent_guide_hover: hsla(225. / 360., 13. / 100., 12. / 100., 1.), panel_indent_guide_active: hsla(225. / 360., 13. / 100., 12. / 100., 1.), + panel_overlay_background: bg, + panel_overlay_hover: hover, pane_focused_border: blue, pane_group_border: hsla(225. / 360., 13. / 100., 12. / 100., 1.), scrollbar_thumb_background: gpui::transparent_black(), - scrollbar_thumb_hover_background: hsla(225.0 / 360., 11.8 / 100., 26.7 / 100., 1.0), + scrollbar_thumb_hover_background: hover, scrollbar_thumb_active_background: hsla( 225.0 / 360., 11.8 / 100., diff --git a/crates/theme/src/schema.rs b/crates/theme/src/schema.rs index bed25d0c05..bfa2adcedf 100644 --- a/crates/theme/src/schema.rs +++ b/crates/theme/src/schema.rs @@ -351,6 +351,12 @@ pub struct ThemeColorsContent { #[serde(rename = "panel.indent_guide_active")] pub panel_indent_guide_active: Option, + #[serde(rename = "panel.overlay_background")] + pub panel_overlay_background: Option, + + #[serde(rename = "panel.overlay_hover")] + pub panel_overlay_hover: Option, + #[serde(rename = "pane.focused_border")] pub pane_focused_border: Option, @@ -674,6 +680,14 @@ impl ThemeColorsContent { .scrollbar_thumb_border .as_ref() .and_then(|color| try_parse_color(color).ok()); + let element_hover = self + .element_hover + .as_ref() + .and_then(|color| try_parse_color(color).ok()); + let panel_background = self + .panel_background + .as_ref() + .and_then(|color| try_parse_color(color).ok()); ThemeColorsRefinement { border, border_variant: self @@ -712,10 +726,7 @@ impl ThemeColorsContent { .element_background .as_ref() .and_then(|color| try_parse_color(color).ok()), - element_hover: self - .element_hover - .as_ref() - .and_then(|color| try_parse_color(color).ok()), + element_hover, element_active: self .element_active .as_ref() @@ -832,10 +843,7 @@ impl ThemeColorsContent { .search_match_background .as_ref() .and_then(|color| try_parse_color(color).ok()), - panel_background: self - .panel_background - .as_ref() - .and_then(|color| try_parse_color(color).ok()), + panel_background, panel_focused_border: self .panel_focused_border .as_ref() @@ -852,6 +860,16 @@ impl ThemeColorsContent { .panel_indent_guide_active .as_ref() .and_then(|color| try_parse_color(color).ok()), + panel_overlay_background: self + .panel_overlay_background + .as_ref() + .and_then(|color| try_parse_color(color).ok()) + .or(panel_background), + panel_overlay_hover: self + .panel_overlay_hover + .as_ref() + .and_then(|color| try_parse_color(color).ok()) + .or(element_hover), pane_focused_border: self .pane_focused_border .as_ref() diff --git a/crates/theme/src/styles/colors.rs b/crates/theme/src/styles/colors.rs index 7c5270e361..aab11803f4 100644 --- a/crates/theme/src/styles/colors.rs +++ b/crates/theme/src/styles/colors.rs @@ -131,6 +131,12 @@ pub struct ThemeColors { pub panel_indent_guide: Hsla, pub panel_indent_guide_hover: Hsla, pub panel_indent_guide_active: Hsla, + + /// The color of the overlay surface on top of panel. + pub panel_overlay_background: Hsla, + /// The color of the overlay surface on top of panel when hovered over. + pub panel_overlay_hover: Hsla, + pub pane_focused_border: Hsla, pub pane_group_border: Hsla, /// The color of the scrollbar thumb. @@ -326,6 +332,8 @@ pub enum ThemeColorField { PanelIndentGuide, PanelIndentGuideHover, PanelIndentGuideActive, + PanelOverlayBackground, + PanelOverlayHover, PaneFocusedBorder, PaneGroupBorder, ScrollbarThumbBackground, @@ -438,6 +446,8 @@ impl ThemeColors { ThemeColorField::PanelIndentGuide => self.panel_indent_guide, ThemeColorField::PanelIndentGuideHover => self.panel_indent_guide_hover, ThemeColorField::PanelIndentGuideActive => self.panel_indent_guide_active, + ThemeColorField::PanelOverlayBackground => self.panel_overlay_background, + ThemeColorField::PanelOverlayHover => self.panel_overlay_hover, ThemeColorField::PaneFocusedBorder => self.pane_focused_border, ThemeColorField::PaneGroupBorder => self.pane_group_border, ThemeColorField::ScrollbarThumbBackground => self.scrollbar_thumb_background, From 3a651c546b13c7b9a2a25a551975f5313b7e3793 Mon Sep 17 00:00:00 2001 From: Ben Brandt Date: Tue, 22 Jul 2025 12:12:07 +0200 Subject: [PATCH 0115/1052] context_server: Change command string field to PathBuf (#34873) Release Notes: - N/A --- .../configure_context_server_modal.rs | 8 +++++--- crates/context_server/src/context_server.rs | 4 ++-- crates/extension/src/types.rs | 4 ++-- .../src/wasm_host/wit/since_v0_6_0.rs | 4 ++-- crates/project/src/context_server_store.rs | 18 +++++++++--------- .../src/context_server_store/extension.rs | 5 +---- crates/project/src/project_settings.rs | 2 +- 7 files changed, 22 insertions(+), 23 deletions(-) diff --git a/crates/agent_ui/src/agent_configuration/configure_context_server_modal.rs b/crates/agent_ui/src/agent_configuration/configure_context_server_modal.rs index 9e5f6e09c8..06d035d836 100644 --- a/crates/agent_ui/src/agent_configuration/configure_context_server_modal.rs +++ b/crates/agent_ui/src/agent_configuration/configure_context_server_modal.rs @@ -1,4 +1,5 @@ use std::{ + path::PathBuf, sync::{Arc, Mutex}, time::Duration, }; @@ -188,7 +189,7 @@ fn context_server_input(existing: Option<(ContextServerId, ContextServerCommand) } None => ( "some-mcp-server".to_string(), - "".to_string(), + PathBuf::new(), "[]".to_string(), "{}".to_string(), ), @@ -199,13 +200,14 @@ fn context_server_input(existing: Option<(ContextServerId, ContextServerCommand) /// The name of your MCP server "{name}": {{ /// The command which runs the MCP server - "command": "{command}", + "command": "{}", /// The arguments to pass to the MCP server "args": {args}, /// The environment variables to set "env": {env} }} -}}"# +}}"#, + command.display() ) } diff --git a/crates/context_server/src/context_server.rs b/crates/context_server/src/context_server.rs index 807b17f1ca..f2517feb27 100644 --- a/crates/context_server/src/context_server.rs +++ b/crates/context_server/src/context_server.rs @@ -6,9 +6,9 @@ pub mod test; pub mod transport; pub mod types; -use std::fmt::Display; use std::path::Path; use std::sync::Arc; +use std::{fmt::Display, path::PathBuf}; use anyhow::Result; use client::Client; @@ -31,7 +31,7 @@ impl Display for ContextServerId { #[derive(Deserialize, Serialize, Clone, PartialEq, Eq, JsonSchema)] pub struct ContextServerCommand { #[serde(rename = "command")] - pub path: String, + pub path: PathBuf, pub args: Vec, pub env: Option>, } diff --git a/crates/extension/src/types.rs b/crates/extension/src/types.rs index cb24e5077b..ed9eb2ec2f 100644 --- a/crates/extension/src/types.rs +++ b/crates/extension/src/types.rs @@ -3,7 +3,7 @@ mod dap; mod lsp; mod slash_command; -use std::ops::Range; +use std::{ops::Range, path::PathBuf}; use util::redact::should_redact; @@ -18,7 +18,7 @@ pub type EnvVars = Vec<(String, String)>; /// A command. pub struct Command { /// The command to execute. - pub command: String, + pub command: PathBuf, /// The arguments to pass to the command. pub args: Vec, /// The environment variables to set for the command. diff --git a/crates/extension_host/src/wasm_host/wit/since_v0_6_0.rs b/crates/extension_host/src/wasm_host/wit/since_v0_6_0.rs index ced2ea9c67..d25328ee7f 100644 --- a/crates/extension_host/src/wasm_host/wit/since_v0_6_0.rs +++ b/crates/extension_host/src/wasm_host/wit/since_v0_6_0.rs @@ -75,7 +75,7 @@ impl From for std::ops::Range { impl From for extension::Command { fn from(value: Command) -> Self { Self { - command: value.command, + command: value.command.into(), args: value.args, env: value.env, } @@ -958,7 +958,7 @@ impl ExtensionImports for WasmState { command, } => Ok(serde_json::to_string(&settings::ContextServerSettings { command: Some(settings::CommandSettings { - path: Some(command.path), + path: command.path.to_str().map(|path| path.to_string()), arguments: Some(command.args), env: command.env.map(|env| env.into_iter().collect()), }), diff --git a/crates/project/src/context_server_store.rs b/crates/project/src/context_server_store.rs index fd31e638d4..ceec0c0a52 100644 --- a/crates/project/src/context_server_store.rs +++ b/crates/project/src/context_server_store.rs @@ -610,7 +610,7 @@ mod tests { use context_server::test::create_fake_transport; use gpui::{AppContext, TestAppContext, UpdateGlobal as _}; use serde_json::json; - use std::{cell::RefCell, rc::Rc}; + use std::{cell::RefCell, path::PathBuf, rc::Rc}; use util::path; #[gpui::test] @@ -931,7 +931,7 @@ mod tests { ContextServerSettings::Custom { enabled: true, command: ContextServerCommand { - path: "somebinary".to_string(), + path: "somebinary".into(), args: vec!["arg".to_string()], env: None, }, @@ -971,7 +971,7 @@ mod tests { ContextServerSettings::Custom { enabled: true, command: ContextServerCommand { - path: "somebinary".to_string(), + path: "somebinary".into(), args: vec!["anotherArg".to_string()], env: None, }, @@ -1053,7 +1053,7 @@ mod tests { ContextServerSettings::Custom { enabled: true, command: ContextServerCommand { - path: "somebinary".to_string(), + path: "somebinary".into(), args: vec!["arg".to_string()], env: None, }, @@ -1104,7 +1104,7 @@ mod tests { ContextServerSettings::Custom { enabled: false, command: ContextServerCommand { - path: "somebinary".to_string(), + path: "somebinary".into(), args: vec!["arg".to_string()], env: None, }, @@ -1132,7 +1132,7 @@ mod tests { ContextServerSettings::Custom { enabled: true, command: ContextServerCommand { - path: "somebinary".to_string(), + path: "somebinary".into(), args: vec!["arg".to_string()], env: None, }, @@ -1184,7 +1184,7 @@ mod tests { ContextServerSettings::Custom { enabled: true, command: ContextServerCommand { - path: "somebinary".to_string(), + path: "somebinary".into(), args: vec!["arg".to_string()], env: None, }, @@ -1256,11 +1256,11 @@ mod tests { } struct FakeContextServerDescriptor { - path: String, + path: PathBuf, } impl FakeContextServerDescriptor { - fn new(path: impl Into) -> Self { + fn new(path: impl Into) -> Self { Self { path: path.into() } } } diff --git a/crates/project/src/context_server_store/extension.rs b/crates/project/src/context_server_store/extension.rs index 1eaecd987d..1eb0fe7da1 100644 --- a/crates/project/src/context_server_store/extension.rs +++ b/crates/project/src/context_server_store/extension.rs @@ -61,10 +61,7 @@ impl registry::ContextServerDescriptor for ContextServerDescriptor { let mut command = extension .context_server_command(id.clone(), extension_project.clone()) .await?; - command.command = extension - .path_from_extension(command.command.as_ref()) - .to_string_lossy() - .to_string(); + command.command = extension.path_from_extension(&command.command); log::info!("loaded command for context server {id}: {command:?}"); diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs index a85d90fe33..20be7fef85 100644 --- a/crates/project/src/project_settings.rs +++ b/crates/project/src/project_settings.rs @@ -581,7 +581,7 @@ impl Settings for ProjectSettings { #[derive(Deserialize)] struct VsCodeContextServerCommand { - command: String, + command: PathBuf, args: Option>, env: Option>, // note: we don't support envFile and type From c7158f0bd7ec3324fe299b4cf3e6b4e34a492436 Mon Sep 17 00:00:00 2001 From: Oleksiy Syvokon Date: Tue, 22 Jul 2025 14:23:50 +0300 Subject: [PATCH 0116/1052] Improve distinguishing user from agent edits (#34716) We no longer rely on the `author` field to tell if a change was made by the user or the agent. The `author` can be set to `User` in many situations that are not really user-made edits, such as saving a file, accepting a change, auto-formatting, and more. I started tracking and fixing some of these cases, but found that inspecting changes in `diff_base` is a more reliable method. Also, we no longer show empty diffs. For example, if the user adds a line and then removes the same line, the final diff is empty, even though the buffer is marked as user-changed. Now we won't show such edit. There are still some issues to address: - When a user edits within an unaccepted agent-written block, this change becomes a part of the agent's edit. Rejecting this block will lose user edits. It won't be displayed in project notifications, either. - Accepting an agent block counts as a user-made edit. - Agent start to call `project_notifications` tool after seeing enough auto-calls. Release Notes: - N/A --- crates/agent/src/thread.rs | 20 ++++--- crates/assistant_tool/src/action_log.rs | 56 +++++++++++--------- crates/assistant_tools/src/edit_file_tool.rs | 3 ++ 3 files changed, 42 insertions(+), 37 deletions(-) diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs index e50763535a..f8a7827615 100644 --- a/crates/agent/src/thread.rs +++ b/crates/agent/src/thread.rs @@ -47,7 +47,7 @@ use std::{ time::{Duration, Instant}, }; use thiserror::Error; -use util::{ResultExt as _, debug_panic, post_inc}; +use util::{ResultExt as _, post_inc}; use uuid::Uuid; use zed_llm_client::{CompletionIntent, CompletionRequestStatus, UsageLimit}; @@ -1582,20 +1582,18 @@ impl Thread { model: Arc, cx: &mut App, ) -> Option { - let action_log = self.action_log.read(cx); + // Represent notification as a simulated `project_notifications` tool call + let tool_name = Arc::from("project_notifications"); + let tool = self.tools.read(cx).tool(&tool_name, cx)?; - if !action_log.has_unnotified_user_edits() { + if !self.profile.is_tool_enabled(tool.source(), tool.name(), cx) { return None; } - // Represent notification as a simulated `project_notifications` tool call - let tool_name = Arc::from("project_notifications"); - let Some(tool) = self.tools.read(cx).tool(&tool_name, cx) else { - debug_panic!("`project_notifications` tool not found"); - return None; - }; - - if !self.profile.is_tool_enabled(tool.source(), tool.name(), cx) { + if self + .action_log + .update(cx, |log, cx| log.unnotified_user_edits(cx).is_none()) + { return None; } diff --git a/crates/assistant_tool/src/action_log.rs b/crates/assistant_tool/src/action_log.rs index ecbbcc785e..672c048872 100644 --- a/crates/assistant_tool/src/action_log.rs +++ b/crates/assistant_tool/src/action_log.rs @@ -51,23 +51,13 @@ impl ActionLog { Some(self.tracked_buffers.get(buffer)?.snapshot.clone()) } - pub fn has_unnotified_user_edits(&self) -> bool { - self.tracked_buffers - .values() - .any(|tracked| tracked.has_unnotified_user_edits) - } - /// Return a unified diff patch with user edits made since last read or notification pub fn unnotified_user_edits(&self, cx: &Context) -> Option { - if !self.has_unnotified_user_edits() { - return None; - } - - let unified_diff = self + let diffs = self .tracked_buffers .values() .filter_map(|tracked| { - if !tracked.has_unnotified_user_edits { + if !tracked.may_have_unnotified_user_edits { return None; } @@ -95,9 +85,13 @@ impl ActionLog { Some(result) }) - .collect::>() - .join("\n\n"); + .collect::>(); + if diffs.is_empty() { + return None; + } + + let unified_diff = diffs.join("\n\n"); Some(unified_diff) } @@ -106,7 +100,7 @@ impl ActionLog { pub fn flush_unnotified_user_edits(&mut self, cx: &Context) -> Option { let patch = self.unnotified_user_edits(cx); self.tracked_buffers.values_mut().for_each(|tracked| { - tracked.has_unnotified_user_edits = false; + tracked.may_have_unnotified_user_edits = false; tracked.last_seen_base = tracked.diff_base.clone(); }); patch @@ -185,7 +179,7 @@ impl ActionLog { version: buffer.read(cx).version(), diff, diff_update: diff_update_tx, - has_unnotified_user_edits: false, + may_have_unnotified_user_edits: false, _open_lsp_handle: open_lsp_handle, _maintain_diff: cx.spawn({ let buffer = buffer.clone(); @@ -337,27 +331,34 @@ impl ActionLog { let new_snapshot = buffer_snapshot.clone(); let unreviewed_edits = tracked_buffer.unreviewed_edits.clone(); let edits = diff_snapshots(&old_snapshot, &new_snapshot); - if let ChangeAuthor::User = author - && !edits.is_empty() - { - tracked_buffer.has_unnotified_user_edits = true; - } + let mut has_user_changes = false; async move { if let ChangeAuthor::User = author { - apply_non_conflicting_edits( + has_user_changes = apply_non_conflicting_edits( &unreviewed_edits, edits, &mut base_text, new_snapshot.as_rope(), ); } - (Arc::new(base_text.to_string()), base_text) + + (Arc::new(base_text.to_string()), base_text, has_user_changes) } }); anyhow::Ok(rebase) })??; - let (new_base_text, new_diff_base) = rebase.await; + let (new_base_text, new_diff_base, has_user_changes) = rebase.await; + + this.update(cx, |this, _| { + let tracked_buffer = this + .tracked_buffers + .get_mut(buffer) + .context("buffer not tracked") + .unwrap(); + tracked_buffer.may_have_unnotified_user_edits |= has_user_changes; + })?; + Self::update_diff( this, buffer, @@ -829,11 +830,12 @@ fn apply_non_conflicting_edits( edits: Vec>, old_text: &mut Rope, new_text: &Rope, -) { +) -> bool { let mut old_edits = patch.edits().iter().cloned().peekable(); let mut new_edits = edits.into_iter().peekable(); let mut applied_delta = 0i32; let mut rebased_delta = 0i32; + let mut has_made_changes = false; while let Some(mut new_edit) = new_edits.next() { let mut conflict = false; @@ -883,8 +885,10 @@ fn apply_non_conflicting_edits( &new_text.chunks_in_range(new_bytes).collect::(), ); applied_delta += new_edit.new_len() as i32 - new_edit.old_len() as i32; + has_made_changes = true; } } + has_made_changes } fn diff_snapshots( @@ -958,7 +962,7 @@ struct TrackedBuffer { diff: Entity, snapshot: text::BufferSnapshot, diff_update: mpsc::UnboundedSender<(ChangeAuthor, text::BufferSnapshot)>, - has_unnotified_user_edits: bool, + may_have_unnotified_user_edits: bool, _open_lsp_handle: OpenLspBufferHandle, _maintain_diff: Task<()>, _subscription: Subscription, diff --git a/crates/assistant_tools/src/edit_file_tool.rs b/crates/assistant_tools/src/edit_file_tool.rs index 0423f56145..6413677bd9 100644 --- a/crates/assistant_tools/src/edit_file_tool.rs +++ b/crates/assistant_tools/src/edit_file_tool.rs @@ -278,6 +278,9 @@ impl Tool for EditFileTool { .unwrap_or(false); if format_on_save_enabled { + action_log.update(cx, |log, cx| { + log.buffer_edited(buffer.clone(), cx); + })?; let format_task = project.update(cx, |project, cx| { project.format( HashSet::from_iter([buffer.clone()]), From a3850b3d38928e87f01b67d43755b5a5cc410605 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Tue, 22 Jul 2025 09:42:34 -0300 Subject: [PATCH 0117/1052] agent: Add `use_modifier_to_send` section in the settings view (#34866) This PR also converts all of these switch-based settings to use the new `SwitchField` component, introduced in https://github.com/zed-industries/zed/pull/34713. Release Notes: - agent: Added the ability to change the `use_modifier_to_send` setting from the agent panel settings UI. --- crates/agent_ui/src/agent_configuration.rs | 162 ++++++++------------- crates/ui/src/components/toggle.rs | 11 +- 2 files changed, 69 insertions(+), 104 deletions(-) diff --git a/crates/agent_ui/src/agent_configuration.rs b/crates/agent_ui/src/agent_configuration.rs index 0697f5dee7..b5ad6ba37c 100644 --- a/crates/agent_ui/src/agent_configuration.rs +++ b/crates/agent_ui/src/agent_configuration.rs @@ -28,7 +28,7 @@ use proto::Plan; use settings::{Settings, update_settings_file}; use ui::{ Chip, ContextMenu, Disclosure, Divider, DividerColor, ElevationIndex, Indicator, PopoverMenu, - Scrollbar, ScrollbarState, Switch, SwitchColor, Tooltip, prelude::*, + Scrollbar, ScrollbarState, Switch, SwitchColor, SwitchField, Tooltip, prelude::*, }; use util::ResultExt as _; use workspace::Workspace; @@ -330,119 +330,74 @@ impl AgentConfiguration { fn render_command_permission(&mut self, cx: &mut Context) -> impl IntoElement { let always_allow_tool_actions = AgentSettings::get_global(cx).always_allow_tool_actions; + let fs = self.fs.clone(); - h_flex() - .gap_4() - .justify_between() - .flex_wrap() - .child( - v_flex() - .gap_0p5() - .max_w_5_6() - .child(Label::new("Allow running editing tools without asking for confirmation")) - .child( - Label::new( - "The agent can perform potentially destructive actions without asking for your confirmation.", - ) - .color(Color::Muted), - ), - ) - .child( - Switch::new( - "always-allow-tool-actions-switch", - always_allow_tool_actions.into(), - ) - .color(SwitchColor::Accent) - .on_click({ - let fs = self.fs.clone(); - move |state, _window, cx| { - let allow = state == &ToggleState::Selected; - update_settings_file::( - fs.clone(), - cx, - move |settings, _| { - settings.set_always_allow_tool_actions(allow); - }, - ); - } - }), - ) + SwitchField::new( + "single-file-review", + "Enable single-file agent reviews", + "Agent edits are also displayed in single-file editors for review.", + always_allow_tool_actions, + move |state, _window, cx| { + let allow = state == &ToggleState::Selected; + update_settings_file::(fs.clone(), cx, move |settings, _| { + settings.set_always_allow_tool_actions(allow); + }); + }, + ) } fn render_single_file_review(&mut self, cx: &mut Context) -> impl IntoElement { let single_file_review = AgentSettings::get_global(cx).single_file_review; + let fs = self.fs.clone(); - h_flex() - .gap_4() - .justify_between() - .flex_wrap() - .child( - v_flex() - .gap_0p5() - .max_w_5_6() - .child(Label::new("Enable single-file agent reviews")) - .child( - Label::new( - "Agent edits are also displayed in single-file editors for review.", - ) - .color(Color::Muted), - ), - ) - .child( - Switch::new("single-file-review-switch", single_file_review.into()) - .color(SwitchColor::Accent) - .on_click({ - let fs = self.fs.clone(); - move |state, _window, cx| { - let allow = state == &ToggleState::Selected; - update_settings_file::( - fs.clone(), - cx, - move |settings, _| { - settings.set_single_file_review(allow); - }, - ); - } - }), - ) + SwitchField::new( + "single-file-review", + "Enable single-file agent reviews", + "Agent edits are also displayed in single-file editors for review.", + single_file_review, + move |state, _window, cx| { + let allow = state == &ToggleState::Selected; + update_settings_file::(fs.clone(), cx, move |settings, _| { + settings.set_single_file_review(allow); + }); + }, + ) } fn render_sound_notification(&mut self, cx: &mut Context) -> impl IntoElement { let play_sound_when_agent_done = AgentSettings::get_global(cx).play_sound_when_agent_done; + let fs = self.fs.clone(); - h_flex() - .gap_4() - .justify_between() - .flex_wrap() - .child( - v_flex() - .gap_0p5() - .max_w_5_6() - .child(Label::new("Play sound when finished generating")) - .child( - Label::new( - "Hear a notification sound when the agent is done generating changes or needs your input.", - ) - .color(Color::Muted), - ), - ) - .child( - Switch::new("play-sound-notification-switch", play_sound_when_agent_done.into()) - .color(SwitchColor::Accent) - .on_click({ - let fs = self.fs.clone(); - move |state, _window, cx| { - let allow = state == &ToggleState::Selected; - update_settings_file::( - fs.clone(), - cx, - move |settings, _| { - settings.set_play_sound_when_agent_done(allow); - }, - ); - } - }), - ) + SwitchField::new( + "sound-notification", + "Play sound when finished generating", + "Hear a notification sound when the agent is done generating changes or needs your input.", + play_sound_when_agent_done, + move |state, _window, cx| { + let allow = state == &ToggleState::Selected; + update_settings_file::(fs.clone(), cx, move |settings, _| { + settings.set_play_sound_when_agent_done(allow); + }); + }, + ) + } + + fn render_modifier_to_send(&mut self, cx: &mut Context) -> impl IntoElement { + let use_modifier_to_send = AgentSettings::get_global(cx).use_modifier_to_send; + let fs = self.fs.clone(); + + SwitchField::new( + "modifier-send", + "Use modifier to submit a message", + "Make a modifier (cmd-enter on macOS, ctrl-enter on Linux) required to send messages.", + use_modifier_to_send, + move |state, _window, cx| { + let allow = state == &ToggleState::Selected; + update_settings_file::(fs.clone(), cx, move |settings, _| { + settings.set_use_modifier_to_send(allow); + }); + }, + ) } fn render_general_settings_section(&mut self, cx: &mut Context) -> impl IntoElement { @@ -456,6 +411,7 @@ impl AgentConfiguration { .child(self.render_command_permission(cx)) .child(self.render_single_file_review(cx)) .child(self.render_sound_notification(cx)) + .child(self.render_modifier_to_send(cx)) } fn render_zed_plan_info(&self, plan: Option, cx: &mut Context) -> impl IntoElement { diff --git a/crates/ui/src/components/toggle.rs b/crates/ui/src/components/toggle.rs index 759b225434..cf2a56b1c9 100644 --- a/crates/ui/src/components/toggle.rs +++ b/crates/ui/src/components/toggle.rs @@ -588,7 +588,7 @@ impl SwitchField { toggle_state: toggle_state.into(), on_click: Arc::new(on_click), disabled: false, - color: SwitchColor::default(), + color: SwitchColor::Accent, } } @@ -634,6 +634,15 @@ impl RenderOnce for SwitchField { } }), ) + .when(!self.disabled, |this| { + this.on_click({ + let on_click = self.on_click.clone(); + let toggle_state = self.toggle_state; + move |_click, window, cx| { + (on_click)(&toggle_state.inverse(), window, cx); + } + }) + }) } } From 31aab89ab0343b9b6388224f4e8ec2fa3f91fe2e Mon Sep 17 00:00:00 2001 From: Umesh Yadav <23421535+imumesh18@users.noreply.github.com> Date: Tue, 22 Jul 2025 18:24:06 +0530 Subject: [PATCH 0118/1052] ai_onboarding: Fix API key onboarding callout not showing properly (#34880) The current onboarding callout for ApiKeysWithProviders is broken. | Before | After | |--------|--------| | CleanShot 2025-07-22 at 16 21 53@2x | CleanShot 2025-07-22 at 16 22 38@2x | cc @danilo-leal Release Notes: - N/A --------- Co-authored-by: Danilo Leal --- .../src/agent_api_keys_onboarding.rs | 29 +++++++++++++------ 1 file changed, 20 insertions(+), 9 deletions(-) diff --git a/crates/ai_onboarding/src/agent_api_keys_onboarding.rs b/crates/ai_onboarding/src/agent_api_keys_onboarding.rs index 4f9e20cf77..883317e566 100644 --- a/crates/ai_onboarding/src/agent_api_keys_onboarding.rs +++ b/crates/ai_onboarding/src/agent_api_keys_onboarding.rs @@ -38,10 +38,6 @@ impl ApiKeysWithProviders { .map(|provider| (provider.icon(), provider.name().0.clone())) .collect() } - - pub fn has_providers(&self) -> bool { - !self.configured_providers.is_empty() - } } impl Render for ApiKeysWithProviders { @@ -53,11 +49,10 @@ impl Render for ApiKeysWithProviders { .map(|(icon, name)| { h_flex() .gap_1p5() - .child(Icon::new(icon).size(IconSize::Small).color(Color::Muted)) + .child(Icon::new(icon).size(IconSize::XSmall).color(Color::Muted)) .child(Label::new(name)) }); - - h_flex() + div() .mx_2p5() .p_1() .pb_0() @@ -85,8 +80,24 @@ impl Render for ApiKeysWithProviders { .border_x_1() .border_color(cx.theme().colors().border) .bg(cx.theme().colors().panel_background) - .child(Icon::new(IconName::Info).size(IconSize::XSmall).color(Color::Muted)) - .child(Label::new("Or start now using API keys from your environment for the following providers:").color(Color::Muted)) + .child( + h_flex() + .min_w_0() + .gap_2() + .child( + Icon::new(IconName::Info) + .size(IconSize::XSmall) + .color(Color::Muted) + ) + .child( + div() + .w_full() + .child( + Label::new("Or start now using API keys from your environment for the following providers:") + .color(Color::Muted) + ) + ) + ) .children(configured_providers_list) ) } From 30177b87d6c1fb76f809f470f1ea42249f7ab662 Mon Sep 17 00:00:00 2001 From: Ben Kunkle Date: Tue, 22 Jul 2025 08:51:30 -0500 Subject: [PATCH 0119/1052] Fix detection of pending bindings when binding in parent context matches (#34856) Broke in #34664 Release Notes: - N/A *or* Added/Fixed/Improved ... Co-authored-by: Conrad --- crates/gpui/src/keymap.rs | 314 ++++++++++++++++++++++++++++++-------- 1 file changed, 249 insertions(+), 65 deletions(-) diff --git a/crates/gpui/src/keymap.rs b/crates/gpui/src/keymap.rs index 174dbc80f0..69700e64dc 100644 --- a/crates/gpui/src/keymap.rs +++ b/crates/gpui/src/keymap.rs @@ -5,7 +5,7 @@ pub use binding::*; pub use context::*; use crate::{Action, Keystroke, is_no_action}; -use collections::HashMap; +use collections::{HashMap, HashSet}; use smallvec::SmallVec; use std::any::TypeId; @@ -167,76 +167,49 @@ impl Keymap { input: &[Keystroke], context_stack: &[KeyContext], ) -> (SmallVec<[(BindingIndex, KeyBinding); 1]>, bool) { - let mut possibilities = self - .bindings() - .enumerate() - .rev() - .filter_map(|(ix, binding)| { - let depth = self.binding_enabled(binding, &context_stack)?; - let pending = binding.match_keystrokes(input)?; - Some((depth, BindingIndex(ix), binding, pending)) - }) - .collect::>(); - possibilities.sort_by(|(depth_a, ix_a, _, _), (depth_b, ix_b, _, _)| { + let mut bindings: SmallVec<[(usize, BindingIndex, &KeyBinding); 1]> = SmallVec::new(); + let mut pending_bindings: SmallVec<[(BindingIndex, &KeyBinding); 1]> = SmallVec::new(); + + for (ix, binding) in self.bindings().enumerate().rev() { + let Some(depth) = self.binding_enabled(binding, &context_stack) else { + continue; + }; + let Some(pending) = binding.match_keystrokes(input) else { + continue; + }; + + if !pending { + bindings.push((depth, BindingIndex(ix), binding)) + } else { + pending_bindings.push((BindingIndex(ix), binding)) + } + } + + bindings.sort_by(|(depth_a, ix_a, _), (depth_b, ix_b, _)| { depth_b.cmp(depth_a).then(ix_b.cmp(ix_a)) }); - let mut bindings: SmallVec<[(BindingIndex, KeyBinding, usize); 1]> = SmallVec::new(); - - // (pending, is_no_action, depth, keystrokes) - let mut pending_info_opt: Option<(bool, bool, usize, &[Keystroke])> = None; - - 'outer: for (depth, binding_index, binding, pending) in possibilities { - let is_no_action = is_no_action(&*binding.action); - // We only want to consider a binding pending if it has an action - // This, however, means that if we have both a NoAction binding and a binding - // with an action at the same depth, we should still set is_pending to true. - if let Some(pending_info) = pending_info_opt.as_mut() { - let (already_pending, pending_is_no_action, pending_depth, pending_keystrokes) = - *pending_info; - - // We only want to change the pending status if it's not already pending AND if - // the existing pending status was set by a NoAction binding. This avoids a NoAction - // binding erroneously setting the pending status to true when a binding with an action - // already set it to false - // - // We also want to change the pending status if the keystrokes don't match, - // meaning it's different keystrokes than the NoAction that set pending to false - if pending - && !already_pending - && pending_is_no_action - && (pending_depth == depth || pending_keystrokes != binding.keystrokes()) - { - pending_info.0 = !is_no_action; - } - } else { - pending_info_opt = Some(( - pending && !is_no_action, - is_no_action, - depth, - binding.keystrokes(), - )); - } - - if !pending { - bindings.push((binding_index, binding.clone(), depth)); - continue 'outer; - } - } - // sort by descending depth - bindings.sort_by(|a, b| a.2.cmp(&b.2).reverse()); - let bindings = bindings + let bindings: SmallVec<[_; 1]> = bindings .into_iter() - .map_while(|(binding_index, binding, _)| { - if is_no_action(&*binding.action) { - None - } else { - Some((binding_index, binding)) - } - }) + .take_while(|(_, _, binding)| !is_no_action(&*binding.action)) + .map(|(_, ix, binding)| (ix, binding.clone())) .collect(); - (bindings, pending_info_opt.unwrap_or_default().0) + let mut pending = HashSet::default(); + for (ix, binding) in pending_bindings.into_iter().rev() { + if let Some((binding_ix, _)) = bindings.first() + && *binding_ix > ix + { + continue; + } + if is_no_action(&*binding.action) { + pending.remove(&&binding.keystrokes); + continue; + } + pending.insert(&binding.keystrokes); + } + + (bindings, !pending.is_empty()) } /// Check if the given binding is enabled, given a certain key context. @@ -302,6 +275,30 @@ mod tests { ); } + #[test] + fn test_depth_precedence() { + let bindings = [ + KeyBinding::new("ctrl-a", ActionBeta {}, Some("pane")), + KeyBinding::new("ctrl-a", ActionGamma {}, Some("editor")), + ]; + + let mut keymap = Keymap::default(); + keymap.add_bindings(bindings.clone()); + + let (result, pending) = keymap.bindings_for_input( + &[Keystroke::parse("ctrl-a").unwrap()], + &[ + KeyContext::parse("pane").unwrap(), + KeyContext::parse("editor").unwrap(), + ], + ); + + assert!(!pending); + assert_eq!(result.len(), 2); + assert!(result[0].action.partial_eq(&ActionGamma {})); + assert!(result[1].action.partial_eq(&ActionBeta {})); + } + #[test] fn test_keymap_disabled() { let bindings = [ @@ -453,6 +450,193 @@ mod tests { assert_eq!(space_editor.1, true); } + #[test] + fn test_override_multikey() { + let bindings = [ + KeyBinding::new("ctrl-w left", ActionAlpha {}, Some("editor")), + KeyBinding::new("ctrl-w", NoAction {}, Some("editor")), + ]; + + let mut keymap = Keymap::default(); + keymap.add_bindings(bindings.clone()); + + // Ensure `space` results in pending input on the workspace, but not editor + let (result, pending) = keymap.bindings_for_input( + &[Keystroke::parse("ctrl-w").unwrap()], + &[KeyContext::parse("editor").unwrap()], + ); + assert!(result.is_empty()); + assert_eq!(pending, true); + + let bindings = [ + KeyBinding::new("ctrl-w left", ActionAlpha {}, Some("editor")), + KeyBinding::new("ctrl-w", ActionBeta {}, Some("editor")), + ]; + + let mut keymap = Keymap::default(); + keymap.add_bindings(bindings.clone()); + + // Ensure `space` results in pending input on the workspace, but not editor + let (result, pending) = keymap.bindings_for_input( + &[Keystroke::parse("ctrl-w").unwrap()], + &[KeyContext::parse("editor").unwrap()], + ); + assert_eq!(result.len(), 1); + assert_eq!(pending, false); + } + + #[test] + fn test_simple_disable() { + let bindings = [ + KeyBinding::new("ctrl-x", ActionAlpha {}, Some("editor")), + KeyBinding::new("ctrl-x", NoAction {}, Some("editor")), + ]; + + let mut keymap = Keymap::default(); + keymap.add_bindings(bindings.clone()); + + // Ensure `space` results in pending input on the workspace, but not editor + let (result, pending) = keymap.bindings_for_input( + &[Keystroke::parse("ctrl-x").unwrap()], + &[KeyContext::parse("editor").unwrap()], + ); + assert!(result.is_empty()); + assert_eq!(pending, false); + } + + #[test] + fn test_fail_to_disable() { + // disabled at the wrong level + let bindings = [ + KeyBinding::new("ctrl-x", ActionAlpha {}, Some("editor")), + KeyBinding::new("ctrl-x", NoAction {}, Some("workspace")), + ]; + + let mut keymap = Keymap::default(); + keymap.add_bindings(bindings.clone()); + + // Ensure `space` results in pending input on the workspace, but not editor + let (result, pending) = keymap.bindings_for_input( + &[Keystroke::parse("ctrl-x").unwrap()], + &[ + KeyContext::parse("workspace").unwrap(), + KeyContext::parse("editor").unwrap(), + ], + ); + assert_eq!(result.len(), 1); + assert_eq!(pending, false); + } + + #[test] + fn test_disable_deeper() { + let bindings = [ + KeyBinding::new("ctrl-x", ActionAlpha {}, Some("workspace")), + KeyBinding::new("ctrl-x", NoAction {}, Some("editor")), + ]; + + let mut keymap = Keymap::default(); + keymap.add_bindings(bindings.clone()); + + // Ensure `space` results in pending input on the workspace, but not editor + let (result, pending) = keymap.bindings_for_input( + &[Keystroke::parse("ctrl-x").unwrap()], + &[ + KeyContext::parse("workspace").unwrap(), + KeyContext::parse("editor").unwrap(), + ], + ); + assert_eq!(result.len(), 0); + assert_eq!(pending, false); + } + + #[test] + fn test_pending_match_enabled() { + let bindings = [ + KeyBinding::new("ctrl-x", ActionBeta, Some("vim_mode == normal")), + KeyBinding::new("ctrl-x 0", ActionAlpha, Some("Workspace")), + ]; + let mut keymap = Keymap::default(); + keymap.add_bindings(bindings.clone()); + + let matched = keymap.bindings_for_input( + &[Keystroke::parse("ctrl-x")].map(Result::unwrap), + &[ + KeyContext::parse("Workspace"), + KeyContext::parse("Pane"), + KeyContext::parse("Editor vim_mode=normal"), + ] + .map(Result::unwrap), + ); + assert_eq!(matched.0.len(), 1); + assert!(matched.0[0].action.partial_eq(&ActionBeta)); + assert!(matched.1); + } + + #[test] + fn test_pending_match_enabled_extended() { + let bindings = [ + KeyBinding::new("ctrl-x", ActionBeta, Some("vim_mode == normal")), + KeyBinding::new("ctrl-x 0", NoAction, Some("Workspace")), + ]; + let mut keymap = Keymap::default(); + keymap.add_bindings(bindings.clone()); + + let matched = keymap.bindings_for_input( + &[Keystroke::parse("ctrl-x")].map(Result::unwrap), + &[ + KeyContext::parse("Workspace"), + KeyContext::parse("Pane"), + KeyContext::parse("Editor vim_mode=normal"), + ] + .map(Result::unwrap), + ); + assert_eq!(matched.0.len(), 1); + assert!(matched.0[0].action.partial_eq(&ActionBeta)); + assert!(!matched.1); + let bindings = [ + KeyBinding::new("ctrl-x", ActionBeta, Some("Workspace")), + KeyBinding::new("ctrl-x 0", NoAction, Some("vim_mode == normal")), + ]; + let mut keymap = Keymap::default(); + keymap.add_bindings(bindings.clone()); + + let matched = keymap.bindings_for_input( + &[Keystroke::parse("ctrl-x")].map(Result::unwrap), + &[ + KeyContext::parse("Workspace"), + KeyContext::parse("Pane"), + KeyContext::parse("Editor vim_mode=normal"), + ] + .map(Result::unwrap), + ); + assert_eq!(matched.0.len(), 1); + assert!(matched.0[0].action.partial_eq(&ActionBeta)); + assert!(!matched.1); + } + + #[test] + fn test_overriding_prefix() { + let bindings = [ + KeyBinding::new("ctrl-x 0", ActionAlpha, Some("Workspace")), + KeyBinding::new("ctrl-x", ActionBeta, Some("vim_mode == normal")), + ]; + let mut keymap = Keymap::default(); + keymap.add_bindings(bindings.clone()); + + let matched = keymap.bindings_for_input( + &[Keystroke::parse("ctrl-x")].map(Result::unwrap), + &[ + KeyContext::parse("Workspace"), + KeyContext::parse("Pane"), + KeyContext::parse("Editor vim_mode=normal"), + ] + .map(Result::unwrap), + ); + assert_eq!(matched.0.len(), 1); + assert!(matched.0[0].action.partial_eq(&ActionBeta)); + assert!(!matched.1); + } + #[test] fn test_bindings_for_action() { let bindings = [ From 2eeab5b0bf9921814c9d8a1824a3d09d3f5397f4 Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Tue, 22 Jul 2025 10:52:04 -0400 Subject: [PATCH 0120/1052] textmate: Correct context for 'Editor && mode == full' keybinds (#34895) Closes https://github.com/zed-industries/zed/issues/34891 Release Notes: - Fixed textmate keymap misbehaving in certain contexts --- assets/keymaps/macos/textmate.json | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/assets/keymaps/macos/textmate.json b/assets/keymaps/macos/textmate.json index dccb675f6c..0bd8873b17 100644 --- a/assets/keymaps/macos/textmate.json +++ b/assets/keymaps/macos/textmate.json @@ -6,7 +6,7 @@ } }, { - "context": "Editor", + "context": "Editor && mode == full", "bindings": { "cmd-l": "go_to_line::Toggle", "ctrl-shift-d": "editor::DuplicateLineDown", @@ -15,7 +15,12 @@ "cmd-enter": "editor::NewlineBelow", "cmd-alt-enter": "editor::NewlineAbove", "cmd-shift-l": "editor::SelectLine", - "cmd-shift-t": "outline::Toggle", + "cmd-shift-t": "outline::Toggle" + } + }, + { + "context": "Editor", + "bindings": { "alt-backspace": "editor::DeleteToPreviousWordStart", "alt-shift-backspace": "editor::DeleteToNextWordEnd", "alt-delete": "editor::DeleteToNextWordEnd", @@ -39,10 +44,6 @@ "ctrl-_": "editor::ConvertToSnakeCase" } }, - { - "context": "Editor && mode == full", - "bindings": {} - }, { "context": "BufferSearchBar", "bindings": { From 1a76a6b0bfc5145cf51355ff7777b0413063a868 Mon Sep 17 00:00:00 2001 From: Ben Kunkle Date: Tue, 22 Jul 2025 09:59:51 -0500 Subject: [PATCH 0121/1052] gpui: Simplify `bindings_for_action` API (#34857) Closes #ISSUE Simplifies the API to no longer have a variant that returns indices. The downside is that a few places that used to call `bindings_for_action_with_indices` now compare `Box` instead of indices, however the result is the removal of wrapper code and index handling that is largely unnecessary Release Notes: - N/A *or* Added/Fixed/Improved ... Co-authored-by: Conrad --- crates/gpui/src/key_dispatch.rs | 39 +++++++++--------------- crates/gpui/src/keymap.rs | 53 +++++++++++---------------------- 2 files changed, 31 insertions(+), 61 deletions(-) diff --git a/crates/gpui/src/key_dispatch.rs b/crates/gpui/src/key_dispatch.rs index a290a132c3..cc6ebb9b08 100644 --- a/crates/gpui/src/key_dispatch.rs +++ b/crates/gpui/src/key_dispatch.rs @@ -50,8 +50,8 @@ /// KeyBinding::new("cmd-k left", pane::SplitLeft, Some("Pane")) /// use crate::{ - Action, ActionRegistry, App, BindingIndex, DispatchPhase, EntityId, FocusId, KeyBinding, - KeyContext, Keymap, Keystroke, ModifiersChangedEvent, Window, + Action, ActionRegistry, App, DispatchPhase, EntityId, FocusId, KeyBinding, KeyContext, Keymap, + Keystroke, ModifiersChangedEvent, Window, }; use collections::FxHashMap; use smallvec::SmallVec; @@ -406,16 +406,11 @@ impl DispatchTree { // methods, but this can't be done very cleanly since keymap must be borrowed. let keymap = self.keymap.borrow(); keymap - .bindings_for_action_with_indices(action) - .filter(|(binding_index, binding)| { - Self::binding_matches_predicate_and_not_shadowed( - &keymap, - *binding_index, - &binding.keystrokes, - context_stack, - ) + .bindings_for_action(action) + .filter(|binding| { + Self::binding_matches_predicate_and_not_shadowed(&keymap, &binding, context_stack) }) - .map(|(_, binding)| binding.clone()) + .cloned() .collect() } @@ -428,28 +423,22 @@ impl DispatchTree { ) -> Option { let keymap = self.keymap.borrow(); keymap - .bindings_for_action_with_indices(action) + .bindings_for_action(action) .rev() - .find_map(|(binding_index, binding)| { - let found = Self::binding_matches_predicate_and_not_shadowed( - &keymap, - binding_index, - &binding.keystrokes, - context_stack, - ); - if found { Some(binding.clone()) } else { None } + .find(|binding| { + Self::binding_matches_predicate_and_not_shadowed(&keymap, &binding, context_stack) }) + .cloned() } fn binding_matches_predicate_and_not_shadowed( keymap: &Keymap, - binding_index: BindingIndex, - keystrokes: &[Keystroke], + binding: &KeyBinding, context_stack: &[KeyContext], ) -> bool { - let (bindings, _) = keymap.bindings_for_input_with_indices(&keystrokes, context_stack); - if let Some((highest_precedence_index, _)) = bindings.iter().next() { - binding_index == *highest_precedence_index + let (bindings, _) = keymap.bindings_for_input(&binding.keystrokes, context_stack); + if let Some(found) = bindings.iter().next() { + found.action.partial_eq(binding.action.as_ref()) } else { false } diff --git a/crates/gpui/src/keymap.rs b/crates/gpui/src/keymap.rs index 69700e64dc..83d7479a04 100644 --- a/crates/gpui/src/keymap.rs +++ b/crates/gpui/src/keymap.rs @@ -77,15 +77,6 @@ impl Keymap { &'a self, action: &'a dyn Action, ) -> impl 'a + DoubleEndedIterator { - self.bindings_for_action_with_indices(action) - .map(|(_, binding)| binding) - } - - /// Like `bindings_for_action_with_indices`, but also returns the binding indices. - pub fn bindings_for_action_with_indices<'a>( - &'a self, - action: &'a dyn Action, - ) -> impl 'a + DoubleEndedIterator { let action_id = action.type_id(); let binding_indices = self .binding_indices_by_action_id @@ -118,7 +109,7 @@ impl Keymap { } } - Some((BindingIndex(*ix), binding)) + Some(binding) }) } @@ -153,22 +144,8 @@ impl Keymap { input: &[Keystroke], context_stack: &[KeyContext], ) -> (SmallVec<[KeyBinding; 1]>, bool) { - let (bindings, pending) = self.bindings_for_input_with_indices(input, context_stack); - let bindings = bindings - .into_iter() - .map(|(_, binding)| binding) - .collect::>(); - (bindings, pending) - } - - /// Like `bindings_for_input`, but also returns the binding indices. - pub fn bindings_for_input_with_indices( - &self, - input: &[Keystroke], - context_stack: &[KeyContext], - ) -> (SmallVec<[(BindingIndex, KeyBinding); 1]>, bool) { - let mut bindings: SmallVec<[(usize, BindingIndex, &KeyBinding); 1]> = SmallVec::new(); - let mut pending_bindings: SmallVec<[(BindingIndex, &KeyBinding); 1]> = SmallVec::new(); + let mut matched_bindings = SmallVec::<[(usize, BindingIndex, &KeyBinding); 1]>::new(); + let mut pending_bindings = SmallVec::<[(BindingIndex, &KeyBinding); 1]>::new(); for (ix, binding) in self.bindings().enumerate().rev() { let Some(depth) = self.binding_enabled(binding, &context_stack) else { @@ -179,26 +156,30 @@ impl Keymap { }; if !pending { - bindings.push((depth, BindingIndex(ix), binding)) + matched_bindings.push((depth, BindingIndex(ix), binding)); } else { - pending_bindings.push((BindingIndex(ix), binding)) + pending_bindings.push((BindingIndex(ix), binding)); } } - bindings.sort_by(|(depth_a, ix_a, _), (depth_b, ix_b, _)| { + matched_bindings.sort_by(|(depth_a, ix_a, _), (depth_b, ix_b, _)| { depth_b.cmp(depth_a).then(ix_b.cmp(ix_a)) }); - let bindings: SmallVec<[_; 1]> = bindings - .into_iter() - .take_while(|(_, _, binding)| !is_no_action(&*binding.action)) - .map(|(_, ix, binding)| (ix, binding.clone())) - .collect(); + let mut bindings: SmallVec<[_; 1]> = SmallVec::new(); + let mut first_binding_index = None; + for (_, ix, binding) in matched_bindings { + if is_no_action(&*binding.action) { + break; + } + bindings.push(binding.clone()); + first_binding_index.get_or_insert(ix); + } let mut pending = HashSet::default(); for (ix, binding) in pending_bindings.into_iter().rev() { - if let Some((binding_ix, _)) = bindings.first() - && *binding_ix > ix + if let Some(binding_ix) = first_binding_index + && binding_ix > ix { continue; } From 230061a6cb79c93faf3e3a9ff880207dc6668e37 Mon Sep 17 00:00:00 2001 From: Bennet Bo Fenner Date: Tue, 22 Jul 2025 17:20:07 +0200 Subject: [PATCH 0122/1052] Support multiple OpenAI compatible providers (#34212) TODO - [x] OpenAI Compatible API Icon - [x] Docs - [x] Link to docs in OpenAI provider section about configuring OpenAI API compatible providers Closes #33992 Related to #30010 Release Notes: - agent: Add support for adding multiple OpenAI API compatible providers --------- Co-authored-by: MrSubidubi Co-authored-by: Danilo Leal --- Cargo.lock | 4 +- assets/icons/ai_open_ai_compat.svg | 4 + assets/settings/default.json | 1 + crates/agent/src/thread.rs | 2 +- crates/agent_ui/Cargo.toml | 2 + crates/agent_ui/src/active_thread.rs | 4 +- crates/agent_ui/src/agent_configuration.rs | 55 +- .../add_llm_provider_modal.rs | 639 ++++++++++++++++++ .../src/assistant_context_tests.rs | 2 +- .../src/project_notifications_tool.rs | 2 +- crates/icons/src/icons.rs | 1 + crates/language_model/src/fake_provider.rs | 55 +- crates/language_model/src/language_model.rs | 12 + crates/language_model/src/registry.rs | 9 +- crates/language_models/Cargo.toml | 2 +- crates/language_models/src/language_models.rs | 72 +- crates/language_models/src/provider.rs | 1 + .../language_models/src/provider/open_ai.rs | 192 ++---- .../src/provider/open_ai_compatible.rs | 522 ++++++++++++++ crates/language_models/src/settings.rs | 27 +- crates/ui/src/components/modal.rs | 16 +- crates/ui_input/src/ui_input.rs | 4 + docs/src/ai/configuration.md | 13 +- 23 files changed, 1450 insertions(+), 191 deletions(-) create mode 100644 assets/icons/ai_open_ai_compat.svg create mode 100644 crates/agent_ui/src/agent_configuration/add_llm_provider_modal.rs create mode 100644 crates/language_models/src/provider/open_ai_compatible.rs diff --git a/Cargo.lock b/Cargo.lock index ad6c40bcf2..c7297e6d59 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -231,6 +231,7 @@ dependencies = [ "jsonschema", "language", "language_model", + "language_models", "languages", "log", "lsp", @@ -269,6 +270,7 @@ dependencies = [ "time_format", "tree-sitter-md", "ui", + "ui_input", "unindent", "urlencoding", "util", @@ -9097,11 +9099,11 @@ dependencies = [ "client", "collections", "component", + "convert_case 0.8.0", "copilot", "credentials_provider", "deepseek", "editor", - "fs", "futures 0.3.31", "google_ai", "gpui", diff --git a/assets/icons/ai_open_ai_compat.svg b/assets/icons/ai_open_ai_compat.svg new file mode 100644 index 0000000000..f6557caac3 --- /dev/null +++ b/assets/icons/ai_open_ai_compat.svg @@ -0,0 +1,4 @@ + + + + diff --git a/assets/settings/default.json b/assets/settings/default.json index 358871650b..309afaccf5 100644 --- a/assets/settings/default.json +++ b/assets/settings/default.json @@ -1712,6 +1712,7 @@ "openai": { "api_url": "https://api.openai.com/v1" }, + "openai_compatible": {}, "open_router": { "api_url": "https://openrouter.ai/api/v1" }, diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs index f8a7827615..1b3b022ab2 100644 --- a/crates/agent/src/thread.rs +++ b/crates/agent/src/thread.rs @@ -5490,7 +5490,7 @@ fn main() {{ let thread = thread_store.update(cx, |store, cx| store.create_thread(cx)); let context_store = cx.new(|_cx| ContextStore::new(project.downgrade(), None)); - let provider = Arc::new(FakeLanguageModelProvider); + let provider = Arc::new(FakeLanguageModelProvider::default()); let model = provider.test_model(); let model: Arc = Arc::new(model); diff --git a/crates/agent_ui/Cargo.toml b/crates/agent_ui/Cargo.toml index e55ae86fb7..33042c0ebd 100644 --- a/crates/agent_ui/Cargo.toml +++ b/crates/agent_ui/Cargo.toml @@ -53,6 +53,7 @@ itertools.workspace = true jsonschema.workspace = true language.workspace = true language_model.workspace = true +language_models.workspace = true log.workspace = true lsp.workspace = true markdown.workspace = true @@ -87,6 +88,7 @@ theme.workspace = true time.workspace = true time_format.workspace = true ui.workspace = true +ui_input.workspace = true urlencoding.workspace = true util.workspace = true uuid.workspace = true diff --git a/crates/agent_ui/src/active_thread.rs b/crates/agent_ui/src/active_thread.rs index bfed81f5b7..e27c318221 100644 --- a/crates/agent_ui/src/active_thread.rs +++ b/crates/agent_ui/src/active_thread.rs @@ -3895,7 +3895,7 @@ mod tests { LanguageModelRegistry::global(cx).update(cx, |registry, cx| { registry.set_default_model( Some(ConfiguredModel { - provider: Arc::new(FakeLanguageModelProvider), + provider: Arc::new(FakeLanguageModelProvider::default()), model, }), cx, @@ -3979,7 +3979,7 @@ mod tests { LanguageModelRegistry::global(cx).update(cx, |registry, cx| { registry.set_default_model( Some(ConfiguredModel { - provider: Arc::new(FakeLanguageModelProvider), + provider: Arc::new(FakeLanguageModelProvider::default()), model: model.clone(), }), cx, diff --git a/crates/agent_ui/src/agent_configuration.rs b/crates/agent_ui/src/agent_configuration.rs index b5ad6ba37c..334c5ee6dc 100644 --- a/crates/agent_ui/src/agent_configuration.rs +++ b/crates/agent_ui/src/agent_configuration.rs @@ -1,3 +1,4 @@ +mod add_llm_provider_modal; mod configure_context_server_modal; mod manage_profiles_modal; mod tool_picker; @@ -37,7 +38,10 @@ use zed_actions::ExtensionCategoryFilter; pub(crate) use configure_context_server_modal::ConfigureContextServerModal; pub(crate) use manage_profiles_modal::ManageProfilesModal; -use crate::AddContextServer; +use crate::{ + AddContextServer, + agent_configuration::add_llm_provider_modal::{AddLlmProviderModal, LlmCompatibleProvider}, +}; pub struct AgentConfiguration { fs: Arc, @@ -304,16 +308,55 @@ impl AgentConfiguration { v_flex() .child( - v_flex() + h_flex() .p(DynamicSpacing::Base16.rems(cx)) .pr(DynamicSpacing::Base20.rems(cx)) .pb_0() .mb_2p5() - .gap_0p5() - .child(Headline::new("LLM Providers")) + .items_start() + .justify_between() .child( - Label::new("Add at least one provider to use AI-powered features.") - .color(Color::Muted), + v_flex() + .gap_0p5() + .child(Headline::new("LLM Providers")) + .child( + Label::new("Add at least one provider to use AI-powered features.") + .color(Color::Muted), + ), + ) + .child( + PopoverMenu::new("add-provider-popover") + .trigger( + Button::new("add-provider", "Add Provider") + .icon_position(IconPosition::Start) + .icon(IconName::Plus) + .icon_size(IconSize::Small) + .icon_color(Color::Muted) + .label_size(LabelSize::Small), + ) + .anchor(gpui::Corner::TopRight) + .menu({ + let workspace = self.workspace.clone(); + move |window, cx| { + Some(ContextMenu::build(window, cx, |menu, _window, _cx| { + menu.header("Compatible APIs").entry("OpenAI", None, { + let workspace = workspace.clone(); + move |window, cx| { + workspace + .update(cx, |workspace, cx| { + AddLlmProviderModal::toggle( + LlmCompatibleProvider::OpenAi, + workspace, + window, + cx, + ); + }) + .log_err(); + } + }) + })) + } + }), ), ) .child( diff --git a/crates/agent_ui/src/agent_configuration/add_llm_provider_modal.rs b/crates/agent_ui/src/agent_configuration/add_llm_provider_modal.rs new file mode 100644 index 0000000000..94b32d156b --- /dev/null +++ b/crates/agent_ui/src/agent_configuration/add_llm_provider_modal.rs @@ -0,0 +1,639 @@ +use std::sync::Arc; + +use anyhow::Result; +use collections::HashSet; +use fs::Fs; +use gpui::{DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Render, Task}; +use language_model::LanguageModelRegistry; +use language_models::{ + AllLanguageModelSettings, OpenAiCompatibleSettingsContent, + provider::open_ai_compatible::AvailableModel, +}; +use settings::update_settings_file; +use ui::{Banner, KeyBinding, Modal, ModalFooter, ModalHeader, Section, prelude::*}; +use ui_input::SingleLineInput; +use workspace::{ModalView, Workspace}; + +#[derive(Clone, Copy)] +pub enum LlmCompatibleProvider { + OpenAi, +} + +impl LlmCompatibleProvider { + fn name(&self) -> &'static str { + match self { + LlmCompatibleProvider::OpenAi => "OpenAI", + } + } + + fn api_url(&self) -> &'static str { + match self { + LlmCompatibleProvider::OpenAi => "https://api.openai.com/v1", + } + } +} + +struct AddLlmProviderInput { + provider_name: Entity, + api_url: Entity, + api_key: Entity, + models: Vec, +} + +impl AddLlmProviderInput { + fn new(provider: LlmCompatibleProvider, window: &mut Window, cx: &mut App) -> Self { + let provider_name = single_line_input("Provider Name", provider.name(), None, window, cx); + let api_url = single_line_input("API URL", provider.api_url(), None, window, cx); + let api_key = single_line_input( + "API Key", + "000000000000000000000000000000000000000000000000", + None, + window, + cx, + ); + + Self { + provider_name, + api_url, + api_key, + models: vec![ModelInput::new(window, cx)], + } + } + + fn add_model(&mut self, window: &mut Window, cx: &mut App) { + self.models.push(ModelInput::new(window, cx)); + } + + fn remove_model(&mut self, index: usize) { + self.models.remove(index); + } +} + +struct ModelInput { + name: Entity, + max_completion_tokens: Entity, + max_output_tokens: Entity, + max_tokens: Entity, +} + +impl ModelInput { + fn new(window: &mut Window, cx: &mut App) -> Self { + let model_name = single_line_input( + "Model Name", + "e.g. gpt-4o, claude-opus-4, gemini-2.5-pro", + None, + window, + cx, + ); + let max_completion_tokens = single_line_input( + "Max Completion Tokens", + "200000", + Some("200000"), + window, + cx, + ); + let max_output_tokens = single_line_input( + "Max Output Tokens", + "Max Output Tokens", + Some("32000"), + window, + cx, + ); + let max_tokens = single_line_input("Max Tokens", "Max Tokens", Some("200000"), window, cx); + Self { + name: model_name, + max_completion_tokens, + max_output_tokens, + max_tokens, + } + } + + fn parse(&self, cx: &App) -> Result { + let name = self.name.read(cx).text(cx); + if name.is_empty() { + return Err(SharedString::from("Model Name cannot be empty")); + } + Ok(AvailableModel { + name, + display_name: None, + max_completion_tokens: Some( + self.max_completion_tokens + .read(cx) + .text(cx) + .parse::() + .map_err(|_| SharedString::from("Max Completion Tokens must be a number"))?, + ), + max_output_tokens: Some( + self.max_output_tokens + .read(cx) + .text(cx) + .parse::() + .map_err(|_| SharedString::from("Max Output Tokens must be a number"))?, + ), + max_tokens: self + .max_tokens + .read(cx) + .text(cx) + .parse::() + .map_err(|_| SharedString::from("Max Tokens must be a number"))?, + }) + } +} + +fn single_line_input( + label: impl Into, + placeholder: impl Into, + text: Option<&str>, + window: &mut Window, + cx: &mut App, +) -> Entity { + cx.new(|cx| { + let input = SingleLineInput::new(window, cx, placeholder).label(label); + if let Some(text) = text { + input + .editor() + .update(cx, |editor, cx| editor.set_text(text, window, cx)); + } + input + }) +} + +fn save_provider_to_settings( + input: &AddLlmProviderInput, + cx: &mut App, +) -> Task> { + let provider_name: Arc = input.provider_name.read(cx).text(cx).into(); + if provider_name.is_empty() { + return Task::ready(Err("Provider Name cannot be empty".into())); + } + + if LanguageModelRegistry::read_global(cx) + .providers() + .iter() + .any(|provider| { + provider.id().0.as_ref() == provider_name.as_ref() + || provider.name().0.as_ref() == provider_name.as_ref() + }) + { + return Task::ready(Err( + "Provider Name is already taken by another provider".into() + )); + } + + let api_url = input.api_url.read(cx).text(cx); + if api_url.is_empty() { + return Task::ready(Err("API URL cannot be empty".into())); + } + + let api_key = input.api_key.read(cx).text(cx); + if api_key.is_empty() { + return Task::ready(Err("API Key cannot be empty".into())); + } + + let mut models = Vec::new(); + let mut model_names: HashSet = HashSet::default(); + for model in &input.models { + match model.parse(cx) { + Ok(model) => { + if !model_names.insert(model.name.clone()) { + return Task::ready(Err("Model Names must be unique".into())); + } + models.push(model) + } + Err(err) => return Task::ready(Err(err)), + } + } + + let fs = ::global(cx); + let task = cx.write_credentials(&api_url, "Bearer", api_key.as_bytes()); + cx.spawn(async move |cx| { + task.await + .map_err(|_| "Failed to write API key to keychain")?; + cx.update(|cx| { + update_settings_file::(fs, cx, |settings, _cx| { + settings.openai_compatible.get_or_insert_default().insert( + provider_name, + OpenAiCompatibleSettingsContent { + api_url, + available_models: models, + }, + ); + }); + }) + .ok(); + Ok(()) + }) +} + +pub struct AddLlmProviderModal { + provider: LlmCompatibleProvider, + input: AddLlmProviderInput, + focus_handle: FocusHandle, + last_error: Option, +} + +impl AddLlmProviderModal { + pub fn toggle( + provider: LlmCompatibleProvider, + workspace: &mut Workspace, + window: &mut Window, + cx: &mut Context, + ) { + workspace.toggle_modal(window, cx, |window, cx| Self::new(provider, window, cx)); + } + + fn new(provider: LlmCompatibleProvider, window: &mut Window, cx: &mut Context) -> Self { + Self { + input: AddLlmProviderInput::new(provider, window, cx), + provider, + last_error: None, + focus_handle: cx.focus_handle(), + } + } + + fn confirm(&mut self, _: &menu::Confirm, _: &mut Window, cx: &mut Context) { + let task = save_provider_to_settings(&self.input, cx); + cx.spawn(async move |this, cx| { + let result = task.await; + this.update(cx, |this, cx| match result { + Ok(_) => { + cx.emit(DismissEvent); + } + Err(error) => { + this.last_error = Some(error); + cx.notify(); + } + }) + }) + .detach_and_log_err(cx); + } + + fn cancel(&mut self, _: &menu::Cancel, _: &mut Window, cx: &mut Context) { + cx.emit(DismissEvent); + } + + fn render_section(&self) -> Section { + Section::new() + .child(self.input.provider_name.clone()) + .child(self.input.api_url.clone()) + .child(self.input.api_key.clone()) + } + + fn render_model_section(&self, cx: &mut Context) -> Section { + Section::new().child( + v_flex() + .gap_2() + .child( + h_flex() + .justify_between() + .child(Label::new("Models").size(LabelSize::Small)) + .child( + Button::new("add-model", "Add Model") + .icon(IconName::Plus) + .icon_position(IconPosition::Start) + .icon_size(IconSize::XSmall) + .icon_color(Color::Muted) + .label_size(LabelSize::Small) + .on_click(cx.listener(|this, _, window, cx| { + this.input.add_model(window, cx); + cx.notify(); + })), + ), + ) + .children( + self.input + .models + .iter() + .enumerate() + .map(|(ix, _)| self.render_model(ix, cx)), + ), + ) + } + + fn render_model(&self, ix: usize, cx: &mut Context) -> impl IntoElement + use<> { + let has_more_than_one_model = self.input.models.len() > 1; + let model = &self.input.models[ix]; + + v_flex() + .p_2() + .gap_2() + .rounded_sm() + .border_1() + .border_dashed() + .border_color(cx.theme().colors().border.opacity(0.6)) + .bg(cx.theme().colors().element_active.opacity(0.15)) + .child(model.name.clone()) + .child( + h_flex() + .gap_2() + .child(model.max_completion_tokens.clone()) + .child(model.max_output_tokens.clone()), + ) + .child(model.max_tokens.clone()) + .when(has_more_than_one_model, |this| { + this.child( + Button::new(("remove-model", ix), "Remove Model") + .icon(IconName::Trash) + .icon_position(IconPosition::Start) + .icon_size(IconSize::XSmall) + .icon_color(Color::Muted) + .label_size(LabelSize::Small) + .style(ButtonStyle::Outlined) + .full_width() + .on_click(cx.listener(move |this, _, _window, cx| { + this.input.remove_model(ix); + cx.notify(); + })), + ) + }) + } +} + +impl EventEmitter for AddLlmProviderModal {} + +impl Focusable for AddLlmProviderModal { + fn focus_handle(&self, _cx: &App) -> FocusHandle { + self.focus_handle.clone() + } +} + +impl ModalView for AddLlmProviderModal {} + +impl Render for AddLlmProviderModal { + fn render(&mut self, window: &mut ui::Window, cx: &mut ui::Context) -> impl IntoElement { + let focus_handle = self.focus_handle(cx); + + div() + .id("add-llm-provider-modal") + .key_context("AddLlmProviderModal") + .w(rems(34.)) + .elevation_3(cx) + .on_action(cx.listener(Self::cancel)) + .capture_any_mouse_down(cx.listener(|this, _, window, cx| { + this.focus_handle(cx).focus(window); + })) + .child( + Modal::new("configure-context-server", None) + .header(ModalHeader::new().headline("Add LLM Provider").description( + match self.provider { + LlmCompatibleProvider::OpenAi => { + "This provider will use an OpenAI compatible API." + } + }, + )) + .when_some(self.last_error.clone(), |this, error| { + this.section( + Section::new().child( + Banner::new() + .severity(ui::Severity::Warning) + .child(div().text_xs().child(error)), + ), + ) + }) + .child( + v_flex() + .id("modal_content") + .max_h_128() + .overflow_y_scroll() + .gap_2() + .child(self.render_section()) + .child(self.render_model_section(cx)), + ) + .footer( + ModalFooter::new().end_slot( + h_flex() + .gap_1() + .child( + Button::new("cancel", "Cancel") + .key_binding( + KeyBinding::for_action_in( + &menu::Cancel, + &focus_handle, + window, + cx, + ) + .map(|kb| kb.size(rems_from_px(12.))), + ) + .on_click(cx.listener(|this, _event, window, cx| { + this.cancel(&menu::Cancel, window, cx) + })), + ) + .child( + Button::new("save-server", "Save Provider") + .key_binding( + KeyBinding::for_action_in( + &menu::Confirm, + &focus_handle, + window, + cx, + ) + .map(|kb| kb.size(rems_from_px(12.))), + ) + .on_click(cx.listener(|this, _event, window, cx| { + this.confirm(&menu::Confirm, window, cx) + })), + ), + ), + ), + ) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use editor::EditorSettings; + use fs::FakeFs; + use gpui::{TestAppContext, VisualTestContext}; + use language::language_settings; + use language_model::{ + LanguageModelProviderId, LanguageModelProviderName, + fake_provider::FakeLanguageModelProvider, + }; + use project::Project; + use settings::{Settings as _, SettingsStore}; + use util::path; + + #[gpui::test] + async fn test_save_provider_invalid_inputs(cx: &mut TestAppContext) { + let cx = setup_test(cx).await; + + assert_eq!( + save_provider_validation_errors("", "someurl", "somekey", vec![], cx,).await, + Some("Provider Name cannot be empty".into()) + ); + + assert_eq!( + save_provider_validation_errors("someprovider", "", "somekey", vec![], cx,).await, + Some("API URL cannot be empty".into()) + ); + + assert_eq!( + save_provider_validation_errors("someprovider", "someurl", "", vec![], cx,).await, + Some("API Key cannot be empty".into()) + ); + + assert_eq!( + save_provider_validation_errors( + "someprovider", + "someurl", + "somekey", + vec![("", "200000", "200000", "32000")], + cx, + ) + .await, + Some("Model Name cannot be empty".into()) + ); + + assert_eq!( + save_provider_validation_errors( + "someprovider", + "someurl", + "somekey", + vec![("somemodel", "abc", "200000", "32000")], + cx, + ) + .await, + Some("Max Tokens must be a number".into()) + ); + + assert_eq!( + save_provider_validation_errors( + "someprovider", + "someurl", + "somekey", + vec![("somemodel", "200000", "abc", "32000")], + cx, + ) + .await, + Some("Max Completion Tokens must be a number".into()) + ); + + assert_eq!( + save_provider_validation_errors( + "someprovider", + "someurl", + "somekey", + vec![("somemodel", "200000", "200000", "abc")], + cx, + ) + .await, + Some("Max Output Tokens must be a number".into()) + ); + + assert_eq!( + save_provider_validation_errors( + "someprovider", + "someurl", + "somekey", + vec![ + ("somemodel", "200000", "200000", "32000"), + ("somemodel", "200000", "200000", "32000"), + ], + cx, + ) + .await, + Some("Model Names must be unique".into()) + ); + } + + #[gpui::test] + async fn test_save_provider_name_conflict(cx: &mut TestAppContext) { + let cx = setup_test(cx).await; + + cx.update(|_window, cx| { + LanguageModelRegistry::global(cx).update(cx, |registry, cx| { + registry.register_provider( + FakeLanguageModelProvider::new( + LanguageModelProviderId::new("someprovider"), + LanguageModelProviderName::new("Some Provider"), + ), + cx, + ); + }); + }); + + assert_eq!( + save_provider_validation_errors( + "someprovider", + "someurl", + "someapikey", + vec![("somemodel", "200000", "200000", "32000")], + cx, + ) + .await, + Some("Provider Name is already taken by another provider".into()) + ); + } + + async fn setup_test(cx: &mut TestAppContext) -> &mut VisualTestContext { + cx.update(|cx| { + let store = SettingsStore::test(cx); + cx.set_global(store); + workspace::init_settings(cx); + Project::init_settings(cx); + theme::init(theme::LoadThemes::JustBase, cx); + language_settings::init(cx); + EditorSettings::register(cx); + language_model::init_settings(cx); + language_models::init_settings(cx); + }); + + let fs = FakeFs::new(cx.executor()); + cx.update(|cx| ::set_global(fs.clone(), cx)); + let project = Project::test(fs, [path!("/dir").as_ref()], cx).await; + let (_, cx) = + cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx)); + + cx + } + + async fn save_provider_validation_errors( + provider_name: &str, + api_url: &str, + api_key: &str, + models: Vec<(&str, &str, &str, &str)>, + cx: &mut VisualTestContext, + ) -> Option { + fn set_text( + input: &Entity, + text: &str, + window: &mut Window, + cx: &mut App, + ) { + input.update(cx, |input, cx| { + input.editor().update(cx, |editor, cx| { + editor.set_text(text, window, cx); + }); + }); + } + + let task = cx.update(|window, cx| { + let mut input = AddLlmProviderInput::new(LlmCompatibleProvider::OpenAi, window, cx); + set_text(&input.provider_name, provider_name, window, cx); + set_text(&input.api_url, api_url, window, cx); + set_text(&input.api_key, api_key, window, cx); + + for (i, (name, max_tokens, max_completion_tokens, max_output_tokens)) in + models.iter().enumerate() + { + if i >= input.models.len() { + input.models.push(ModelInput::new(window, cx)); + } + let model = &mut input.models[i]; + set_text(&model.name, name, window, cx); + set_text(&model.max_tokens, max_tokens, window, cx); + set_text( + &model.max_completion_tokens, + max_completion_tokens, + window, + cx, + ); + set_text(&model.max_output_tokens, max_output_tokens, window, cx); + } + save_provider_to_settings(&input, cx) + }); + + task.await.err() + } +} diff --git a/crates/assistant_context/src/assistant_context_tests.rs b/crates/assistant_context/src/assistant_context_tests.rs index dba3bfde61..f139d525d3 100644 --- a/crates/assistant_context/src/assistant_context_tests.rs +++ b/crates/assistant_context/src/assistant_context_tests.rs @@ -1323,7 +1323,7 @@ fn setup_context_editor_with_fake_model( ) -> (Entity, Arc) { let registry = Arc::new(LanguageRegistry::test(cx.executor().clone())); - let fake_provider = Arc::new(FakeLanguageModelProvider); + let fake_provider = Arc::new(FakeLanguageModelProvider::default()); let fake_model = Arc::new(fake_provider.test_model()); cx.update(|cx| { diff --git a/crates/assistant_tools/src/project_notifications_tool.rs b/crates/assistant_tools/src/project_notifications_tool.rs index ec315d9ab1..7567926dca 100644 --- a/crates/assistant_tools/src/project_notifications_tool.rs +++ b/crates/assistant_tools/src/project_notifications_tool.rs @@ -200,7 +200,7 @@ mod tests { // Run the tool before any changes let tool = Arc::new(ProjectNotificationsTool); - let provider = Arc::new(FakeLanguageModelProvider); + let provider = Arc::new(FakeLanguageModelProvider::default()); let model: Arc = Arc::new(provider.test_model()); let request = Arc::new(LanguageModelRequest::default()); let tool_input = json!({}); diff --git a/crates/icons/src/icons.rs b/crates/icons/src/icons.rs index b85e5b517d..e7066ae151 100644 --- a/crates/icons/src/icons.rs +++ b/crates/icons/src/icons.rs @@ -20,6 +20,7 @@ pub enum IconName { AiMistral, AiOllama, AiOpenAi, + AiOpenAiCompat, AiOpenRouter, AiVZero, AiXAi, diff --git a/crates/language_model/src/fake_provider.rs b/crates/language_model/src/fake_provider.rs index f5191016d8..d54db7554a 100644 --- a/crates/language_model/src/fake_provider.rs +++ b/crates/language_model/src/fake_provider.rs @@ -10,25 +10,21 @@ use http_client::Result; use parking_lot::Mutex; use std::sync::Arc; -pub fn language_model_id() -> LanguageModelId { - LanguageModelId::from("fake".to_string()) +#[derive(Clone)] +pub struct FakeLanguageModelProvider { + id: LanguageModelProviderId, + name: LanguageModelProviderName, } -pub fn language_model_name() -> LanguageModelName { - LanguageModelName::from("Fake".to_string()) +impl Default for FakeLanguageModelProvider { + fn default() -> Self { + Self { + id: LanguageModelProviderId::from("fake".to_string()), + name: LanguageModelProviderName::from("Fake".to_string()), + } + } } -pub fn provider_id() -> LanguageModelProviderId { - LanguageModelProviderId::from("fake".to_string()) -} - -pub fn provider_name() -> LanguageModelProviderName { - LanguageModelProviderName::from("Fake".to_string()) -} - -#[derive(Clone, Default)] -pub struct FakeLanguageModelProvider; - impl LanguageModelProviderState for FakeLanguageModelProvider { type ObservableEntity = (); @@ -39,11 +35,11 @@ impl LanguageModelProviderState for FakeLanguageModelProvider { impl LanguageModelProvider for FakeLanguageModelProvider { fn id(&self) -> LanguageModelProviderId { - provider_id() + self.id.clone() } fn name(&self) -> LanguageModelProviderName { - provider_name() + self.name.clone() } fn default_model(&self, _cx: &App) -> Option> { @@ -76,6 +72,10 @@ impl LanguageModelProvider for FakeLanguageModelProvider { } impl FakeLanguageModelProvider { + pub fn new(id: LanguageModelProviderId, name: LanguageModelProviderName) -> Self { + Self { id, name } + } + pub fn test_model(&self) -> FakeLanguageModel { FakeLanguageModel::default() } @@ -89,11 +89,22 @@ pub struct ToolUseRequest { pub schema: serde_json::Value, } -#[derive(Default)] pub struct FakeLanguageModel { + provider_id: LanguageModelProviderId, + provider_name: LanguageModelProviderName, current_completion_txs: Mutex)>>, } +impl Default for FakeLanguageModel { + fn default() -> Self { + Self { + provider_id: LanguageModelProviderId::from("fake".to_string()), + provider_name: LanguageModelProviderName::from("Fake".to_string()), + current_completion_txs: Mutex::new(Vec::new()), + } + } +} + impl FakeLanguageModel { pub fn pending_completions(&self) -> Vec { self.current_completion_txs @@ -138,19 +149,19 @@ impl FakeLanguageModel { impl LanguageModel for FakeLanguageModel { fn id(&self) -> LanguageModelId { - language_model_id() + LanguageModelId::from("fake".to_string()) } fn name(&self) -> LanguageModelName { - language_model_name() + LanguageModelName::from("Fake".to_string()) } fn provider_id(&self) -> LanguageModelProviderId { - provider_id() + self.provider_id.clone() } fn provider_name(&self) -> LanguageModelProviderName { - provider_name() + self.provider_name.clone() } fn supports_tools(&self) -> bool { diff --git a/crates/language_model/src/language_model.rs b/crates/language_model/src/language_model.rs index 72455b3821..54640419b6 100644 --- a/crates/language_model/src/language_model.rs +++ b/crates/language_model/src/language_model.rs @@ -735,6 +735,18 @@ impl From for LanguageModelProviderName { } } +impl From> for LanguageModelProviderId { + fn from(value: Arc) -> Self { + Self(SharedString::from(value)) + } +} + +impl From> for LanguageModelProviderName { + fn from(value: Arc) -> Self { + Self(SharedString::from(value)) + } +} + #[cfg(test)] mod tests { use super::*; diff --git a/crates/language_model/src/registry.rs b/crates/language_model/src/registry.rs index 6e8e8e9108..7cf071808a 100644 --- a/crates/language_model/src/registry.rs +++ b/crates/language_model/src/registry.rs @@ -125,7 +125,7 @@ impl LanguageModelRegistry { #[cfg(any(test, feature = "test-support"))] pub fn test(cx: &mut App) -> crate::fake_provider::FakeLanguageModelProvider { - let fake_provider = crate::fake_provider::FakeLanguageModelProvider; + let fake_provider = crate::fake_provider::FakeLanguageModelProvider::default(); let registry = cx.new(|cx| { let mut registry = Self::default(); registry.register_provider(fake_provider.clone(), cx); @@ -403,16 +403,17 @@ mod tests { fn test_register_providers(cx: &mut App) { let registry = cx.new(|_| LanguageModelRegistry::default()); + let provider = FakeLanguageModelProvider::default(); registry.update(cx, |registry, cx| { - registry.register_provider(FakeLanguageModelProvider, cx); + registry.register_provider(provider.clone(), cx); }); let providers = registry.read(cx).providers(); assert_eq!(providers.len(), 1); - assert_eq!(providers[0].id(), crate::fake_provider::provider_id()); + assert_eq!(providers[0].id(), provider.id()); registry.update(cx, |registry, cx| { - registry.unregister_provider(crate::fake_provider::provider_id(), cx); + registry.unregister_provider(provider.id(), cx); }); let providers = registry.read(cx).providers(); diff --git a/crates/language_models/Cargo.toml b/crates/language_models/Cargo.toml index ed38ac7660..574579aaa7 100644 --- a/crates/language_models/Cargo.toml +++ b/crates/language_models/Cargo.toml @@ -26,10 +26,10 @@ client.workspace = true collections.workspace = true component.workspace = true credentials_provider.workspace = true +convert_case.workspace = true copilot.workspace = true deepseek = { workspace = true, features = ["schemars"] } editor.workspace = true -fs.workspace = true futures.workspace = true google_ai = { workspace = true, features = ["schemars"] } gpui.workspace = true diff --git a/crates/language_models/src/language_models.rs b/crates/language_models/src/language_models.rs index 192f5a5fae..18e6f47ed0 100644 --- a/crates/language_models/src/language_models.rs +++ b/crates/language_models/src/language_models.rs @@ -1,8 +1,10 @@ use std::sync::Arc; +use ::settings::{Settings, SettingsStore}; use client::{Client, UserStore}; +use collections::HashSet; use gpui::{App, Context, Entity}; -use language_model::LanguageModelRegistry; +use language_model::{LanguageModelProviderId, LanguageModelRegistry}; use provider::deepseek::DeepSeekLanguageModelProvider; pub mod provider; @@ -18,17 +20,81 @@ use crate::provider::lmstudio::LmStudioLanguageModelProvider; use crate::provider::mistral::MistralLanguageModelProvider; use crate::provider::ollama::OllamaLanguageModelProvider; use crate::provider::open_ai::OpenAiLanguageModelProvider; +use crate::provider::open_ai_compatible::OpenAiCompatibleLanguageModelProvider; use crate::provider::open_router::OpenRouterLanguageModelProvider; use crate::provider::vercel::VercelLanguageModelProvider; use crate::provider::x_ai::XAiLanguageModelProvider; pub use crate::settings::*; pub fn init(user_store: Entity, client: Arc, cx: &mut App) { - crate::settings::init(cx); + crate::settings::init_settings(cx); let registry = LanguageModelRegistry::global(cx); registry.update(cx, |registry, cx| { - register_language_model_providers(registry, user_store, client, cx); + register_language_model_providers(registry, user_store, client.clone(), cx); }); + + let mut openai_compatible_providers = AllLanguageModelSettings::get_global(cx) + .openai_compatible + .keys() + .cloned() + .collect::>(); + + registry.update(cx, |registry, cx| { + register_openai_compatible_providers( + registry, + &HashSet::default(), + &openai_compatible_providers, + client.clone(), + cx, + ); + }); + cx.observe_global::(move |cx| { + let openai_compatible_providers_new = AllLanguageModelSettings::get_global(cx) + .openai_compatible + .keys() + .cloned() + .collect::>(); + if openai_compatible_providers_new != openai_compatible_providers { + registry.update(cx, |registry, cx| { + register_openai_compatible_providers( + registry, + &openai_compatible_providers, + &openai_compatible_providers_new, + client.clone(), + cx, + ); + }); + openai_compatible_providers = openai_compatible_providers_new; + } + }) + .detach(); +} + +fn register_openai_compatible_providers( + registry: &mut LanguageModelRegistry, + old: &HashSet>, + new: &HashSet>, + client: Arc, + cx: &mut Context, +) { + for provider_id in old { + if !new.contains(provider_id) { + registry.unregister_provider(LanguageModelProviderId::from(provider_id.clone()), cx); + } + } + + for provider_id in new { + if !old.contains(provider_id) { + registry.register_provider( + OpenAiCompatibleLanguageModelProvider::new( + provider_id.clone(), + client.http_client(), + cx, + ), + cx, + ); + } + } } fn register_language_model_providers( diff --git a/crates/language_models/src/provider.rs b/crates/language_models/src/provider.rs index c717be7c90..d780195c66 100644 --- a/crates/language_models/src/provider.rs +++ b/crates/language_models/src/provider.rs @@ -8,6 +8,7 @@ pub mod lmstudio; pub mod mistral; pub mod ollama; pub mod open_ai; +pub mod open_ai_compatible; pub mod open_router; pub mod vercel; pub mod x_ai; diff --git a/crates/language_models/src/provider/open_ai.rs b/crates/language_models/src/provider/open_ai.rs index 76f2fbe303..6c4d4c9b3e 100644 --- a/crates/language_models/src/provider/open_ai.rs +++ b/crates/language_models/src/provider/open_ai.rs @@ -2,7 +2,6 @@ use anyhow::{Context as _, Result, anyhow}; use collections::{BTreeMap, HashMap}; use credentials_provider::CredentialsProvider; -use fs::Fs; use futures::Stream; use futures::{FutureExt, StreamExt, future::BoxFuture}; use gpui::{AnyView, App, AsyncApp, Context, Entity, Subscription, Task, Window}; @@ -18,7 +17,7 @@ use menu; use open_ai::{ImageUrl, Model, ResponseStreamEvent, stream_completion}; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; -use settings::{Settings, SettingsStore, update_settings_file}; +use settings::{Settings, SettingsStore}; use std::pin::Pin; use std::str::FromStr as _; use std::sync::Arc; @@ -28,7 +27,6 @@ use ui::{ElevationIndex, List, Tooltip, prelude::*}; use ui_input::SingleLineInput; use util::ResultExt; -use crate::OpenAiSettingsContent; use crate::{AllLanguageModelSettings, ui::InstructionListItem}; const PROVIDER_ID: LanguageModelProviderId = language_model::OPEN_AI_PROVIDER_ID; @@ -621,26 +619,32 @@ struct RawToolCall { arguments: String, } +pub(crate) fn collect_tiktoken_messages( + request: LanguageModelRequest, +) -> Vec { + request + .messages + .into_iter() + .map(|message| tiktoken_rs::ChatCompletionRequestMessage { + role: match message.role { + Role::User => "user".into(), + Role::Assistant => "assistant".into(), + Role::System => "system".into(), + }, + content: Some(message.string_contents()), + name: None, + function_call: None, + }) + .collect::>() +} + pub fn count_open_ai_tokens( request: LanguageModelRequest, model: Model, cx: &App, ) -> BoxFuture<'static, Result> { cx.background_spawn(async move { - let messages = request - .messages - .into_iter() - .map(|message| tiktoken_rs::ChatCompletionRequestMessage { - role: match message.role { - Role::User => "user".into(), - Role::Assistant => "assistant".into(), - Role::System => "system".into(), - }, - content: Some(message.string_contents()), - name: None, - function_call: None, - }) - .collect::>(); + let messages = collect_tiktoken_messages(request); match model { Model::Custom { max_tokens, .. } => { @@ -678,7 +682,6 @@ pub fn count_open_ai_tokens( struct ConfigurationView { api_key_editor: Entity, - api_url_editor: Entity, state: gpui::Entity, load_credentials_task: Option>, } @@ -691,23 +694,6 @@ impl ConfigurationView { cx, "sk-000000000000000000000000000000000000000000000000", ) - .label("API key") - }); - - let api_url = AllLanguageModelSettings::get_global(cx) - .openai - .api_url - .clone(); - - let api_url_editor = cx.new(|cx| { - let input = SingleLineInput::new(window, cx, open_ai::OPEN_AI_API_URL).label("API URL"); - - if !api_url.is_empty() { - input.editor.update(cx, |editor, cx| { - editor.set_text(&*api_url, window, cx); - }); - } - input }); cx.observe(&state, |_, _, cx| { @@ -735,7 +721,6 @@ impl ConfigurationView { Self { api_key_editor, - api_url_editor, state, load_credentials_task, } @@ -783,57 +768,6 @@ impl ConfigurationView { cx.notify(); } - fn save_api_url(&mut self, cx: &mut Context) { - let api_url = self - .api_url_editor - .read(cx) - .editor() - .read(cx) - .text(cx) - .trim() - .to_string(); - - let current_url = AllLanguageModelSettings::get_global(cx) - .openai - .api_url - .clone(); - - let effective_current_url = if current_url.is_empty() { - open_ai::OPEN_AI_API_URL - } else { - ¤t_url - }; - - if !api_url.is_empty() && api_url != effective_current_url { - let fs = ::global(cx); - update_settings_file::(fs, cx, move |settings, _| { - if let Some(settings) = settings.openai.as_mut() { - settings.api_url = Some(api_url.clone()); - } else { - settings.openai = Some(OpenAiSettingsContent { - api_url: Some(api_url.clone()), - available_models: None, - }); - } - }); - } - } - - fn reset_api_url(&mut self, window: &mut Window, cx: &mut Context) { - self.api_url_editor.update(cx, |input, cx| { - input.editor.update(cx, |editor, cx| { - editor.set_text("", window, cx); - }); - }); - let fs = ::global(cx); - update_settings_file::(fs, cx, |settings, _cx| { - if let Some(settings) = settings.openai.as_mut() { - settings.api_url = None; - } - }); - cx.notify(); - } - fn should_render_editor(&self, cx: &mut Context) -> bool { !self.state.read(cx).is_authenticated() } @@ -846,7 +780,6 @@ impl Render for ConfigurationView { let api_key_section = if self.should_render_editor(cx) { v_flex() .on_action(cx.listener(Self::save_api_key)) - .child(Label::new("To use Zed's assistant with OpenAI, you need to add an API key. Follow these steps:")) .child( List::new() @@ -910,59 +843,34 @@ impl Render for ConfigurationView { .into_any() }; - let custom_api_url_set = - AllLanguageModelSettings::get_global(cx).openai.api_url != open_ai::OPEN_AI_API_URL; - - let api_url_section = if custom_api_url_set { - h_flex() - .mt_1() - .p_1() - .justify_between() - .rounded_md() - .border_1() - .border_color(cx.theme().colors().border) - .bg(cx.theme().colors().background) - .child( - h_flex() - .gap_1() - .child(Icon::new(IconName::Check).color(Color::Success)) - .child(Label::new("Custom API URL configured.")), - ) - .child( - Button::new("reset-api-url", "Reset API URL") - .label_size(LabelSize::Small) - .icon(IconName::Undo) - .icon_size(IconSize::Small) - .icon_position(IconPosition::Start) - .layer(ElevationIndex::ModalSurface) - .on_click( - cx.listener(|this, _, window, cx| this.reset_api_url(window, cx)), - ), - ) - .into_any() - } else { - v_flex() - .on_action(cx.listener(|this, _: &menu::Confirm, _window, cx| { - this.save_api_url(cx); - cx.notify(); - })) - .mt_2() - .pt_2() - .border_t_1() - .border_color(cx.theme().colors().border_variant) - .gap_1() - .child( - List::new() - .child(InstructionListItem::text_only( - "Optionally, you can change the base URL for the OpenAI API request.", - )) - .child(InstructionListItem::text_only( - "Paste the new API endpoint below and hit enter", - )), - ) - .child(self.api_url_editor.clone()) - .into_any() - }; + let compatible_api_section = h_flex() + .mt_1p5() + .gap_0p5() + .flex_wrap() + .when(self.should_render_editor(cx), |this| { + this.pt_1p5() + .border_t_1() + .border_color(cx.theme().colors().border_variant) + }) + .child( + h_flex() + .gap_2() + .child( + Icon::new(IconName::Info) + .size(IconSize::XSmall) + .color(Color::Muted), + ) + .child(Label::new("Zed also supports OpenAI-compatible models.")), + ) + .child( + Button::new("docs", "Learn More") + .icon(IconName::ArrowUpRight) + .icon_size(IconSize::XSmall) + .icon_color(Color::Muted) + .on_click(move |_, _window, cx| { + cx.open_url("https://zed.dev/docs/ai/configuration#openai-api-compatible") + }), + ); if self.load_credentials_task.is_some() { div().child(Label::new("Loading credentials…")).into_any() @@ -970,7 +878,7 @@ impl Render for ConfigurationView { v_flex() .size_full() .child(api_key_section) - .child(api_url_section) + .child(compatible_api_section) .into_any() } } diff --git a/crates/language_models/src/provider/open_ai_compatible.rs b/crates/language_models/src/provider/open_ai_compatible.rs new file mode 100644 index 0000000000..64add5483d --- /dev/null +++ b/crates/language_models/src/provider/open_ai_compatible.rs @@ -0,0 +1,522 @@ +use anyhow::{Context as _, Result, anyhow}; +use credentials_provider::CredentialsProvider; + +use convert_case::{Case, Casing}; +use futures::{FutureExt, StreamExt, future::BoxFuture}; +use gpui::{AnyView, App, AsyncApp, Context, Entity, Subscription, Task, Window}; +use http_client::HttpClient; +use language_model::{ + AuthenticateError, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent, + LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, + LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, + LanguageModelToolChoice, RateLimiter, +}; +use menu; +use open_ai::{ResponseStreamEvent, stream_completion}; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use settings::{Settings, SettingsStore}; +use std::sync::Arc; + +use ui::{ElevationIndex, Tooltip, prelude::*}; +use ui_input::SingleLineInput; +use util::ResultExt; + +use crate::AllLanguageModelSettings; +use crate::provider::open_ai::{OpenAiEventMapper, into_open_ai}; + +#[derive(Default, Clone, Debug, PartialEq)] +pub struct OpenAiCompatibleSettings { + pub api_url: String, + pub available_models: Vec, +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)] +pub struct AvailableModel { + pub name: String, + pub display_name: Option, + pub max_tokens: u64, + pub max_output_tokens: Option, + pub max_completion_tokens: Option, +} + +pub struct OpenAiCompatibleLanguageModelProvider { + id: LanguageModelProviderId, + name: LanguageModelProviderName, + http_client: Arc, + state: gpui::Entity, +} + +pub struct State { + id: Arc, + env_var_name: Arc, + api_key: Option, + api_key_from_env: bool, + settings: OpenAiCompatibleSettings, + _subscription: Subscription, +} + +impl State { + fn is_authenticated(&self) -> bool { + self.api_key.is_some() + } + + fn reset_api_key(&self, cx: &mut Context) -> Task> { + let credentials_provider = ::global(cx); + let api_url = self.settings.api_url.clone(); + cx.spawn(async move |this, cx| { + credentials_provider + .delete_credentials(&api_url, &cx) + .await + .log_err(); + this.update(cx, |this, cx| { + this.api_key = None; + this.api_key_from_env = false; + cx.notify(); + }) + }) + } + + fn set_api_key(&mut self, api_key: String, cx: &mut Context) -> Task> { + let credentials_provider = ::global(cx); + let api_url = self.settings.api_url.clone(); + cx.spawn(async move |this, cx| { + credentials_provider + .write_credentials(&api_url, "Bearer", api_key.as_bytes(), &cx) + .await + .log_err(); + this.update(cx, |this, cx| { + this.api_key = Some(api_key); + cx.notify(); + }) + }) + } + + fn authenticate(&self, cx: &mut Context) -> Task> { + if self.is_authenticated() { + return Task::ready(Ok(())); + } + + let credentials_provider = ::global(cx); + let env_var_name = self.env_var_name.clone(); + let api_url = self.settings.api_url.clone(); + cx.spawn(async move |this, cx| { + let (api_key, from_env) = if let Ok(api_key) = std::env::var(env_var_name.as_ref()) { + (api_key, true) + } else { + let (_, api_key) = credentials_provider + .read_credentials(&api_url, &cx) + .await? + .ok_or(AuthenticateError::CredentialsNotFound)?; + ( + String::from_utf8(api_key).context("invalid {PROVIDER_NAME} API key")?, + false, + ) + }; + this.update(cx, |this, cx| { + this.api_key = Some(api_key); + this.api_key_from_env = from_env; + cx.notify(); + })?; + + Ok(()) + }) + } +} + +impl OpenAiCompatibleLanguageModelProvider { + pub fn new(id: Arc, http_client: Arc, cx: &mut App) -> Self { + fn resolve_settings<'a>(id: &'a str, cx: &'a App) -> Option<&'a OpenAiCompatibleSettings> { + AllLanguageModelSettings::get_global(cx) + .openai_compatible + .get(id) + } + + let state = cx.new(|cx| State { + id: id.clone(), + env_var_name: format!("{}_API_KEY", id).to_case(Case::Constant).into(), + settings: resolve_settings(&id, cx).cloned().unwrap_or_default(), + api_key: None, + api_key_from_env: false, + _subscription: cx.observe_global::(|this: &mut State, cx| { + let Some(settings) = resolve_settings(&this.id, cx) else { + return; + }; + if &this.settings != settings { + this.settings = settings.clone(); + cx.notify(); + } + }), + }); + + Self { + id: id.clone().into(), + name: id.into(), + http_client, + state, + } + } + + fn create_language_model(&self, model: AvailableModel) -> Arc { + Arc::new(OpenAiCompatibleLanguageModel { + id: LanguageModelId::from(model.name.clone()), + provider_id: self.id.clone(), + provider_name: self.name.clone(), + model, + state: self.state.clone(), + http_client: self.http_client.clone(), + request_limiter: RateLimiter::new(4), + }) + } +} + +impl LanguageModelProviderState for OpenAiCompatibleLanguageModelProvider { + type ObservableEntity = State; + + fn observable_entity(&self) -> Option> { + Some(self.state.clone()) + } +} + +impl LanguageModelProvider for OpenAiCompatibleLanguageModelProvider { + fn id(&self) -> LanguageModelProviderId { + self.id.clone() + } + + fn name(&self) -> LanguageModelProviderName { + self.name.clone() + } + + fn icon(&self) -> IconName { + IconName::AiOpenAiCompat + } + + fn default_model(&self, cx: &App) -> Option> { + self.state + .read(cx) + .settings + .available_models + .first() + .map(|model| self.create_language_model(model.clone())) + } + + fn default_fast_model(&self, _cx: &App) -> Option> { + None + } + + fn provided_models(&self, cx: &App) -> Vec> { + self.state + .read(cx) + .settings + .available_models + .iter() + .map(|model| self.create_language_model(model.clone())) + .collect() + } + + fn is_authenticated(&self, cx: &App) -> bool { + self.state.read(cx).is_authenticated() + } + + fn authenticate(&self, cx: &mut App) -> Task> { + self.state.update(cx, |state, cx| state.authenticate(cx)) + } + + fn configuration_view(&self, window: &mut Window, cx: &mut App) -> AnyView { + cx.new(|cx| ConfigurationView::new(self.state.clone(), window, cx)) + .into() + } + + fn reset_credentials(&self, cx: &mut App) -> Task> { + self.state.update(cx, |state, cx| state.reset_api_key(cx)) + } +} + +pub struct OpenAiCompatibleLanguageModel { + id: LanguageModelId, + provider_id: LanguageModelProviderId, + provider_name: LanguageModelProviderName, + model: AvailableModel, + state: gpui::Entity, + http_client: Arc, + request_limiter: RateLimiter, +} + +impl OpenAiCompatibleLanguageModel { + fn stream_completion( + &self, + request: open_ai::Request, + cx: &AsyncApp, + ) -> BoxFuture<'static, Result>>> + { + let http_client = self.http_client.clone(); + let Ok((api_key, api_url)) = cx.read_entity(&self.state, |state, _| { + (state.api_key.clone(), state.settings.api_url.clone()) + }) else { + return futures::future::ready(Err(anyhow!("App state dropped"))).boxed(); + }; + + let provider = self.provider_name.clone(); + let future = self.request_limiter.stream(async move { + let Some(api_key) = api_key else { + return Err(LanguageModelCompletionError::NoApiKey { provider }); + }; + let request = stream_completion(http_client.as_ref(), &api_url, &api_key, request); + let response = request.await?; + Ok(response) + }); + + async move { Ok(future.await?.boxed()) }.boxed() + } +} + +impl LanguageModel for OpenAiCompatibleLanguageModel { + fn id(&self) -> LanguageModelId { + self.id.clone() + } + + fn name(&self) -> LanguageModelName { + LanguageModelName::from( + self.model + .display_name + .clone() + .unwrap_or_else(|| self.model.name.clone()), + ) + } + + fn provider_id(&self) -> LanguageModelProviderId { + self.provider_id.clone() + } + + fn provider_name(&self) -> LanguageModelProviderName { + self.provider_name.clone() + } + + fn supports_tools(&self) -> bool { + true + } + + fn supports_images(&self) -> bool { + false + } + + fn supports_tool_choice(&self, choice: LanguageModelToolChoice) -> bool { + match choice { + LanguageModelToolChoice::Auto => true, + LanguageModelToolChoice::Any => true, + LanguageModelToolChoice::None => true, + } + } + + fn telemetry_id(&self) -> String { + format!("openai/{}", self.model.name) + } + + fn max_token_count(&self) -> u64 { + self.model.max_tokens + } + + fn max_output_tokens(&self) -> Option { + self.model.max_output_tokens + } + + fn count_tokens( + &self, + request: LanguageModelRequest, + cx: &App, + ) -> BoxFuture<'static, Result> { + let max_token_count = self.max_token_count(); + cx.background_spawn(async move { + let messages = super::open_ai::collect_tiktoken_messages(request); + let model = if max_token_count >= 100_000 { + // If the max tokens is 100k or more, it is likely the o200k_base tokenizer from gpt4o + "gpt-4o" + } else { + // Otherwise fallback to gpt-4, since only cl100k_base and o200k_base are + // supported with this tiktoken method + "gpt-4" + }; + tiktoken_rs::num_tokens_from_messages(model, &messages).map(|tokens| tokens as u64) + }) + .boxed() + } + + fn stream_completion( + &self, + request: LanguageModelRequest, + cx: &AsyncApp, + ) -> BoxFuture< + 'static, + Result< + futures::stream::BoxStream< + 'static, + Result, + >, + LanguageModelCompletionError, + >, + > { + let request = into_open_ai(request, &self.model.name, true, self.max_output_tokens()); + let completions = self.stream_completion(request, cx); + async move { + let mapper = OpenAiEventMapper::new(); + Ok(mapper.map_stream(completions.await?).boxed()) + } + .boxed() + } +} + +struct ConfigurationView { + api_key_editor: Entity, + state: gpui::Entity, + load_credentials_task: Option>, +} + +impl ConfigurationView { + fn new(state: gpui::Entity, window: &mut Window, cx: &mut Context) -> Self { + let api_key_editor = cx.new(|cx| { + SingleLineInput::new( + window, + cx, + "000000000000000000000000000000000000000000000000000", + ) + }); + + cx.observe(&state, |_, _, cx| { + cx.notify(); + }) + .detach(); + + let load_credentials_task = Some(cx.spawn_in(window, { + let state = state.clone(); + async move |this, cx| { + if let Some(task) = state + .update(cx, |state, cx| state.authenticate(cx)) + .log_err() + { + // We don't log an error, because "not signed in" is also an error. + let _ = task.await; + } + this.update(cx, |this, cx| { + this.load_credentials_task = None; + cx.notify(); + }) + .log_err(); + } + })); + + Self { + api_key_editor, + state, + load_credentials_task, + } + } + + fn save_api_key(&mut self, _: &menu::Confirm, window: &mut Window, cx: &mut Context) { + let api_key = self + .api_key_editor + .read(cx) + .editor() + .read(cx) + .text(cx) + .trim() + .to_string(); + + // Don't proceed if no API key is provided and we're not authenticated + if api_key.is_empty() && !self.state.read(cx).is_authenticated() { + return; + } + + let state = self.state.clone(); + cx.spawn_in(window, async move |_, cx| { + state + .update(cx, |state, cx| state.set_api_key(api_key, cx))? + .await + }) + .detach_and_log_err(cx); + + cx.notify(); + } + + fn reset_api_key(&mut self, window: &mut Window, cx: &mut Context) { + self.api_key_editor.update(cx, |input, cx| { + input.editor.update(cx, |editor, cx| { + editor.set_text("", window, cx); + }); + }); + + let state = self.state.clone(); + cx.spawn_in(window, async move |_, cx| { + state.update(cx, |state, cx| state.reset_api_key(cx))?.await + }) + .detach_and_log_err(cx); + + cx.notify(); + } + + fn should_render_editor(&self, cx: &mut Context) -> bool { + !self.state.read(cx).is_authenticated() + } +} + +impl Render for ConfigurationView { + fn render(&mut self, _: &mut Window, cx: &mut Context) -> impl IntoElement { + let env_var_set = self.state.read(cx).api_key_from_env; + let env_var_name = self.state.read(cx).env_var_name.clone(); + + let api_key_section = if self.should_render_editor(cx) { + v_flex() + .on_action(cx.listener(Self::save_api_key)) + .child(Label::new("To use Zed's assistant with an OpenAI compatible provider, you need to add an API key.")) + .child( + div() + .pt(DynamicSpacing::Base04.rems(cx)) + .child(self.api_key_editor.clone()) + ) + .child( + Label::new( + format!("You can also assign the {env_var_name} environment variable and restart Zed."), + ) + .size(LabelSize::Small).color(Color::Muted), + ) + .into_any() + } else { + h_flex() + .mt_1() + .p_1() + .justify_between() + .rounded_md() + .border_1() + .border_color(cx.theme().colors().border) + .bg(cx.theme().colors().background) + .child( + h_flex() + .gap_1() + .child(Icon::new(IconName::Check).color(Color::Success)) + .child(Label::new(if env_var_set { + format!("API key set in {env_var_name} environment variable.") + } else { + "API key configured.".to_string() + })), + ) + .child( + Button::new("reset-api-key", "Reset API Key") + .label_size(LabelSize::Small) + .icon(IconName::Undo) + .icon_size(IconSize::Small) + .icon_position(IconPosition::Start) + .layer(ElevationIndex::ModalSurface) + .when(env_var_set, |this| { + this.tooltip(Tooltip::text(format!("To reset your API key, unset the {env_var_name} environment variable."))) + }) + .on_click(cx.listener(|this, _, window, cx| this.reset_api_key(window, cx))), + ) + .into_any() + }; + + if self.load_credentials_task.is_some() { + div().child(Label::new("Loading credentials…")).into_any() + } else { + v_flex().size_full().child(api_key_section).into_any() + } + } +} diff --git a/crates/language_models/src/settings.rs b/crates/language_models/src/settings.rs index dafbb62910..b163585aa7 100644 --- a/crates/language_models/src/settings.rs +++ b/crates/language_models/src/settings.rs @@ -1,4 +1,7 @@ +use std::sync::Arc; + use anyhow::Result; +use collections::HashMap; use gpui::App; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; @@ -15,13 +18,14 @@ use crate::provider::{ mistral::MistralSettings, ollama::OllamaSettings, open_ai::OpenAiSettings, + open_ai_compatible::OpenAiCompatibleSettings, open_router::OpenRouterSettings, vercel::VercelSettings, x_ai::XAiSettings, }; /// Initializes the language model settings. -pub fn init(cx: &mut App) { +pub fn init_settings(cx: &mut App) { AllLanguageModelSettings::register(cx); } @@ -36,6 +40,7 @@ pub struct AllLanguageModelSettings { pub ollama: OllamaSettings, pub open_router: OpenRouterSettings, pub openai: OpenAiSettings, + pub openai_compatible: HashMap, OpenAiCompatibleSettings>, pub vercel: VercelSettings, pub x_ai: XAiSettings, pub zed_dot_dev: ZedDotDevSettings, @@ -52,6 +57,7 @@ pub struct AllLanguageModelSettingsContent { pub ollama: Option, pub open_router: Option, pub openai: Option, + pub openai_compatible: Option, OpenAiCompatibleSettingsContent>>, pub vercel: Option, pub x_ai: Option, #[serde(rename = "zed.dev")] @@ -103,6 +109,12 @@ pub struct OpenAiSettingsContent { pub available_models: Option>, } +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema)] +pub struct OpenAiCompatibleSettingsContent { + pub api_url: String, + pub available_models: Vec, +} + #[derive(Default, Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema)] pub struct VercelSettingsContent { pub api_url: Option, @@ -226,6 +238,19 @@ impl settings::Settings for AllLanguageModelSettings { openai.as_ref().and_then(|s| s.available_models.clone()), ); + // OpenAI Compatible + if let Some(openai_compatible) = value.openai_compatible.clone() { + for (id, openai_compatible_settings) in openai_compatible { + settings.openai_compatible.insert( + id, + OpenAiCompatibleSettings { + api_url: openai_compatible_settings.api_url, + available_models: openai_compatible_settings.available_models, + }, + ); + } + } + // Vercel let vercel = value.vercel.clone(); merge( diff --git a/crates/ui/src/components/modal.rs b/crates/ui/src/components/modal.rs index 2e926b7593..2145b34ef2 100644 --- a/crates/ui/src/components/modal.rs +++ b/crates/ui/src/components/modal.rs @@ -93,6 +93,7 @@ impl RenderOnce for Modal { #[derive(IntoElement)] pub struct ModalHeader { headline: Option, + description: Option, children: SmallVec<[AnyElement; 2]>, show_dismiss_button: bool, show_back_button: bool, @@ -108,6 +109,7 @@ impl ModalHeader { pub fn new() -> Self { Self { headline: None, + description: None, children: SmallVec::new(), show_dismiss_button: false, show_back_button: false, @@ -123,6 +125,11 @@ impl ModalHeader { self } + pub fn description(mut self, description: impl Into) -> Self { + self.description = Some(description.into()); + self + } + pub fn show_dismiss_button(mut self, show: bool) -> Self { self.show_dismiss_button = show; self @@ -171,7 +178,14 @@ impl RenderOnce for ModalHeader { }), ) }) - .child(div().flex_1().children(children)) + .child( + v_flex().flex_1().children(children).when_some( + self.description, + |this, description| { + this.child(Label::new(description).color(Color::Muted).mb_2()) + }, + ), + ) .when(self.show_dismiss_button, |this| { this.child( IconButton::new("dismiss", IconName::Close) diff --git a/crates/ui_input/src/ui_input.rs b/crates/ui_input/src/ui_input.rs index 18aa732e81..309b3f62f6 100644 --- a/crates/ui_input/src/ui_input.rs +++ b/crates/ui_input/src/ui_input.rs @@ -97,6 +97,10 @@ impl SingleLineInput { pub fn editor(&self) -> &Entity { &self.editor } + + pub fn text(&self, cx: &App) -> String { + self.editor().read(cx).text(cx) + } } impl Render for SingleLineInput { diff --git a/docs/src/ai/configuration.md b/docs/src/ai/configuration.md index 1201fa2173..414da2206f 100644 --- a/docs/src/ai/configuration.md +++ b/docs/src/ai/configuration.md @@ -444,14 +444,17 @@ Custom models will be listed in the model dropdown in the Agent Panel. ### OpenAI API Compatible {#openai-api-compatible} -Zed supports using OpenAI compatible APIs by specifying a custom `endpoint` and `available_models` for the OpenAI provider. +Zed supports using [OpenAI compatible APIs](https://platform.openai.com/docs/api-reference/chat) by specifying a custom `api_url` and `available_models` for the OpenAI provider. This is useful for connecting to other hosted services (like Together AI, Anyscale, etc.) or local models. -Zed supports using OpenAI compatible APIs by specifying a custom `api_url` and `available_models` for the OpenAI provider. This is useful for connecting to other hosted services (like Together AI, Anyscale, etc.) or local models. +To configure a compatible API, you can add a custom API URL for OpenAI either via the UI (currently available only in Preview) or by editing your `settings.json`. -To configure a compatible API, you can add a custom API URL for OpenAI either via the UI or by editing your `settings.json`. For example, to connect to [Together AI](https://www.together.ai/): +For example, to connect to [Together AI](https://www.together.ai/) via the UI: -1. Get an API key from your [Together AI account](https://api.together.ai/settings/api-keys). -2. Add the following to your `settings.json`: +1. Get an API key from your [Together AI account](https://api.together.ai/settings/api-keys). +2. Go to the Agent Panel's settings view, click on the "Add Provider" button, and then on the "OpenAI" menu item +3. Add the requested fields, such as `api_url`, `api_key`, available models, and others + +Alternatively, you can also add it via the `settings.json`: ```json { From 939f9fffa3f7d305280957dcf1573989ab429a7b Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Tue, 22 Jul 2025 11:27:58 -0400 Subject: [PATCH 0123/1052] collab: Remove unneeded caching of Stripe meters (#34900) This PR removes the caching of Stripe meters on the `StripeBilling` object, as we weren't actually reading them anywhere. Release Notes: - N/A --- crates/collab/src/stripe_billing.rs | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/crates/collab/src/stripe_billing.rs b/crates/collab/src/stripe_billing.rs index 3d52dea0e3..707928d5cd 100644 --- a/crates/collab/src/stripe_billing.rs +++ b/crates/collab/src/stripe_billing.rs @@ -17,7 +17,7 @@ use crate::stripe_client::{ StripeCreateCheckoutSessionSubscriptionData, StripeCreateMeterEventParams, StripeCreateMeterEventPayload, StripeCreateSubscriptionItems, StripeCreateSubscriptionParams, StripeCustomerId, StripeCustomerUpdate, StripeCustomerUpdateAddress, StripeCustomerUpdateName, - StripeMeter, StripePrice, StripePriceId, StripeSubscription, StripeSubscriptionId, + StripePrice, StripePriceId, StripeSubscription, StripeSubscriptionId, StripeSubscriptionTrialSettings, StripeSubscriptionTrialSettingsEndBehavior, StripeSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod, StripeTaxIdCollection, UpdateSubscriptionItems, UpdateSubscriptionParams, @@ -30,7 +30,6 @@ pub struct StripeBilling { #[derive(Default)] struct StripeBillingState { - meters_by_event_name: HashMap, price_ids_by_meter_id: HashMap, prices_by_lookup_key: HashMap, } @@ -60,14 +59,7 @@ impl StripeBilling { let mut state = self.state.write().await; - let (meters, prices) = - futures::try_join!(self.client.list_meters(), self.client.list_prices())?; - - for meter in meters { - state - .meters_by_event_name - .insert(meter.event_name.clone(), meter); - } + let prices = self.client.list_prices().await?; for price in prices { if let Some(lookup_key) = price.lookup_key.clone() { From 96f994279167569a4458bb9f5cd636bfb82c0fac Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Tue, 22 Jul 2025 11:32:39 -0400 Subject: [PATCH 0124/1052] Add setting to disable all AI features (#34896) https://github.com/user-attachments/assets/674bba41-40ac-4a98-99e4-0b47f9097b6a Release Notes: - Added setting to disable all AI features --- Cargo.lock | 2 + assets/settings/default.json | 4 ++ crates/agent_ui/Cargo.toml | 1 + crates/agent_ui/src/agent_panel.rs | 8 ++- crates/agent_ui/src/agent_ui.rs | 65 ++++++++++++++++++- crates/agent_ui/src/inline_assistant.rs | 44 ++++++++++++- crates/assistant_tools/Cargo.toml | 1 + crates/assistant_tools/src/assistant_tools.rs | 3 +- crates/client/src/client.rs | 28 ++++++++ crates/copilot/src/copilot.rs | 46 ++++++++----- crates/git_ui/Cargo.toml | 1 + crates/git_ui/src/commit_modal.rs | 14 ++-- crates/git_ui/src/git_panel.rs | 19 ++++-- .../src/inline_completion_button.rs | 7 +- crates/welcome/src/welcome.rs | 36 +++++----- crates/workspace/src/dock.rs | 13 +++- crates/zed/src/main.rs | 1 + crates/zed/src/zed/quick_action_bar.rs | 26 +++++++- crates/zeta/src/init.rs | 57 ++++++++++++---- 19 files changed, 308 insertions(+), 68 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index c7297e6d59..6237bac204 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -210,6 +210,7 @@ dependencies = [ "chrono", "client", "collections", + "command_palette_hooks", "component", "context_server", "db", @@ -6360,6 +6361,7 @@ dependencies = [ "buffer_diff", "call", "chrono", + "client", "collections", "command_palette_hooks", "component", diff --git a/assets/settings/default.json b/assets/settings/default.json index 309afaccf5..dab1684aef 100644 --- a/assets/settings/default.json +++ b/assets/settings/default.json @@ -1076,6 +1076,10 @@ // Send anonymized usage data like what languages you're using Zed with. "metrics": true }, + // Whether to disable all AI features in Zed. + // + // Default: false + "disable_ai": false, // Automatically update Zed. This setting may be ignored on Linux if // installed through a package manager. "auto_update": true, diff --git a/crates/agent_ui/Cargo.toml b/crates/agent_ui/Cargo.toml index 33042c0ebd..7d3b84e42e 100644 --- a/crates/agent_ui/Cargo.toml +++ b/crates/agent_ui/Cargo.toml @@ -32,6 +32,7 @@ buffer_diff.workspace = true chrono.workspace = true client.workspace = true collections.workspace = true +command_palette_hooks.workspace = true component.workspace = true context_server.workspace = true db.workspace = true diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index fc803c730e..7e9360a0cb 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -43,7 +43,7 @@ use anyhow::{Result, anyhow}; use assistant_context::{AssistantContext, ContextEvent, ContextSummary}; use assistant_slash_command::SlashCommandWorkingSet; use assistant_tool::ToolWorkingSet; -use client::{UserStore, zed_urls}; +use client::{DisableAiSettings, UserStore, zed_urls}; use editor::{Anchor, AnchorRangeExt as _, Editor, EditorEvent, MultiBuffer}; use feature_flags::{self, FeatureFlagAppExt}; use fs::Fs; @@ -744,6 +744,7 @@ impl AgentPanel { if workspace .panel::(cx) .is_some_and(|panel| panel.read(cx).enabled(cx)) + && !DisableAiSettings::get_global(cx).disable_ai { workspace.toggle_panel_focus::(window, cx); } @@ -1665,7 +1666,10 @@ impl Panel for AgentPanel { } fn icon(&self, _window: &Window, cx: &App) -> Option { - (self.enabled(cx) && AgentSettings::get_global(cx).button).then_some(IconName::ZedAssistant) + (self.enabled(cx) + && AgentSettings::get_global(cx).button + && !DisableAiSettings::get_global(cx).disable_ai) + .then_some(IconName::ZedAssistant) } fn icon_tooltip(&self, _window: &Window, _cx: &App) -> Option<&'static str> { diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rs index 7f69e8f66e..cac0f1adac 100644 --- a/crates/agent_ui/src/agent_ui.rs +++ b/crates/agent_ui/src/agent_ui.rs @@ -31,7 +31,8 @@ use std::sync::Arc; use agent::{Thread, ThreadId}; use agent_settings::{AgentProfileId, AgentSettings, LanguageModelSelection}; use assistant_slash_command::SlashCommandRegistry; -use client::Client; +use client::{Client, DisableAiSettings}; +use command_palette_hooks::CommandPaletteFilter; use feature_flags::FeatureFlagAppExt as _; use fs::Fs; use gpui::{Action, App, Entity, actions}; @@ -43,6 +44,7 @@ use prompt_store::PromptBuilder; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; use settings::{Settings as _, SettingsStore}; +use std::any::TypeId; pub use crate::active_thread::ActiveThread; use crate::agent_configuration::{ConfigureContextServerModal, ManageProfilesModal}; @@ -52,6 +54,7 @@ use crate::slash_command_settings::SlashCommandSettings; pub use agent_diff::{AgentDiffPane, AgentDiffToolbar}; pub use text_thread_editor::{AgentPanelDelegate, TextThreadEditor}; pub use ui::preview::{all_agent_previews, get_agent_preview}; +use zed_actions; actions!( agent, @@ -241,6 +244,66 @@ pub fn init( }) .detach(); cx.observe_new(ManageProfilesModal::register).detach(); + + // Update command palette filter based on AI settings + update_command_palette_filter(cx); + + // Watch for settings changes + cx.observe_global::(|app_cx| { + // When settings change, update the command palette filter + update_command_palette_filter(app_cx); + }) + .detach(); +} + +fn update_command_palette_filter(cx: &mut App) { + let disable_ai = DisableAiSettings::get_global(cx).disable_ai; + CommandPaletteFilter::update_global(cx, |filter, _| { + if disable_ai { + filter.hide_namespace("agent"); + filter.hide_namespace("assistant"); + filter.hide_namespace("zed_predict_onboarding"); + filter.hide_namespace("edit_prediction"); + + use editor::actions::{ + AcceptEditPrediction, AcceptPartialEditPrediction, NextEditPrediction, + PreviousEditPrediction, ShowEditPrediction, ToggleEditPrediction, + }; + let edit_prediction_actions = [ + TypeId::of::(), + TypeId::of::(), + TypeId::of::(), + TypeId::of::(), + TypeId::of::(), + TypeId::of::(), + ]; + filter.hide_action_types(&edit_prediction_actions); + filter.hide_action_types(&[TypeId::of::()]); + } else { + filter.show_namespace("agent"); + filter.show_namespace("assistant"); + filter.show_namespace("zed_predict_onboarding"); + + filter.show_namespace("edit_prediction"); + + use editor::actions::{ + AcceptEditPrediction, AcceptPartialEditPrediction, NextEditPrediction, + PreviousEditPrediction, ShowEditPrediction, ToggleEditPrediction, + }; + let edit_prediction_actions = [ + TypeId::of::(), + TypeId::of::(), + TypeId::of::(), + TypeId::of::(), + TypeId::of::(), + TypeId::of::(), + ]; + filter.show_action_types(edit_prediction_actions.iter()); + + filter + .show_action_types([TypeId::of::()].iter()); + } + }); } fn init_language_model_settings(cx: &mut App) { diff --git a/crates/agent_ui/src/inline_assistant.rs b/crates/agent_ui/src/inline_assistant.rs index 65b72cbba5..44ec050ae2 100644 --- a/crates/agent_ui/src/inline_assistant.rs +++ b/crates/agent_ui/src/inline_assistant.rs @@ -16,7 +16,7 @@ use agent::{ }; use agent_settings::AgentSettings; use anyhow::{Context as _, Result}; -use client::telemetry::Telemetry; +use client::{DisableAiSettings, telemetry::Telemetry}; use collections::{HashMap, HashSet, VecDeque, hash_map}; use editor::SelectionEffects; use editor::{ @@ -57,6 +57,17 @@ pub fn init( cx: &mut App, ) { cx.set_global(InlineAssistant::new(fs, prompt_builder, telemetry)); + + cx.observe_global::(|cx| { + if DisableAiSettings::get_global(cx).disable_ai { + // Hide any active inline assist UI when AI is disabled + InlineAssistant::update_global(cx, |assistant, cx| { + assistant.cancel_all_active_completions(cx); + }); + } + }) + .detach(); + cx.observe_new(|_workspace: &mut Workspace, window, cx| { let Some(window) = window else { return; @@ -141,6 +152,26 @@ impl InlineAssistant { .detach(); } + /// Hides all active inline assists when AI is disabled + pub fn cancel_all_active_completions(&mut self, cx: &mut App) { + // Cancel all active completions in editors + for (editor_handle, _) in self.assists_by_editor.iter() { + if let Some(editor) = editor_handle.upgrade() { + let windows = cx.windows(); + if !windows.is_empty() { + let window = windows[0]; + let _ = window.update(cx, |_, window, cx| { + editor.update(cx, |editor, cx| { + if editor.has_active_inline_completion() { + editor.cancel(&Default::default(), window, cx); + } + }); + }); + } + } + } + } + fn handle_workspace_event( &mut self, workspace: Entity, @@ -176,7 +207,7 @@ impl InlineAssistant { window: &mut Window, cx: &mut App, ) { - let is_assistant2_enabled = true; + let is_assistant2_enabled = !DisableAiSettings::get_global(cx).disable_ai; if let Some(editor) = item.act_as::(cx) { editor.update(cx, |editor, cx| { @@ -199,6 +230,13 @@ impl InlineAssistant { cx, ); + if DisableAiSettings::get_global(cx).disable_ai { + // Cancel any active completions + if editor.has_active_inline_completion() { + editor.cancel(&Default::default(), window, cx); + } + } + // Remove the Assistant1 code action provider, as it still might be registered. editor.remove_code_action_provider("assistant".into(), window, cx); } else { @@ -219,7 +257,7 @@ impl InlineAssistant { cx: &mut Context, ) { let settings = AgentSettings::get_global(cx); - if !settings.enabled { + if !settings.enabled || DisableAiSettings::get_global(cx).disable_ai { return; } diff --git a/crates/assistant_tools/Cargo.toml b/crates/assistant_tools/Cargo.toml index e234b62b14..146800e094 100644 --- a/crates/assistant_tools/Cargo.toml +++ b/crates/assistant_tools/Cargo.toml @@ -20,6 +20,7 @@ anyhow.workspace = true assistant_tool.workspace = true buffer_diff.workspace = true chrono.workspace = true +client.workspace = true collections.workspace = true component.workspace = true derive_more.workspace = true diff --git a/crates/assistant_tools/src/assistant_tools.rs b/crates/assistant_tools/src/assistant_tools.rs index eef792f526..57fdc51336 100644 --- a/crates/assistant_tools/src/assistant_tools.rs +++ b/crates/assistant_tools/src/assistant_tools.rs @@ -20,14 +20,13 @@ mod thinking_tool; mod ui; mod web_search_tool; -use std::sync::Arc; - use assistant_tool::ToolRegistry; use copy_path_tool::CopyPathTool; use gpui::{App, Entity}; use http_client::HttpClientWithUrl; use language_model::LanguageModelRegistry; use move_path_tool::MovePathTool; +use std::sync::Arc; use web_search_tool::WebSearchTool; pub(crate) use templates::*; diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs index 1be8ffdb55..81bb95b514 100644 --- a/crates/client/src/client.rs +++ b/crates/client/src/client.rs @@ -151,6 +151,7 @@ impl Settings for ProxySettings { pub fn init_settings(cx: &mut App) { TelemetrySettings::register(cx); + DisableAiSettings::register(cx); ClientSettings::register(cx); ProxySettings::register(cx); } @@ -548,6 +549,33 @@ impl settings::Settings for TelemetrySettings { } } +/// Whether to disable all AI features in Zed. +/// +/// Default: false +#[derive(Copy, Clone, Debug)] +pub struct DisableAiSettings { + pub disable_ai: bool, +} + +impl settings::Settings for DisableAiSettings { + const KEY: Option<&'static str> = Some("disable_ai"); + + type FileContent = Option; + + fn load(sources: SettingsSources, _: &mut App) -> Result { + Ok(Self { + disable_ai: sources + .user + .or(sources.server) + .copied() + .flatten() + .unwrap_or(sources.default.ok_or_else(Self::missing_default)?), + }) + } + + fn import_from_vscode(_vscode: &settings::VsCodeSettings, _current: &mut Self::FileContent) {} +} + impl Client { pub fn new( clock: Arc, diff --git a/crates/copilot/src/copilot.rs b/crates/copilot/src/copilot.rs index 1966d1a389..e11242cb15 100644 --- a/crates/copilot/src/copilot.rs +++ b/crates/copilot/src/copilot.rs @@ -6,6 +6,7 @@ mod sign_in; use crate::sign_in::initiate_sign_in_within_workspace; use ::fs::Fs; use anyhow::{Context as _, Result, anyhow}; +use client::DisableAiSettings; use collections::{HashMap, HashSet}; use command_palette_hooks::CommandPaletteFilter; use futures::{Future, FutureExt, TryFutureExt, channel::oneshot, future::Shared}; @@ -25,6 +26,7 @@ use node_runtime::NodeRuntime; use parking_lot::Mutex; use request::StatusNotification; use serde_json::json; +use settings::Settings; use settings::SettingsStore; use sign_in::{reinstall_and_sign_in_within_workspace, sign_out_within_workspace}; use std::collections::hash_map::Entry; @@ -93,26 +95,34 @@ pub fn init( let copilot_auth_action_types = [TypeId::of::()]; let copilot_no_auth_action_types = [TypeId::of::()]; let status = handle.read(cx).status(); + + let is_ai_disabled = DisableAiSettings::get_global(cx).disable_ai; let filter = CommandPaletteFilter::global_mut(cx); - match status { - Status::Disabled => { - filter.hide_action_types(&copilot_action_types); - filter.hide_action_types(&copilot_auth_action_types); - filter.hide_action_types(&copilot_no_auth_action_types); - } - Status::Authorized => { - filter.hide_action_types(&copilot_no_auth_action_types); - filter.show_action_types( - copilot_action_types - .iter() - .chain(&copilot_auth_action_types), - ); - } - _ => { - filter.hide_action_types(&copilot_action_types); - filter.hide_action_types(&copilot_auth_action_types); - filter.show_action_types(copilot_no_auth_action_types.iter()); + if is_ai_disabled { + filter.hide_action_types(&copilot_action_types); + filter.hide_action_types(&copilot_auth_action_types); + filter.hide_action_types(&copilot_no_auth_action_types); + } else { + match status { + Status::Disabled => { + filter.hide_action_types(&copilot_action_types); + filter.hide_action_types(&copilot_auth_action_types); + filter.hide_action_types(&copilot_no_auth_action_types); + } + Status::Authorized => { + filter.hide_action_types(&copilot_no_auth_action_types); + filter.show_action_types( + copilot_action_types + .iter() + .chain(&copilot_auth_action_types), + ); + } + _ => { + filter.hide_action_types(&copilot_action_types); + filter.hide_action_types(&copilot_auth_action_types); + filter.show_action_types(copilot_no_auth_action_types.iter()); + } } } }) diff --git a/crates/git_ui/Cargo.toml b/crates/git_ui/Cargo.toml index 6e04dcb656..2fb80b7e73 100644 --- a/crates/git_ui/Cargo.toml +++ b/crates/git_ui/Cargo.toml @@ -23,6 +23,7 @@ askpass.workspace = true buffer_diff.workspace = true call.workspace = true chrono.workspace = true +client.workspace = true collections.workspace = true command_palette_hooks.workspace = true component.workspace = true diff --git a/crates/git_ui/src/commit_modal.rs b/crates/git_ui/src/commit_modal.rs index ac3d24e3eb..b99f628806 100644 --- a/crates/git_ui/src/commit_modal.rs +++ b/crates/git_ui/src/commit_modal.rs @@ -1,8 +1,10 @@ use crate::branch_picker::{self, BranchList}; use crate::git_panel::{GitPanel, commit_message_editor}; +use client::DisableAiSettings; use git::repository::CommitOptions; use git::{Amend, Commit, GenerateCommitMessage, Signoff}; use panel::{panel_button, panel_editor_style}; +use settings::Settings; use ui::{ ContextMenu, KeybindingHint, PopoverMenu, PopoverMenuHandle, SplitButton, Tooltip, prelude::*, }; @@ -569,11 +571,13 @@ impl Render for CommitModal { .on_action(cx.listener(Self::dismiss)) .on_action(cx.listener(Self::commit)) .on_action(cx.listener(Self::amend)) - .on_action(cx.listener(|this, _: &GenerateCommitMessage, _, cx| { - this.git_panel.update(cx, |panel, cx| { - panel.generate_commit_message(cx); - }) - })) + .when(!DisableAiSettings::get_global(cx).disable_ai, |this| { + this.on_action(cx.listener(|this, _: &GenerateCommitMessage, _, cx| { + this.git_panel.update(cx, |panel, cx| { + panel.generate_commit_message(cx); + }) + })) + }) .on_action( cx.listener(|this, _: &zed_actions::git::Branch, window, cx| { this.toggle_branch_selector(window, cx); diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index e998586af4..061833a6c7 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -12,6 +12,7 @@ use crate::{ use agent_settings::AgentSettings; use anyhow::Context as _; use askpass::AskPassDelegate; +use client::DisableAiSettings; use db::kvp::KEY_VALUE_STORE; use editor::{ Editor, EditorElement, EditorMode, EditorSettings, MultiBuffer, ShowScrollbar, @@ -53,7 +54,7 @@ use project::{ git_store::{GitStoreEvent, Repository}, }; use serde::{Deserialize, Serialize}; -use settings::{Settings as _, SettingsStore}; +use settings::{Settings, SettingsStore}; use std::future::Future; use std::ops::Range; use std::path::{Path, PathBuf}; @@ -464,9 +465,14 @@ impl GitPanel { }; let mut assistant_enabled = AgentSettings::get_global(cx).enabled; + let mut was_ai_disabled = DisableAiSettings::get_global(cx).disable_ai; let _settings_subscription = cx.observe_global::(move |_, cx| { - if assistant_enabled != AgentSettings::get_global(cx).enabled { + let is_ai_disabled = DisableAiSettings::get_global(cx).disable_ai; + if assistant_enabled != AgentSettings::get_global(cx).enabled + || was_ai_disabled != is_ai_disabled + { assistant_enabled = AgentSettings::get_global(cx).enabled; + was_ai_disabled = is_ai_disabled; cx.notify(); } }); @@ -1806,7 +1812,7 @@ impl GitPanel { /// Generates a commit message using an LLM. pub fn generate_commit_message(&mut self, cx: &mut Context) { - if !self.can_commit() { + if !self.can_commit() || DisableAiSettings::get_global(cx).disable_ai { return; } @@ -4305,8 +4311,10 @@ impl GitPanel { } fn current_language_model(cx: &Context<'_, GitPanel>) -> Option> { - agent_settings::AgentSettings::get_global(cx) - .enabled + let is_enabled = agent_settings::AgentSettings::get_global(cx).enabled + && !DisableAiSettings::get_global(cx).disable_ai; + + is_enabled .then(|| { let ConfiguredModel { provider, model } = LanguageModelRegistry::read_global(cx).commit_message_model()?; @@ -5037,6 +5045,7 @@ mod tests { language::init(cx); editor::init(cx); Project::init_settings(cx); + client::DisableAiSettings::register(cx); crate::init(cx); }); } diff --git a/crates/inline_completion_button/src/inline_completion_button.rs b/crates/inline_completion_button/src/inline_completion_button.rs index 8a8eacdc6a..2615a8beef 100644 --- a/crates/inline_completion_button/src/inline_completion_button.rs +++ b/crates/inline_completion_button/src/inline_completion_button.rs @@ -1,5 +1,5 @@ use anyhow::Result; -use client::{UserStore, zed_urls}; +use client::{DisableAiSettings, UserStore, zed_urls}; use copilot::{Copilot, Status}; use editor::{ Editor, SelectionEffects, @@ -72,6 +72,11 @@ enum SupermavenButtonStatus { impl Render for InlineCompletionButton { fn render(&mut self, _: &mut Window, cx: &mut Context) -> impl IntoElement { + // Return empty div if AI is disabled + if DisableAiSettings::get_global(cx).disable_ai { + return div(); + } + let all_language_settings = all_language_settings(None, cx); match all_language_settings.edit_predictions.provider { diff --git a/crates/welcome/src/welcome.rs b/crates/welcome/src/welcome.rs index ea4ac13de7..49bf2031ab 100644 --- a/crates/welcome/src/welcome.rs +++ b/crates/welcome/src/welcome.rs @@ -1,4 +1,4 @@ -use client::{TelemetrySettings, telemetry::Telemetry}; +use client::{DisableAiSettings, TelemetrySettings, telemetry::Telemetry}; use db::kvp::KEY_VALUE_STORE; use gpui::{ Action, App, Context, Entity, EventEmitter, FocusHandle, Focusable, InteractiveElement, @@ -174,23 +174,25 @@ impl Render for WelcomePage { .ok(); })), ) - .child( - Button::new( - "try-zed-edit-prediction", - edit_prediction_label, + .when(!DisableAiSettings::get_global(cx).disable_ai, |parent| { + parent.child( + Button::new( + "edit_prediction_onboarding", + edit_prediction_label, + ) + .disabled(edit_prediction_provider_is_zed) + .icon(IconName::ZedPredict) + .icon_size(IconSize::XSmall) + .icon_color(Color::Muted) + .icon_position(IconPosition::Start) + .on_click( + cx.listener(|_, _, window, cx| { + telemetry::event!("Welcome Screen Try Edit Prediction clicked"); + window.dispatch_action(zed_actions::OpenZedPredictOnboarding.boxed_clone(), cx); + }), + ), ) - .disabled(edit_prediction_provider_is_zed) - .icon(IconName::ZedPredict) - .icon_size(IconSize::XSmall) - .icon_color(Color::Muted) - .icon_position(IconPosition::Start) - .on_click( - cx.listener(|_, _, window, cx| { - telemetry::event!("Welcome Screen Try Edit Prediction clicked"); - window.dispatch_action(zed_actions::OpenZedPredictOnboarding.boxed_clone(), cx); - }), - ), - ) + }) .child( Button::new("edit settings", "Edit Settings") .icon(IconName::Settings) diff --git a/crates/workspace/src/dock.rs b/crates/workspace/src/dock.rs index 4e39c2d182..3f047e2f11 100644 --- a/crates/workspace/src/dock.rs +++ b/crates/workspace/src/dock.rs @@ -242,6 +242,7 @@ struct PanelEntry { pub struct PanelButtons { dock: Entity, + _settings_subscription: Subscription, } impl Dock { @@ -373,6 +374,12 @@ impl Dock { }) } + pub fn first_enabled_panel_idx_excluding(&self, exclude_name: &str, cx: &App) -> Option { + self.panel_entries.iter().position(|entry| { + entry.panel.persistent_name() != exclude_name && entry.panel.enabled(cx) + }) + } + fn active_panel_entry(&self) -> Option<&PanelEntry> { self.active_panel_index .and_then(|index| self.panel_entries.get(index)) @@ -833,7 +840,11 @@ impl Render for Dock { impl PanelButtons { pub fn new(dock: Entity, cx: &mut Context) -> Self { cx.observe(&dock, |_, _, cx| cx.notify()).detach(); - Self { dock } + let settings_subscription = cx.observe_global::(|_, cx| cx.notify()); + Self { + dock, + _settings_subscription: settings_subscription, + } } } diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs index c9b8eebff6..d0b9c53397 100644 --- a/crates/zed/src/main.rs +++ b/crates/zed/src/main.rs @@ -554,6 +554,7 @@ pub fn main() { supermaven::init(app_state.client.clone(), cx); language_model::init(app_state.client.clone(), cx); language_models::init(app_state.user_store.clone(), app_state.client.clone(), cx); + agent_settings::init(cx); agent_servers::init(cx); web_search::init(cx); web_search_providers::init(app_state.client.clone(), cx); diff --git a/crates/zed/src/zed/quick_action_bar.rs b/crates/zed/src/zed/quick_action_bar.rs index c95d86c84f..aff124a0bc 100644 --- a/crates/zed/src/zed/quick_action_bar.rs +++ b/crates/zed/src/zed/quick_action_bar.rs @@ -2,6 +2,7 @@ mod preview; mod repl_menu; use agent_settings::AgentSettings; +use client::DisableAiSettings; use editor::actions::{ AddSelectionAbove, AddSelectionBelow, CodeActionSource, DuplicateLineDown, GoToDiagnostic, GoToHunk, GoToPreviousDiagnostic, GoToPreviousHunk, MoveLineDown, MoveLineUp, SelectAll, @@ -32,6 +33,7 @@ const MAX_CODE_ACTION_MENU_LINES: u32 = 16; pub struct QuickActionBar { _inlay_hints_enabled_subscription: Option, + _ai_settings_subscription: Subscription, active_item: Option>, buffer_search_bar: Entity, show: bool, @@ -46,8 +48,28 @@ impl QuickActionBar { workspace: &Workspace, cx: &mut Context, ) -> Self { + let mut was_ai_disabled = DisableAiSettings::get_global(cx).disable_ai; + let mut was_agent_enabled = AgentSettings::get_global(cx).enabled; + let mut was_agent_button = AgentSettings::get_global(cx).button; + + let ai_settings_subscription = cx.observe_global::(move |_, cx| { + let is_ai_disabled = DisableAiSettings::get_global(cx).disable_ai; + let agent_settings = AgentSettings::get_global(cx); + + if was_ai_disabled != is_ai_disabled + || was_agent_enabled != agent_settings.enabled + || was_agent_button != agent_settings.button + { + was_ai_disabled = is_ai_disabled; + was_agent_enabled = agent_settings.enabled; + was_agent_button = agent_settings.button; + cx.notify(); + } + }); + let mut this = Self { _inlay_hints_enabled_subscription: None, + _ai_settings_subscription: ai_settings_subscription, active_item: None, buffer_search_bar, show: true, @@ -575,7 +597,9 @@ impl Render for QuickActionBar { .children(self.render_preview_button(self.workspace.clone(), cx)) .children(search_button) .when( - AgentSettings::get_global(cx).enabled && AgentSettings::get_global(cx).button, + AgentSettings::get_global(cx).enabled + && AgentSettings::get_global(cx).button + && !DisableAiSettings::get_global(cx).disable_ai, |bar| bar.child(assistant_button), ) .children(code_actions_dropdown) diff --git a/crates/zeta/src/init.rs b/crates/zeta/src/init.rs index 4bcd50df88..4a65771223 100644 --- a/crates/zeta/src/init.rs +++ b/crates/zeta/src/init.rs @@ -1,10 +1,11 @@ use std::any::{Any, TypeId}; +use client::DisableAiSettings; use command_palette_hooks::CommandPaletteFilter; use feature_flags::{FeatureFlagAppExt as _, PredictEditsRateCompletionsFeatureFlag}; use gpui::actions; use language::language_settings::{AllLanguageSettings, EditPredictionProvider}; -use settings::update_settings_file; +use settings::{Settings, SettingsStore, update_settings_file}; use ui::App; use workspace::Workspace; @@ -21,6 +22,8 @@ actions!( ); pub fn init(cx: &mut App) { + feature_gate_predict_edits_actions(cx); + cx.observe_new(move |workspace: &mut Workspace, _, _cx| { workspace.register_action(|workspace, _: &RateCompletions, window, cx| { if cx.has_flag::() { @@ -53,27 +56,57 @@ pub fn init(cx: &mut App) { }); }) .detach(); - - feature_gate_predict_edits_rating_actions(cx); } -fn feature_gate_predict_edits_rating_actions(cx: &mut App) { +fn feature_gate_predict_edits_actions(cx: &mut App) { let rate_completion_action_types = [TypeId::of::()]; + let reset_onboarding_action_types = [TypeId::of::()]; + let zeta_all_action_types = [ + TypeId::of::(), + TypeId::of::(), + zed_actions::OpenZedPredictOnboarding.type_id(), + TypeId::of::(), + TypeId::of::(), + TypeId::of::(), + TypeId::of::(), + TypeId::of::(), + ]; CommandPaletteFilter::update_global(cx, |filter, _cx| { filter.hide_action_types(&rate_completion_action_types); + filter.hide_action_types(&reset_onboarding_action_types); filter.hide_action_types(&[zed_actions::OpenZedPredictOnboarding.type_id()]); }); + cx.observe_global::(move |cx| { + let is_ai_disabled = DisableAiSettings::get_global(cx).disable_ai; + let has_feature_flag = cx.has_flag::(); + + CommandPaletteFilter::update_global(cx, |filter, _cx| { + if is_ai_disabled { + filter.hide_action_types(&zeta_all_action_types); + } else { + if has_feature_flag { + filter.show_action_types(rate_completion_action_types.iter()); + } else { + filter.hide_action_types(&rate_completion_action_types); + } + } + }); + }) + .detach(); + cx.observe_flag::(move |is_enabled, cx| { - if is_enabled { - CommandPaletteFilter::update_global(cx, |filter, _cx| { - filter.show_action_types(rate_completion_action_types.iter()); - }); - } else { - CommandPaletteFilter::update_global(cx, |filter, _cx| { - filter.hide_action_types(&rate_completion_action_types); - }); + if !DisableAiSettings::get_global(cx).disable_ai { + if is_enabled { + CommandPaletteFilter::update_global(cx, |filter, _cx| { + filter.show_action_types(rate_completion_action_types.iter()); + }); + } else { + CommandPaletteFilter::update_global(cx, |filter, _cx| { + filter.hide_action_types(&rate_completion_action_types); + }); + } } }) .detach(); From 2b888e1d30c5f1876cedd1ddac18bb050a568ae2 Mon Sep 17 00:00:00 2001 From: Ben Kunkle Date: Tue, 22 Jul 2025 10:45:42 -0500 Subject: [PATCH 0125/1052] Fix redo after noop format (#34898) Closes #31917 Previously, as of #28457 we used a hack, creating an empty transaction in the history that we then merged formatting changes into in order to correctly identify concurrent edits to the buffer while formatting was happening. This caused issues with noop formatting however, as using the normal API of the buffer history (in an albeit weird way) resulted in the redo stack being cleared, regardless of whether the formatting transaction included edits or not, which is the correct behavior in all other contexts. This PR fixes the redo issue by codifying the behavior formatting wants, that being the ability to push an empty transaction to the history with no other side-effects (i.e. clearing the redo stack) to detect concurrent edits, with the tradeoff being that it must then manually remove the transaction later if no changes occurred from the formatting. The redo stack is still cleared when there are formatting edits, as the individual format steps use the normal `{start,end}_transaction` methods which clear the redo stack if the finished transaction isn't empty. Release Notes: - Fixed an issue where redo would not work after buffer formatting (including formatting on save) when the formatting did not result in any changes --- crates/editor/src/editor_tests.rs | 70 ++++++++++++++++++++++++++++++- crates/language/src/buffer.rs | 15 +++++++ crates/project/src/lsp_store.rs | 8 +--- crates/text/src/text.rs | 52 ++++++++++++++++++++++- 4 files changed, 137 insertions(+), 8 deletions(-) diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index 4efb052c71..fbb877796c 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -9570,6 +9570,74 @@ async fn test_document_format_during_save(cx: &mut TestAppContext) { } } +#[gpui::test] +async fn test_redo_after_noop_format(cx: &mut TestAppContext) { + init_test(cx, |settings| { + settings.defaults.ensure_final_newline_on_save = Some(false); + }); + + let fs = FakeFs::new(cx.executor()); + fs.insert_file(path!("/file.txt"), "foo".into()).await; + + let project = Project::test(fs, [path!("/file.txt").as_ref()], cx).await; + + let buffer = project + .update(cx, |project, cx| { + project.open_local_buffer(path!("/file.txt"), cx) + }) + .await + .unwrap(); + + let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx)); + let (editor, cx) = cx.add_window_view(|window, cx| { + build_editor_with_project(project.clone(), buffer, window, cx) + }); + editor.update_in(cx, |editor, window, cx| { + editor.change_selections(SelectionEffects::default(), window, cx, |s| { + s.select_ranges([0..0]) + }); + }); + assert!(!cx.read(|cx| editor.is_dirty(cx))); + + editor.update_in(cx, |editor, window, cx| { + editor.handle_input("\n", window, cx) + }); + cx.run_until_parked(); + save(&editor, &project, cx).await; + assert_eq!("\nfoo", editor.read_with(cx, |editor, cx| editor.text(cx))); + + editor.update_in(cx, |editor, window, cx| { + editor.undo(&Default::default(), window, cx); + }); + save(&editor, &project, cx).await; + assert_eq!("foo", editor.read_with(cx, |editor, cx| editor.text(cx))); + + editor.update_in(cx, |editor, window, cx| { + editor.redo(&Default::default(), window, cx); + }); + cx.run_until_parked(); + assert_eq!("\nfoo", editor.read_with(cx, |editor, cx| editor.text(cx))); + + async fn save(editor: &Entity, project: &Entity, cx: &mut VisualTestContext) { + let save = editor + .update_in(cx, |editor, window, cx| { + editor.save( + SaveOptions { + format: true, + autosave: false, + }, + project.clone(), + window, + cx, + ) + }) + .unwrap(); + cx.executor().start_waiting(); + save.await; + assert!(!cx.read(|cx| editor.is_dirty(cx))); + } +} + #[gpui::test] async fn test_multibuffer_format_during_save(cx: &mut TestAppContext) { init_test(cx, |_| {}); @@ -22708,7 +22776,7 @@ pub(crate) fn init_test(cx: &mut TestAppContext, f: fn(&mut AllLanguageSettingsC workspace::init_settings(cx); crate::init(cx); }); - + zlog::init_test(); update_test_language_settings(cx, f); } diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs index 59aa63ff38..83517accc2 100644 --- a/crates/language/src/buffer.rs +++ b/crates/language/src/buffer.rs @@ -2072,6 +2072,21 @@ impl Buffer { self.text.push_transaction(transaction, now); } + /// Differs from `push_transaction` in that it does not clear the redo + /// stack. Intended to be used to create a parent transaction to merge + /// potential child transactions into. + /// + /// The caller is responsible for removing it from the undo history using + /// `forget_transaction` if no edits are merged into it. Otherwise, if edits + /// are merged into this transaction, the caller is responsible for ensuring + /// the redo stack is cleared. The easiest way to ensure the redo stack is + /// cleared is to create transactions with the usual `start_transaction` and + /// `end_transaction` methods and merging the resulting transactions into + /// the transaction created by this method + pub fn push_empty_transaction(&mut self, now: Instant) -> TransactionId { + self.text.push_empty_transaction(now) + } + /// Prevent the last transaction from being grouped with any subsequent transactions, /// even if they occur with the buffer's undo grouping duration. pub fn finalize_last_transaction(&mut self) -> Option<&Transaction> { diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs index 28cbfcdd18..0cd375e0c5 100644 --- a/crates/project/src/lsp_store.rs +++ b/crates/project/src/lsp_store.rs @@ -1274,15 +1274,11 @@ impl LocalLspStore { // grouped with the previous transaction in the history // based on the transaction group interval buffer.finalize_last_transaction(); - let transaction_id = buffer + buffer .start_transaction() .context("transaction already open")?; - let transaction = buffer - .get_transaction(transaction_id) - .expect("transaction started") - .clone(); buffer.end_transaction(cx); - buffer.push_transaction(transaction, cx.background_executor().now()); + let transaction_id = buffer.push_empty_transaction(cx.background_executor().now()); buffer.finalize_last_transaction(); anyhow::Ok(transaction_id) })??; diff --git a/crates/text/src/text.rs b/crates/text/src/text.rs index a2742081f4..aa9682029e 100644 --- a/crates/text/src/text.rs +++ b/crates/text/src/text.rs @@ -320,7 +320,39 @@ impl History { last_edit_at: now, suppress_grouping: false, }); - self.redo_stack.clear(); + } + + /// Differs from `push_transaction` in that it does not clear the redo + /// stack. Intended to be used to create a parent transaction to merge + /// potential child transactions into. + /// + /// The caller is responsible for removing it from the undo history using + /// `forget_transaction` if no edits are merged into it. Otherwise, if edits + /// are merged into this transaction, the caller is responsible for ensuring + /// the redo stack is cleared. The easiest way to ensure the redo stack is + /// cleared is to create transactions with the usual `start_transaction` and + /// `end_transaction` methods and merging the resulting transactions into + /// the transaction created by this method + fn push_empty_transaction( + &mut self, + start: clock::Global, + now: Instant, + clock: &mut clock::Lamport, + ) -> TransactionId { + assert_eq!(self.transaction_depth, 0); + let id = clock.tick(); + let transaction = Transaction { + id, + start, + edit_ids: Vec::new(), + }; + self.undo_stack.push(HistoryEntry { + transaction, + first_edit_at: now, + last_edit_at: now, + suppress_grouping: false, + }); + id } fn push_undo(&mut self, op_id: clock::Lamport) { @@ -1495,6 +1527,24 @@ impl Buffer { self.history.push_transaction(transaction, now); } + /// Differs from `push_transaction` in that it does not clear the redo stack. + /// The caller responsible for + /// Differs from `push_transaction` in that it does not clear the redo + /// stack. Intended to be used to create a parent transaction to merge + /// potential child transactions into. + /// + /// The caller is responsible for removing it from the undo history using + /// `forget_transaction` if no edits are merged into it. Otherwise, if edits + /// are merged into this transaction, the caller is responsible for ensuring + /// the redo stack is cleared. The easiest way to ensure the redo stack is + /// cleared is to create transactions with the usual `start_transaction` and + /// `end_transaction` methods and merging the resulting transactions into + /// the transaction created by this method + pub fn push_empty_transaction(&mut self, now: Instant) -> TransactionId { + self.history + .push_empty_transaction(self.version.clone(), now, &mut self.lamport_clock) + } + pub fn edited_ranges_for_transaction_id( &self, transaction_id: TransactionId, From 56b99f49fdbba2fe87e4693a646e88a613fdadc0 Mon Sep 17 00:00:00 2001 From: tiagoq <47694386+tiagoq@users.noreply.github.com> Date: Tue, 22 Jul 2025 11:55:24 -0400 Subject: [PATCH 0126/1052] bedrock: Fix remaining streaming delays (#33931) Closes #26030 *Note: This is my first contribution to Zed* This addresses a second streaming bottleneck in Bedrock that remained after the initial fix in #28281 (released in preview 194). The issue is in the mechanism used to convert Zed's internal `AsyncBody` into the `SdkBody` expected by the Bedrock language provider. We are using a non-streaming converter that buffers responses. **How the fix works:** The AWS SDK provides streaming-compatible converters to create `SdkBody` instances, but these require the input body to implement the `Body` trait from the `http-body` crate. This PR enables streaming by implementing the required trait and switching to the streaming-compatible converter. **Changes (2 commits):** * 1st Commit - **Implement http-body Body trait for AsyncBody:** - Add `http-body = 1.0` dependency (already an indirect dependency) - Implement the `Body` trait for our existing `AsyncBody` type - Uses `poll_frame` to read data chunks asynchronously, preserving streaming behavior * 2nd Commit - **Use streaming-compatible AWS SDK converter:** - Create `SdkBody` using `SdkBody::from_body_1_x()` with the new `Body` trait implementation **Details/FAQ:** **Q: Why add another dependency?** A: We tried to avoid adding a dependency, but the AWS SDK requires the `Body` trait and `http-body` is where it's defined. The crate is already an indirect dependency, making this a reasonable solution. **Q: Why modify the shared `http_client` crate instead of just `aws_bedrock_client`?** A: We considered implementing the `Body` trait on a wrapper in `aws_bedrock_client`, but since `AsyncBody` already uses `http` crate types, extending support to the companion `http-body` crate seems reasonable and may benefit other integrations. **Q: How was this bottleneck discovered?** A: After @5herlocked's initial streaming fix in #28281, I tested preview 194 and noticed streaming still had issues. I found a way to reproduce the problem and chatted with @5herlocked about it. He immediately pinpointed the exact location where the issue was occurring, his diagnosis made this fix possible. **Q: How does this relate to the previous fix?** A: #28281 fixed buffering issues higher in the stack, but unfortunately there was another bottleneck lower-down in the aws-http-client. This PR addresses that separate buffering issue. **Q: Does this use zero-copy or one-copy?** A: The `Body` implementation includes one copy. Someone more knowledgeable might be able to achieve a zero-copy approach, but we opted for a conservative approach. The performance impact should not be perceptible in typical usage. **Testing:** Confirmed that Bedrock streaming now works without buffering delays in a local build. Release Notes: - Improved Bedrock streaming by eliminating response buffering delays --------- Co-authored-by: Marshall Bowers --- Cargo.lock | 3 +- Cargo.toml | 1 + crates/aws_http_client/Cargo.toml | 2 - crates/aws_http_client/src/aws_http_client.rs | 39 +++++-------------- crates/http_client/Cargo.toml | 1 + crates/http_client/src/async_body.rs | 22 +++++++++++ .../language_models/src/provider/bedrock.rs | 8 +--- 7 files changed, 36 insertions(+), 40 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 6237bac204..c64995b01b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1872,9 +1872,7 @@ version = "0.1.0" dependencies = [ "aws-smithy-runtime-api", "aws-smithy-types", - "futures 0.3.31", "http_client", - "tokio", "workspace-hack", ] @@ -7857,6 +7855,7 @@ dependencies = [ "derive_more 0.99.19", "futures 0.3.31", "http 1.3.1", + "http-body 1.0.1", "log", "serde", "serde_json", diff --git a/Cargo.toml b/Cargo.toml index ea8690f2b3..ec793a7429 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -482,6 +482,7 @@ heed = { version = "0.21.0", features = ["read-txn-no-tls"] } hex = "0.4.3" html5ever = "0.27.0" http = "1.1" +http-body = "1.0" hyper = "0.14" ignore = "0.4.22" image = "0.25.1" diff --git a/crates/aws_http_client/Cargo.toml b/crates/aws_http_client/Cargo.toml index 3760f70fe0..2749286d4c 100644 --- a/crates/aws_http_client/Cargo.toml +++ b/crates/aws_http_client/Cargo.toml @@ -17,7 +17,5 @@ default = [] [dependencies] aws-smithy-runtime-api.workspace = true aws-smithy-types.workspace = true -futures.workspace = true http_client.workspace = true -tokio = { workspace = true, features = ["rt", "rt-multi-thread"] } workspace-hack.workspace = true diff --git a/crates/aws_http_client/src/aws_http_client.rs b/crates/aws_http_client/src/aws_http_client.rs index 6adb995747..d08c8e64a7 100644 --- a/crates/aws_http_client/src/aws_http_client.rs +++ b/crates/aws_http_client/src/aws_http_client.rs @@ -11,14 +11,11 @@ use aws_smithy_runtime_api::client::result::ConnectorError; use aws_smithy_runtime_api::client::runtime_components::RuntimeComponents; use aws_smithy_runtime_api::http::{Headers, StatusCode}; use aws_smithy_types::body::SdkBody; -use futures::AsyncReadExt; -use http_client::{AsyncBody, Inner}; +use http_client::AsyncBody; use http_client::{HttpClient, Request}; -use tokio::runtime::Handle; struct AwsHttpConnector { client: Arc, - handle: Handle, } impl std::fmt::Debug for AwsHttpConnector { @@ -42,18 +39,17 @@ impl AwsConnector for AwsHttpConnector { .client .send(Request::from_parts(parts, convert_to_async_body(body))); - let handle = self.handle.clone(); - HttpConnectorFuture::new(async move { let response = match response.await { Ok(response) => response, Err(err) => return Err(ConnectorError::other(err.into(), None)), }; let (parts, body) = response.into_parts(); - let body = convert_to_sdk_body(body, handle).await; - let mut response = - HttpResponse::new(StatusCode::try_from(parts.status.as_u16()).unwrap(), body); + let mut response = HttpResponse::new( + StatusCode::try_from(parts.status.as_u16()).unwrap(), + convert_to_sdk_body(body), + ); let headers = match Headers::try_from(parts.headers) { Ok(headers) => headers, @@ -70,7 +66,6 @@ impl AwsConnector for AwsHttpConnector { #[derive(Clone)] pub struct AwsHttpClient { client: Arc, - handler: Handle, } impl std::fmt::Debug for AwsHttpClient { @@ -80,11 +75,8 @@ impl std::fmt::Debug for AwsHttpClient { } impl AwsHttpClient { - pub fn new(client: Arc, handle: Handle) -> Self { - Self { - client, - handler: handle, - } + pub fn new(client: Arc) -> Self { + Self { client } } } @@ -96,25 +88,12 @@ impl AwsClient for AwsHttpClient { ) -> SharedHttpConnector { SharedHttpConnector::new(AwsHttpConnector { client: self.client.clone(), - handle: self.handler.clone(), }) } } -pub async fn convert_to_sdk_body(body: AsyncBody, handle: Handle) -> SdkBody { - match body.0 { - Inner::Empty => SdkBody::empty(), - Inner::Bytes(bytes) => SdkBody::from(bytes.into_inner()), - Inner::AsyncReader(mut reader) => { - let buffer = handle.spawn(async move { - let mut buffer = Vec::new(); - let _ = reader.read_to_end(&mut buffer).await; - buffer - }); - - SdkBody::from(buffer.await.unwrap_or_default()) - } - } +pub fn convert_to_sdk_body(body: AsyncBody) -> SdkBody { + SdkBody::from_body_1_x(body) } pub fn convert_to_async_body(body: SdkBody) -> AsyncBody { diff --git a/crates/http_client/Cargo.toml b/crates/http_client/Cargo.toml index 2b114f240a..2045708ff2 100644 --- a/crates/http_client/Cargo.toml +++ b/crates/http_client/Cargo.toml @@ -21,6 +21,7 @@ anyhow.workspace = true derive_more.workspace = true futures.workspace = true http.workspace = true +http-body.workspace = true log.workspace = true serde.workspace = true serde_json.workspace = true diff --git a/crates/http_client/src/async_body.rs b/crates/http_client/src/async_body.rs index caf8089d0f..88972d279c 100644 --- a/crates/http_client/src/async_body.rs +++ b/crates/http_client/src/async_body.rs @@ -6,6 +6,7 @@ use std::{ use bytes::Bytes; use futures::AsyncRead; +use http_body::{Body, Frame}; /// Based on the implementation of AsyncBody in /// . @@ -114,3 +115,24 @@ impl futures::AsyncRead for AsyncBody { } } } + +impl Body for AsyncBody { + type Data = Bytes; + type Error = std::io::Error; + + fn poll_frame( + mut self: Pin<&mut Self>, + cx: &mut std::task::Context<'_>, + ) -> Poll, Self::Error>>> { + let mut buffer = vec![0; 8192]; + match AsyncRead::poll_read(self.as_mut(), cx, &mut buffer) { + Poll::Ready(Ok(0)) => Poll::Ready(None), + Poll::Ready(Ok(n)) => { + let data = Bytes::copy_from_slice(&buffer[..n]); + Poll::Ready(Some(Ok(Frame::data(data)))) + } + Poll::Ready(Err(e)) => Poll::Ready(Some(Err(e))), + Poll::Pending => Poll::Pending, + } + } +} diff --git a/crates/language_models/src/provider/bedrock.rs b/crates/language_models/src/provider/bedrock.rs index 65ce1dbc4b..a022511b11 100644 --- a/crates/language_models/src/provider/bedrock.rs +++ b/crates/language_models/src/provider/bedrock.rs @@ -258,13 +258,9 @@ impl BedrockLanguageModelProvider { }), }); - let tokio_handle = Tokio::handle(cx); - - let coerced_client = AwsHttpClient::new(http_client.clone(), tokio_handle.clone()); - Self { - http_client: coerced_client, - handler: tokio_handle.clone(), + http_client: AwsHttpClient::new(http_client.clone()), + handler: Tokio::handle(cx), state, } } From fa3e1ccc37373777756283829d180e41e63f8d1a Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Tue, 22 Jul 2025 18:19:51 +0200 Subject: [PATCH 0127/1052] chore: Bump taffy to 0.8.3 (#34876) That's the latest release. Note that we have an opportunity to simplify our size types per https://github.com/DioxusLabs/taffy/blob/main/CHANGELOG.md#highlights-1 (though that's left out of this PR) image Release Notes: - N/A --- Cargo.lock | 9 ++++----- crates/gpui/Cargo.toml | 2 +- crates/gpui/src/taffy.rs | 26 +++++++++++++------------- 3 files changed, 18 insertions(+), 19 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index c64995b01b..08d29cdc80 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7401,9 +7401,9 @@ dependencies = [ [[package]] name = "grid" -version = "0.14.0" +version = "0.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be136d9dacc2a13cc70bb6c8f902b414fb2641f8db1314637c6b7933411a8f82" +checksum = "71b01d27060ad58be4663b9e4ac9e2d4806918e8876af8912afbddd1a91d5eaa" [[package]] name = "group" @@ -15958,13 +15958,12 @@ dependencies = [ [[package]] name = "taffy" -version = "0.5.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8b61630cba2afd2c851821add2e1bb1b7851a2436e839ab73b56558b009035e" +checksum = "7aaef0ac998e6527d6d0d5582f7e43953bb17221ac75bb8eb2fcc2db3396db1c" dependencies = [ "arrayvec", "grid", - "num-traits", "serde", "slotmap", ] diff --git a/crates/gpui/Cargo.toml b/crates/gpui/Cargo.toml index 878794647a..68c0ea89c7 100644 --- a/crates/gpui/Cargo.toml +++ b/crates/gpui/Cargo.toml @@ -121,7 +121,7 @@ smallvec.workspace = true smol.workspace = true strum.workspace = true sum_tree.workspace = true -taffy = "=0.5.1" +taffy = "=0.8.3" thiserror.workspace = true util.workspace = true uuid.workspace = true diff --git a/crates/gpui/src/taffy.rs b/crates/gpui/src/taffy.rs index 6228a60490..f7fa54256d 100644 --- a/crates/gpui/src/taffy.rs +++ b/crates/gpui/src/taffy.rs @@ -283,7 +283,7 @@ impl ToTaffy for Length { fn to_taffy(&self, rem_size: Pixels) -> taffy::prelude::LengthPercentageAuto { match self { Length::Definite(length) => length.to_taffy(rem_size), - Length::Auto => taffy::prelude::LengthPercentageAuto::Auto, + Length::Auto => taffy::prelude::LengthPercentageAuto::auto(), } } } @@ -292,7 +292,7 @@ impl ToTaffy for Length { fn to_taffy(&self, rem_size: Pixels) -> taffy::prelude::Dimension { match self { Length::Definite(length) => length.to_taffy(rem_size), - Length::Auto => taffy::prelude::Dimension::Auto, + Length::Auto => taffy::prelude::Dimension::auto(), } } } @@ -302,14 +302,14 @@ impl ToTaffy for DefiniteLength { match self { DefiniteLength::Absolute(length) => match length { AbsoluteLength::Pixels(pixels) => { - taffy::style::LengthPercentage::Length(pixels.into()) + taffy::style::LengthPercentage::length(pixels.into()) } AbsoluteLength::Rems(rems) => { - taffy::style::LengthPercentage::Length((*rems * rem_size).into()) + taffy::style::LengthPercentage::length((*rems * rem_size).into()) } }, DefiniteLength::Fraction(fraction) => { - taffy::style::LengthPercentage::Percent(*fraction) + taffy::style::LengthPercentage::percent(*fraction) } } } @@ -320,14 +320,14 @@ impl ToTaffy for DefiniteLength { match self { DefiniteLength::Absolute(length) => match length { AbsoluteLength::Pixels(pixels) => { - taffy::style::LengthPercentageAuto::Length(pixels.into()) + taffy::style::LengthPercentageAuto::length(pixels.into()) } AbsoluteLength::Rems(rems) => { - taffy::style::LengthPercentageAuto::Length((*rems * rem_size).into()) + taffy::style::LengthPercentageAuto::length((*rems * rem_size).into()) } }, DefiniteLength::Fraction(fraction) => { - taffy::style::LengthPercentageAuto::Percent(*fraction) + taffy::style::LengthPercentageAuto::percent(*fraction) } } } @@ -337,12 +337,12 @@ impl ToTaffy for DefiniteLength { fn to_taffy(&self, rem_size: Pixels) -> taffy::style::Dimension { match self { DefiniteLength::Absolute(length) => match length { - AbsoluteLength::Pixels(pixels) => taffy::style::Dimension::Length(pixels.into()), + AbsoluteLength::Pixels(pixels) => taffy::style::Dimension::length(pixels.into()), AbsoluteLength::Rems(rems) => { - taffy::style::Dimension::Length((*rems * rem_size).into()) + taffy::style::Dimension::length((*rems * rem_size).into()) } }, - DefiniteLength::Fraction(fraction) => taffy::style::Dimension::Percent(*fraction), + DefiniteLength::Fraction(fraction) => taffy::style::Dimension::percent(*fraction), } } } @@ -350,9 +350,9 @@ impl ToTaffy for DefiniteLength { impl ToTaffy for AbsoluteLength { fn to_taffy(&self, rem_size: Pixels) -> taffy::style::LengthPercentage { match self { - AbsoluteLength::Pixels(pixels) => taffy::style::LengthPercentage::Length(pixels.into()), + AbsoluteLength::Pixels(pixels) => taffy::style::LengthPercentage::length(pixels.into()), AbsoluteLength::Rems(rems) => { - taffy::style::LengthPercentage::Length((*rems * rem_size).into()) + taffy::style::LengthPercentage::length((*rems * rem_size).into()) } } } From 64d0fec699607f4cef8b2625fef62d1ea105a2ed Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Tue, 22 Jul 2025 18:20:48 +0200 Subject: [PATCH 0128/1052] sum_tree: Store context on cursor (#34904) This gets rid of the need to pass context to all cursor functions. In practice context is always immutable when interacting with cursors. A nicety of this is in the follow-up PR we will be able to implement Iterator for all Cursors/filter cursors (hell, we may be able to get rid of filter cursor altogether, as it is just a custom `filter` impl on iterator trait). Release Notes: - N/A --- crates/buffer_diff/src/buffer_diff.rs | 42 ++- crates/channel/src/channel_chat.rs | 30 +- crates/editor/src/display_map/block_map.rs | 96 +++--- crates/editor/src/display_map/crease_map.rs | 24 +- crates/editor/src/display_map/fold_map.rs | 119 ++++---- crates/editor/src/display_map/inlay_map.rs | 94 +++--- crates/editor/src/display_map/wrap_map.rs | 106 +++---- crates/editor/src/git/blame.rs | 14 +- crates/gpui/src/elements/list.rs | 54 ++-- crates/language/src/diagnostic_set.rs | 8 +- crates/language/src/syntax_map.rs | 35 ++- crates/multi_buffer/src/multi_buffer.rs | 286 +++++++++--------- .../notifications/src/notification_store.rs | 10 +- crates/project/src/git_store.rs | 4 +- crates/project/src/git_store/git_traversal.rs | 7 +- crates/rope/src/rope.rs | 104 +++---- crates/sum_tree/src/cursor.rs | 173 ++++++----- crates/sum_tree/src/sum_tree.rs | 222 +++++--------- crates/sum_tree/src/tree_map.rs | 34 +-- crates/text/src/anchor.rs | 2 +- crates/text/src/text.rs | 115 ++++--- crates/text/src/undo_map.rs | 2 - crates/worktree/src/worktree.rs | 44 ++- 23 files changed, 749 insertions(+), 876 deletions(-) diff --git a/crates/buffer_diff/src/buffer_diff.rs b/crates/buffer_diff/src/buffer_diff.rs index ee09fda46e..97f529fe37 100644 --- a/crates/buffer_diff/src/buffer_diff.rs +++ b/crates/buffer_diff/src/buffer_diff.rs @@ -343,8 +343,7 @@ impl BufferDiffInner { .. } in hunks.iter().cloned() { - let preceding_pending_hunks = - old_pending_hunks.slice(&buffer_range.start, Bias::Left, buffer); + let preceding_pending_hunks = old_pending_hunks.slice(&buffer_range.start, Bias::Left); pending_hunks.append(preceding_pending_hunks, buffer); // Skip all overlapping or adjacent old pending hunks @@ -355,7 +354,7 @@ impl BufferDiffInner { .cmp(&buffer_range.end, buffer) .is_le() }) { - old_pending_hunks.next(buffer); + old_pending_hunks.next(); } if (stage && secondary_status == DiffHunkSecondaryStatus::NoSecondaryHunk) @@ -379,10 +378,10 @@ impl BufferDiffInner { ); } // append the remainder - pending_hunks.append(old_pending_hunks.suffix(buffer), buffer); + pending_hunks.append(old_pending_hunks.suffix(), buffer); let mut unstaged_hunk_cursor = unstaged_diff.hunks.cursor::(buffer); - unstaged_hunk_cursor.next(buffer); + unstaged_hunk_cursor.next(); // then, iterate over all pending hunks (both new ones and the existing ones) and compute the edits let mut prev_unstaged_hunk_buffer_end = 0; @@ -397,8 +396,7 @@ impl BufferDiffInner { }) = pending_hunks_iter.next() { // Advance unstaged_hunk_cursor to skip unstaged hunks before current hunk - let skipped_unstaged = - unstaged_hunk_cursor.slice(&buffer_range.start, Bias::Left, buffer); + let skipped_unstaged = unstaged_hunk_cursor.slice(&buffer_range.start, Bias::Left); if let Some(unstaged_hunk) = skipped_unstaged.last() { prev_unstaged_hunk_base_text_end = unstaged_hunk.diff_base_byte_range.end; @@ -425,7 +423,7 @@ impl BufferDiffInner { buffer_offset_range.end = buffer_offset_range.end.max(unstaged_hunk_offset_range.end); - unstaged_hunk_cursor.next(buffer); + unstaged_hunk_cursor.next(); continue; } } @@ -514,7 +512,7 @@ impl BufferDiffInner { }); let anchor_iter = iter::from_fn(move || { - cursor.next(buffer); + cursor.next(); cursor.item() }) .flat_map(move |hunk| { @@ -531,12 +529,12 @@ impl BufferDiffInner { }); let mut pending_hunks_cursor = self.pending_hunks.cursor::(buffer); - pending_hunks_cursor.next(buffer); + pending_hunks_cursor.next(); let mut secondary_cursor = None; if let Some(secondary) = secondary.as_ref() { let mut cursor = secondary.hunks.cursor::(buffer); - cursor.next(buffer); + cursor.next(); secondary_cursor = Some(cursor); } @@ -564,7 +562,7 @@ impl BufferDiffInner { .cmp(&pending_hunks_cursor.start().buffer_range.start, buffer) .is_gt() { - pending_hunks_cursor.seek_forward(&start_anchor, Bias::Left, buffer); + pending_hunks_cursor.seek_forward(&start_anchor, Bias::Left); } if let Some(pending_hunk) = pending_hunks_cursor.item() { @@ -590,7 +588,7 @@ impl BufferDiffInner { .cmp(&secondary_cursor.start().buffer_range.start, buffer) .is_gt() { - secondary_cursor.seek_forward(&start_anchor, Bias::Left, buffer); + secondary_cursor.seek_forward(&start_anchor, Bias::Left); } if let Some(secondary_hunk) = secondary_cursor.item() { @@ -635,7 +633,7 @@ impl BufferDiffInner { }); iter::from_fn(move || { - cursor.prev(buffer); + cursor.prev(); let hunk = cursor.item()?; let range = hunk.buffer_range.to_point(buffer); @@ -653,8 +651,8 @@ impl BufferDiffInner { fn compare(&self, old: &Self, new_snapshot: &text::BufferSnapshot) -> Option> { let mut new_cursor = self.hunks.cursor::<()>(new_snapshot); let mut old_cursor = old.hunks.cursor::<()>(new_snapshot); - old_cursor.next(new_snapshot); - new_cursor.next(new_snapshot); + old_cursor.next(); + new_cursor.next(); let mut start = None; let mut end = None; @@ -669,7 +667,7 @@ impl BufferDiffInner { Ordering::Less => { start.get_or_insert(new_hunk.buffer_range.start); end.replace(new_hunk.buffer_range.end); - new_cursor.next(new_snapshot); + new_cursor.next(); } Ordering::Equal => { if new_hunk != old_hunk { @@ -686,25 +684,25 @@ impl BufferDiffInner { } } - new_cursor.next(new_snapshot); - old_cursor.next(new_snapshot); + new_cursor.next(); + old_cursor.next(); } Ordering::Greater => { start.get_or_insert(old_hunk.buffer_range.start); end.replace(old_hunk.buffer_range.end); - old_cursor.next(new_snapshot); + old_cursor.next(); } } } (Some(new_hunk), None) => { start.get_or_insert(new_hunk.buffer_range.start); end.replace(new_hunk.buffer_range.end); - new_cursor.next(new_snapshot); + new_cursor.next(); } (None, Some(old_hunk)) => { start.get_or_insert(old_hunk.buffer_range.start); end.replace(old_hunk.buffer_range.end); - old_cursor.next(new_snapshot); + old_cursor.next(); } (None, None) => break, } diff --git a/crates/channel/src/channel_chat.rs b/crates/channel/src/channel_chat.rs index 8394972d43..866e3ccd90 100644 --- a/crates/channel/src/channel_chat.rs +++ b/crates/channel/src/channel_chat.rs @@ -333,7 +333,7 @@ impl ChannelChat { if first_id <= message_id { let mut cursor = chat.messages.cursor::<(ChannelMessageId, Count)>(&()); let message_id = ChannelMessageId::Saved(message_id); - cursor.seek(&message_id, Bias::Left, &()); + cursor.seek(&message_id, Bias::Left); return ControlFlow::Break( if cursor .item() @@ -499,7 +499,7 @@ impl ChannelChat { pub fn message(&self, ix: usize) -> &ChannelMessage { let mut cursor = self.messages.cursor::(&()); - cursor.seek(&Count(ix), Bias::Right, &()); + cursor.seek(&Count(ix), Bias::Right); cursor.item().unwrap() } @@ -516,13 +516,13 @@ impl ChannelChat { pub fn messages_in_range(&self, range: Range) -> impl Iterator { let mut cursor = self.messages.cursor::(&()); - cursor.seek(&Count(range.start), Bias::Right, &()); + cursor.seek(&Count(range.start), Bias::Right); cursor.take(range.len()) } pub fn pending_messages(&self) -> impl Iterator { let mut cursor = self.messages.cursor::(&()); - cursor.seek(&ChannelMessageId::Pending(0), Bias::Left, &()); + cursor.seek(&ChannelMessageId::Pending(0), Bias::Left); cursor } @@ -588,9 +588,9 @@ impl ChannelChat { .collect::>(); let mut old_cursor = self.messages.cursor::<(ChannelMessageId, Count)>(&()); - let mut new_messages = old_cursor.slice(&first_message.id, Bias::Left, &()); + let mut new_messages = old_cursor.slice(&first_message.id, Bias::Left); let start_ix = old_cursor.start().1.0; - let removed_messages = old_cursor.slice(&last_message.id, Bias::Right, &()); + let removed_messages = old_cursor.slice(&last_message.id, Bias::Right); let removed_count = removed_messages.summary().count; let new_count = messages.summary().count; let end_ix = start_ix + removed_count; @@ -599,10 +599,10 @@ impl ChannelChat { let mut ranges = Vec::>::new(); if new_messages.last().unwrap().is_pending() { - new_messages.append(old_cursor.suffix(&()), &()); + new_messages.append(old_cursor.suffix(), &()); } else { new_messages.append( - old_cursor.slice(&ChannelMessageId::Pending(0), Bias::Left, &()), + old_cursor.slice(&ChannelMessageId::Pending(0), Bias::Left), &(), ); @@ -617,7 +617,7 @@ impl ChannelChat { } else { new_messages.push(message.clone(), &()); } - old_cursor.next(&()); + old_cursor.next(); } } @@ -641,12 +641,12 @@ impl ChannelChat { fn message_removed(&mut self, id: u64, cx: &mut Context) { let mut cursor = self.messages.cursor::(&()); - let mut messages = cursor.slice(&ChannelMessageId::Saved(id), Bias::Left, &()); + let mut messages = cursor.slice(&ChannelMessageId::Saved(id), Bias::Left); if let Some(item) = cursor.item() { if item.id == ChannelMessageId::Saved(id) { let deleted_message_ix = messages.summary().count; - cursor.next(&()); - messages.append(cursor.suffix(&()), &()); + cursor.next(); + messages.append(cursor.suffix(), &()); drop(cursor); self.messages = messages; @@ -680,7 +680,7 @@ impl ChannelChat { cx: &mut Context, ) { let mut cursor = self.messages.cursor::(&()); - let mut messages = cursor.slice(&id, Bias::Left, &()); + let mut messages = cursor.slice(&id, Bias::Left); let ix = messages.summary().count; if let Some(mut message_to_update) = cursor.item().cloned() { @@ -688,10 +688,10 @@ impl ChannelChat { message_to_update.mentions = mentions; message_to_update.edited_at = edited_at; messages.push(message_to_update, &()); - cursor.next(&()); + cursor.next(); } - messages.append(cursor.suffix(&()), &()); + messages.append(cursor.suffix(), &()); drop(cursor); self.messages = messages; diff --git a/crates/editor/src/display_map/block_map.rs b/crates/editor/src/display_map/block_map.rs index c761e0d69c..85495a2611 100644 --- a/crates/editor/src/display_map/block_map.rs +++ b/crates/editor/src/display_map/block_map.rs @@ -524,10 +524,10 @@ impl BlockMap { // * Isomorphic transforms that end *at* the start of the edit // * Below blocks that end at the start of the edit // However, if we hit a replace block that ends at the start of the edit we want to reconstruct it. - new_transforms.append(cursor.slice(&old_start, Bias::Left, &()), &()); + new_transforms.append(cursor.slice(&old_start, Bias::Left), &()); if let Some(transform) = cursor.item() { if transform.summary.input_rows > 0 - && cursor.end(&()) == old_start + && cursor.end() == old_start && transform .block .as_ref() @@ -535,13 +535,13 @@ impl BlockMap { { // Preserve the transform (push and next) new_transforms.push(transform.clone(), &()); - cursor.next(&()); + cursor.next(); // Preserve below blocks at end of edit while let Some(transform) = cursor.item() { if transform.block.as_ref().map_or(false, |b| b.place_below()) { new_transforms.push(transform.clone(), &()); - cursor.next(&()); + cursor.next(); } else { break; } @@ -579,8 +579,8 @@ impl BlockMap { let mut new_end = WrapRow(edit.new.end); loop { // Seek to the transform starting at or after the end of the edit - cursor.seek(&old_end, Bias::Left, &()); - cursor.next(&()); + cursor.seek(&old_end, Bias::Left); + cursor.next(); // Extend edit to the end of the discarded transform so it is reconstructed in full let transform_rows_after_edit = cursor.start().0 - old_end.0; @@ -592,8 +592,8 @@ impl BlockMap { if next_edit.old.start <= cursor.start().0 { old_end = WrapRow(next_edit.old.end); new_end = WrapRow(next_edit.new.end); - cursor.seek(&old_end, Bias::Left, &()); - cursor.next(&()); + cursor.seek(&old_end, Bias::Left); + cursor.next(); edits.next(); } else { break; @@ -608,7 +608,7 @@ impl BlockMap { // Discard below blocks at the end of the edit. They'll be reconstructed. while let Some(transform) = cursor.item() { if transform.block.as_ref().map_or(false, |b| b.place_below()) { - cursor.next(&()); + cursor.next(); } else { break; } @@ -720,7 +720,7 @@ impl BlockMap { push_isomorphic(&mut new_transforms, rows_after_last_block, wrap_snapshot); } - new_transforms.append(cursor.suffix(&()), &()); + new_transforms.append(cursor.suffix(), &()); debug_assert_eq!( new_transforms.summary().input_rows, wrap_snapshot.max_point().row() + 1 @@ -971,7 +971,7 @@ impl BlockMapReader<'_> { ); let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>(&()); - cursor.seek(&start_wrap_row, Bias::Left, &()); + cursor.seek(&start_wrap_row, Bias::Left); while let Some(transform) = cursor.item() { if cursor.start().0 > end_wrap_row { break; @@ -982,7 +982,7 @@ impl BlockMapReader<'_> { return Some(cursor.start().1); } } - cursor.next(&()); + cursor.next(); } None @@ -1293,7 +1293,7 @@ impl BlockSnapshot { let max_output_row = cmp::min(rows.end, self.transforms.summary().output_rows); let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&()); - cursor.seek(&BlockRow(rows.start), Bias::Right, &()); + cursor.seek(&BlockRow(rows.start), Bias::Right); let transform_output_start = cursor.start().0.0; let transform_input_start = cursor.start().1.0; @@ -1325,7 +1325,7 @@ impl BlockSnapshot { pub(super) fn row_infos(&self, start_row: BlockRow) -> BlockRows<'_> { let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&()); - cursor.seek(&start_row, Bias::Right, &()); + cursor.seek(&start_row, Bias::Right); let (output_start, input_start) = cursor.start(); let overshoot = if cursor .item() @@ -1346,9 +1346,9 @@ impl BlockSnapshot { pub fn blocks_in_range(&self, rows: Range) -> impl Iterator { let mut cursor = self.transforms.cursor::(&()); - cursor.seek(&BlockRow(rows.start), Bias::Left, &()); - while cursor.start().0 < rows.start && cursor.end(&()).0 <= rows.start { - cursor.next(&()); + cursor.seek(&BlockRow(rows.start), Bias::Left); + while cursor.start().0 < rows.start && cursor.end().0 <= rows.start { + cursor.next(); } std::iter::from_fn(move || { @@ -1364,10 +1364,10 @@ impl BlockSnapshot { break; } if let Some(block) = &transform.block { - cursor.next(&()); + cursor.next(); return Some((start_row, block)); } else { - cursor.next(&()); + cursor.next(); } } None @@ -1377,7 +1377,7 @@ impl BlockSnapshot { pub fn sticky_header_excerpt(&self, position: f32) -> Option> { let top_row = position as u32; let mut cursor = self.transforms.cursor::(&()); - cursor.seek(&BlockRow(top_row), Bias::Right, &()); + cursor.seek(&BlockRow(top_row), Bias::Right); while let Some(transform) = cursor.item() { match &transform.block { @@ -1386,7 +1386,7 @@ impl BlockSnapshot { } Some(block) if block.is_buffer_header() => return None, _ => { - cursor.prev(&()); + cursor.prev(); continue; } } @@ -1414,7 +1414,7 @@ impl BlockSnapshot { let wrap_row = WrapRow(wrap_point.row()); let mut cursor = self.transforms.cursor::(&()); - cursor.seek(&wrap_row, Bias::Left, &()); + cursor.seek(&wrap_row, Bias::Left); while let Some(transform) = cursor.item() { if let Some(block) = transform.block.as_ref() { @@ -1425,7 +1425,7 @@ impl BlockSnapshot { break; } - cursor.next(&()); + cursor.next(); } None @@ -1442,7 +1442,7 @@ impl BlockSnapshot { pub fn longest_row_in_range(&self, range: Range) -> BlockRow { let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&()); - cursor.seek(&range.start, Bias::Right, &()); + cursor.seek(&range.start, Bias::Right); let mut longest_row = range.start; let mut longest_row_chars = 0; @@ -1453,7 +1453,7 @@ impl BlockSnapshot { let wrap_start_row = input_start.0 + overshoot; let wrap_end_row = cmp::min( input_start.0 + (range.end.0 - output_start.0), - cursor.end(&()).1.0, + cursor.end().1.0, ); let summary = self .wrap_snapshot @@ -1461,12 +1461,12 @@ impl BlockSnapshot { longest_row = BlockRow(range.start.0 + summary.longest_row); longest_row_chars = summary.longest_row_chars; } - cursor.next(&()); + cursor.next(); } let cursor_start_row = cursor.start().0; if range.end > cursor_start_row { - let summary = cursor.summary::<_, TransformSummary>(&range.end, Bias::Right, &()); + let summary = cursor.summary::<_, TransformSummary>(&range.end, Bias::Right); if summary.longest_row_chars > longest_row_chars { longest_row = BlockRow(cursor_start_row.0 + summary.longest_row); longest_row_chars = summary.longest_row_chars; @@ -1493,7 +1493,7 @@ impl BlockSnapshot { pub(super) fn line_len(&self, row: BlockRow) -> u32 { let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&()); - cursor.seek(&BlockRow(row.0), Bias::Right, &()); + cursor.seek(&BlockRow(row.0), Bias::Right); if let Some(transform) = cursor.item() { let (output_start, input_start) = cursor.start(); let overshoot = row.0 - output_start.0; @@ -1511,13 +1511,13 @@ impl BlockSnapshot { pub(super) fn is_block_line(&self, row: BlockRow) -> bool { let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&()); - cursor.seek(&row, Bias::Right, &()); + cursor.seek(&row, Bias::Right); cursor.item().map_or(false, |t| t.block.is_some()) } pub(super) fn is_folded_buffer_header(&self, row: BlockRow) -> bool { let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&()); - cursor.seek(&row, Bias::Right, &()); + cursor.seek(&row, Bias::Right); let Some(transform) = cursor.item() else { return false; }; @@ -1529,7 +1529,7 @@ impl BlockSnapshot { .wrap_snapshot .make_wrap_point(Point::new(row.0, 0), Bias::Left); let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>(&()); - cursor.seek(&WrapRow(wrap_point.row()), Bias::Right, &()); + cursor.seek(&WrapRow(wrap_point.row()), Bias::Right); cursor.item().map_or(false, |transform| { transform .block @@ -1540,17 +1540,17 @@ impl BlockSnapshot { pub fn clip_point(&self, point: BlockPoint, bias: Bias) -> BlockPoint { let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&()); - cursor.seek(&BlockRow(point.row), Bias::Right, &()); + cursor.seek(&BlockRow(point.row), Bias::Right); let max_input_row = WrapRow(self.transforms.summary().input_rows); let mut search_left = - (bias == Bias::Left && cursor.start().1.0 > 0) || cursor.end(&()).1 == max_input_row; + (bias == Bias::Left && cursor.start().1.0 > 0) || cursor.end().1 == max_input_row; let mut reversed = false; loop { if let Some(transform) = cursor.item() { let (output_start_row, input_start_row) = cursor.start(); - let (output_end_row, input_end_row) = cursor.end(&()); + let (output_end_row, input_end_row) = cursor.end(); let output_start = Point::new(output_start_row.0, 0); let input_start = Point::new(input_start_row.0, 0); let input_end = Point::new(input_end_row.0, 0); @@ -1584,23 +1584,23 @@ impl BlockSnapshot { } if search_left { - cursor.prev(&()); + cursor.prev(); } else { - cursor.next(&()); + cursor.next(); } } else if reversed { return self.max_point(); } else { reversed = true; search_left = !search_left; - cursor.seek(&BlockRow(point.row), Bias::Right, &()); + cursor.seek(&BlockRow(point.row), Bias::Right); } } } pub fn to_block_point(&self, wrap_point: WrapPoint) -> BlockPoint { let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>(&()); - cursor.seek(&WrapRow(wrap_point.row()), Bias::Right, &()); + cursor.seek(&WrapRow(wrap_point.row()), Bias::Right); if let Some(transform) = cursor.item() { if transform.block.is_some() { BlockPoint::new(cursor.start().1.0, 0) @@ -1618,7 +1618,7 @@ impl BlockSnapshot { pub fn to_wrap_point(&self, block_point: BlockPoint, bias: Bias) -> WrapPoint { let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&()); - cursor.seek(&BlockRow(block_point.row), Bias::Right, &()); + cursor.seek(&BlockRow(block_point.row), Bias::Right); if let Some(transform) = cursor.item() { match transform.block.as_ref() { Some(block) => { @@ -1630,7 +1630,7 @@ impl BlockSnapshot { } else if bias == Bias::Left { WrapPoint::new(cursor.start().1.0, 0) } else { - let wrap_row = cursor.end(&()).1.0 - 1; + let wrap_row = cursor.end().1.0 - 1; WrapPoint::new(wrap_row, self.wrap_snapshot.line_len(wrap_row)) } } @@ -1650,14 +1650,14 @@ impl BlockChunks<'_> { /// Go to the next transform fn advance(&mut self) { self.input_chunk = Chunk::default(); - self.transforms.next(&()); + self.transforms.next(); while let Some(transform) = self.transforms.item() { if transform .block .as_ref() .map_or(false, |block| block.height() == 0) { - self.transforms.next(&()); + self.transforms.next(); } else { break; } @@ -1672,7 +1672,7 @@ impl BlockChunks<'_> { let start_output_row = self.transforms.start().0.0; if start_output_row < self.max_output_row { let end_input_row = cmp::min( - self.transforms.end(&()).1.0, + self.transforms.end().1.0, start_input_row + (self.max_output_row - start_output_row), ); self.input_chunks.seek(start_input_row..end_input_row); @@ -1696,7 +1696,7 @@ impl<'a> Iterator for BlockChunks<'a> { let transform = self.transforms.item()?; if transform.block.is_some() { let block_start = self.transforms.start().0.0; - let mut block_end = self.transforms.end(&()).0.0; + let mut block_end = self.transforms.end().0.0; self.advance(); if self.transforms.item().is_none() { block_end -= 1; @@ -1731,7 +1731,7 @@ impl<'a> Iterator for BlockChunks<'a> { } } - let transform_end = self.transforms.end(&()).0.0; + let transform_end = self.transforms.end().0.0; let (prefix_rows, prefix_bytes) = offset_for_row(self.input_chunk.text, transform_end - self.output_row); self.output_row += prefix_rows; @@ -1770,15 +1770,15 @@ impl Iterator for BlockRows<'_> { self.started = true; } - if self.output_row.0 >= self.transforms.end(&()).0.0 { - self.transforms.next(&()); + if self.output_row.0 >= self.transforms.end().0.0 { + self.transforms.next(); while let Some(transform) = self.transforms.item() { if transform .block .as_ref() .map_or(false, |block| block.height() == 0) { - self.transforms.next(&()); + self.transforms.next(); } else { break; } diff --git a/crates/editor/src/display_map/crease_map.rs b/crates/editor/src/display_map/crease_map.rs index e6fe4270ec..bdac982fa7 100644 --- a/crates/editor/src/display_map/crease_map.rs +++ b/crates/editor/src/display_map/crease_map.rs @@ -52,15 +52,15 @@ impl CreaseSnapshot { ) -> Option<&'a Crease> { let start = snapshot.anchor_before(Point::new(row.0, 0)); let mut cursor = self.creases.cursor::(snapshot); - cursor.seek(&start, Bias::Left, snapshot); + cursor.seek(&start, Bias::Left); while let Some(item) = cursor.item() { match Ord::cmp(&item.crease.range().start.to_point(snapshot).row, &row.0) { - Ordering::Less => cursor.next(snapshot), + Ordering::Less => cursor.next(), Ordering::Equal => { if item.crease.range().start.is_valid(snapshot) { return Some(&item.crease); } else { - cursor.next(snapshot); + cursor.next(); } } Ordering::Greater => break, @@ -76,11 +76,11 @@ impl CreaseSnapshot { ) -> impl 'a + Iterator> { let start = snapshot.anchor_before(Point::new(range.start.0, 0)); let mut cursor = self.creases.cursor::(snapshot); - cursor.seek(&start, Bias::Left, snapshot); + cursor.seek(&start, Bias::Left); std::iter::from_fn(move || { while let Some(item) = cursor.item() { - cursor.next(snapshot); + cursor.next(); let crease_range = item.crease.range(); let crease_start = crease_range.start.to_point(snapshot); let crease_end = crease_range.end.to_point(snapshot); @@ -102,13 +102,13 @@ impl CreaseSnapshot { let mut cursor = self.creases.cursor::(snapshot); let mut results = Vec::new(); - cursor.next(snapshot); + cursor.next(); while let Some(item) = cursor.item() { let crease_range = item.crease.range(); let start_point = crease_range.start.to_point(snapshot); let end_point = crease_range.end.to_point(snapshot); results.push((item.id, start_point..end_point)); - cursor.next(snapshot); + cursor.next(); } results @@ -298,7 +298,7 @@ impl CreaseMap { let mut cursor = self.snapshot.creases.cursor::(snapshot); for crease in creases { let crease_range = crease.range().clone(); - new_creases.append(cursor.slice(&crease_range, Bias::Left, snapshot), snapshot); + new_creases.append(cursor.slice(&crease_range, Bias::Left), snapshot); let id = self.next_id; self.next_id.0 += 1; @@ -306,7 +306,7 @@ impl CreaseMap { new_creases.push(CreaseItem { crease, id }, snapshot); new_ids.push(id); } - new_creases.append(cursor.suffix(snapshot), snapshot); + new_creases.append(cursor.suffix(), snapshot); new_creases }; new_ids @@ -332,9 +332,9 @@ impl CreaseMap { let mut cursor = self.snapshot.creases.cursor::(snapshot); for (id, range) in &removals { - new_creases.append(cursor.slice(range, Bias::Left, snapshot), snapshot); + new_creases.append(cursor.slice(range, Bias::Left), snapshot); while let Some(item) = cursor.item() { - cursor.next(snapshot); + cursor.next(); if item.id == *id { break; } else { @@ -343,7 +343,7 @@ impl CreaseMap { } } - new_creases.append(cursor.suffix(snapshot), snapshot); + new_creases.append(cursor.suffix(), snapshot); new_creases }; diff --git a/crates/editor/src/display_map/fold_map.rs b/crates/editor/src/display_map/fold_map.rs index f37e7063e7..829d34ff58 100644 --- a/crates/editor/src/display_map/fold_map.rs +++ b/crates/editor/src/display_map/fold_map.rs @@ -99,7 +99,7 @@ impl FoldPoint { pub fn to_inlay_point(self, snapshot: &FoldSnapshot) -> InlayPoint { let mut cursor = snapshot.transforms.cursor::<(FoldPoint, InlayPoint)>(&()); - cursor.seek(&self, Bias::Right, &()); + cursor.seek(&self, Bias::Right); let overshoot = self.0 - cursor.start().0.0; InlayPoint(cursor.start().1.0 + overshoot) } @@ -108,7 +108,7 @@ impl FoldPoint { let mut cursor = snapshot .transforms .cursor::<(FoldPoint, TransformSummary)>(&()); - cursor.seek(&self, Bias::Right, &()); + cursor.seek(&self, Bias::Right); let overshoot = self.0 - cursor.start().1.output.lines; let mut offset = cursor.start().1.output.len; if !overshoot.is_zero() { @@ -187,10 +187,10 @@ impl FoldMapWriter<'_> { width: None, }, ); - new_tree.append(cursor.slice(&fold.range, Bias::Right, buffer), buffer); + new_tree.append(cursor.slice(&fold.range, Bias::Right), buffer); new_tree.push(fold, buffer); } - new_tree.append(cursor.suffix(buffer), buffer); + new_tree.append(cursor.suffix(), buffer); new_tree }; @@ -252,7 +252,7 @@ impl FoldMapWriter<'_> { fold_ixs_to_delete.push(*folds_cursor.start()); self.0.snapshot.fold_metadata_by_id.remove(&fold.id); } - folds_cursor.next(buffer); + folds_cursor.next(); } } @@ -263,10 +263,10 @@ impl FoldMapWriter<'_> { let mut cursor = self.0.snapshot.folds.cursor::(buffer); let mut folds = SumTree::new(buffer); for fold_ix in fold_ixs_to_delete { - folds.append(cursor.slice(&fold_ix, Bias::Right, buffer), buffer); - cursor.next(buffer); + folds.append(cursor.slice(&fold_ix, Bias::Right), buffer); + cursor.next(); } - folds.append(cursor.suffix(buffer), buffer); + folds.append(cursor.suffix(), buffer); folds }; @@ -412,7 +412,7 @@ impl FoldMap { let mut new_transforms = SumTree::::default(); let mut cursor = self.snapshot.transforms.cursor::(&()); - cursor.seek(&InlayOffset(0), Bias::Right, &()); + cursor.seek(&InlayOffset(0), Bias::Right); while let Some(mut edit) = inlay_edits_iter.next() { if let Some(item) = cursor.item() { @@ -421,19 +421,19 @@ impl FoldMap { |transform| { if !transform.is_fold() { transform.summary.add_summary(&item.summary, &()); - cursor.next(&()); + cursor.next(); } }, &(), ); } } - new_transforms.append(cursor.slice(&edit.old.start, Bias::Left, &()), &()); + new_transforms.append(cursor.slice(&edit.old.start, Bias::Left), &()); edit.new.start -= edit.old.start - *cursor.start(); edit.old.start = *cursor.start(); - cursor.seek(&edit.old.end, Bias::Right, &()); - cursor.next(&()); + cursor.seek(&edit.old.end, Bias::Right); + cursor.next(); let mut delta = edit.new_len().0 as isize - edit.old_len().0 as isize; loop { @@ -449,8 +449,8 @@ impl FoldMap { if next_edit.old.end >= edit.old.end { edit.old.end = next_edit.old.end; - cursor.seek(&edit.old.end, Bias::Right, &()); - cursor.next(&()); + cursor.seek(&edit.old.end, Bias::Right); + cursor.next(); } } else { break; @@ -467,11 +467,7 @@ impl FoldMap { .snapshot .folds .cursor::(&inlay_snapshot.buffer); - folds_cursor.seek( - &FoldRange(anchor..Anchor::max()), - Bias::Left, - &inlay_snapshot.buffer, - ); + folds_cursor.seek(&FoldRange(anchor..Anchor::max()), Bias::Left); let mut folds = iter::from_fn({ let inlay_snapshot = &inlay_snapshot; @@ -485,7 +481,7 @@ impl FoldMap { ..inlay_snapshot.to_inlay_offset(buffer_end), ) }); - folds_cursor.next(&inlay_snapshot.buffer); + folds_cursor.next(); item } }) @@ -558,7 +554,7 @@ impl FoldMap { } } - new_transforms.append(cursor.suffix(&()), &()); + new_transforms.append(cursor.suffix(), &()); if new_transforms.is_empty() { let text_summary = inlay_snapshot.text_summary(); push_isomorphic(&mut new_transforms, text_summary); @@ -575,31 +571,31 @@ impl FoldMap { let mut new_transforms = new_transforms.cursor::<(InlayOffset, FoldOffset)>(&()); for mut edit in inlay_edits { - old_transforms.seek(&edit.old.start, Bias::Left, &()); + old_transforms.seek(&edit.old.start, Bias::Left); if old_transforms.item().map_or(false, |t| t.is_fold()) { edit.old.start = old_transforms.start().0; } let old_start = old_transforms.start().1.0 + (edit.old.start - old_transforms.start().0).0; - old_transforms.seek_forward(&edit.old.end, Bias::Right, &()); + old_transforms.seek_forward(&edit.old.end, Bias::Right); if old_transforms.item().map_or(false, |t| t.is_fold()) { - old_transforms.next(&()); + old_transforms.next(); edit.old.end = old_transforms.start().0; } let old_end = old_transforms.start().1.0 + (edit.old.end - old_transforms.start().0).0; - new_transforms.seek(&edit.new.start, Bias::Left, &()); + new_transforms.seek(&edit.new.start, Bias::Left); if new_transforms.item().map_or(false, |t| t.is_fold()) { edit.new.start = new_transforms.start().0; } let new_start = new_transforms.start().1.0 + (edit.new.start - new_transforms.start().0).0; - new_transforms.seek_forward(&edit.new.end, Bias::Right, &()); + new_transforms.seek_forward(&edit.new.end, Bias::Right); if new_transforms.item().map_or(false, |t| t.is_fold()) { - new_transforms.next(&()); + new_transforms.next(); edit.new.end = new_transforms.start().0; } let new_end = @@ -656,10 +652,10 @@ impl FoldSnapshot { let mut summary = TextSummary::default(); let mut cursor = self.transforms.cursor::<(FoldPoint, InlayPoint)>(&()); - cursor.seek(&range.start, Bias::Right, &()); + cursor.seek(&range.start, Bias::Right); if let Some(transform) = cursor.item() { let start_in_transform = range.start.0 - cursor.start().0.0; - let end_in_transform = cmp::min(range.end, cursor.end(&()).0).0 - cursor.start().0.0; + let end_in_transform = cmp::min(range.end, cursor.end().0).0 - cursor.start().0.0; if let Some(placeholder) = transform.placeholder.as_ref() { summary = TextSummary::from( &placeholder.text @@ -678,10 +674,10 @@ impl FoldSnapshot { } } - if range.end > cursor.end(&()).0 { - cursor.next(&()); + if range.end > cursor.end().0 { + cursor.next(); summary += &cursor - .summary::<_, TransformSummary>(&range.end, Bias::Right, &()) + .summary::<_, TransformSummary>(&range.end, Bias::Right) .output; if let Some(transform) = cursor.item() { let end_in_transform = range.end.0 - cursor.start().0.0; @@ -705,19 +701,16 @@ impl FoldSnapshot { pub fn to_fold_point(&self, point: InlayPoint, bias: Bias) -> FoldPoint { let mut cursor = self.transforms.cursor::<(InlayPoint, FoldPoint)>(&()); - cursor.seek(&point, Bias::Right, &()); + cursor.seek(&point, Bias::Right); if cursor.item().map_or(false, |t| t.is_fold()) { if bias == Bias::Left || point == cursor.start().0 { cursor.start().1 } else { - cursor.end(&()).1 + cursor.end().1 } } else { let overshoot = point.0 - cursor.start().0.0; - FoldPoint(cmp::min( - cursor.start().1.0 + overshoot, - cursor.end(&()).1.0, - )) + FoldPoint(cmp::min(cursor.start().1.0 + overshoot, cursor.end().1.0)) } } @@ -742,7 +735,7 @@ impl FoldSnapshot { let fold_point = FoldPoint::new(start_row, 0); let mut cursor = self.transforms.cursor::<(FoldPoint, InlayPoint)>(&()); - cursor.seek(&fold_point, Bias::Left, &()); + cursor.seek(&fold_point, Bias::Left); let overshoot = fold_point.0 - cursor.start().0.0; let inlay_point = InlayPoint(cursor.start().1.0 + overshoot); @@ -773,7 +766,7 @@ impl FoldSnapshot { let mut folds = intersecting_folds(&self.inlay_snapshot, &self.folds, range, false); iter::from_fn(move || { let item = folds.item(); - folds.next(&self.inlay_snapshot.buffer); + folds.next(); item }) } @@ -785,7 +778,7 @@ impl FoldSnapshot { let buffer_offset = offset.to_offset(&self.inlay_snapshot.buffer); let inlay_offset = self.inlay_snapshot.to_inlay_offset(buffer_offset); let mut cursor = self.transforms.cursor::(&()); - cursor.seek(&inlay_offset, Bias::Right, &()); + cursor.seek(&inlay_offset, Bias::Right); cursor.item().map_or(false, |t| t.placeholder.is_some()) } @@ -794,7 +787,7 @@ impl FoldSnapshot { .inlay_snapshot .to_inlay_point(Point::new(buffer_row.0, 0)); let mut cursor = self.transforms.cursor::(&()); - cursor.seek(&inlay_point, Bias::Right, &()); + cursor.seek(&inlay_point, Bias::Right); loop { match cursor.item() { Some(transform) => { @@ -808,11 +801,11 @@ impl FoldSnapshot { None => return false, } - if cursor.end(&()).row() == inlay_point.row() { - cursor.next(&()); + if cursor.end().row() == inlay_point.row() { + cursor.next(); } else { inlay_point.0 += Point::new(1, 0); - cursor.seek(&inlay_point, Bias::Right, &()); + cursor.seek(&inlay_point, Bias::Right); } } } @@ -824,14 +817,14 @@ impl FoldSnapshot { highlights: Highlights<'a>, ) -> FoldChunks<'a> { let mut transform_cursor = self.transforms.cursor::<(FoldOffset, InlayOffset)>(&()); - transform_cursor.seek(&range.start, Bias::Right, &()); + transform_cursor.seek(&range.start, Bias::Right); let inlay_start = { let overshoot = range.start.0 - transform_cursor.start().0.0; transform_cursor.start().1 + InlayOffset(overshoot) }; - let transform_end = transform_cursor.end(&()); + let transform_end = transform_cursor.end(); let inlay_end = if transform_cursor .item() @@ -879,14 +872,14 @@ impl FoldSnapshot { pub fn clip_point(&self, point: FoldPoint, bias: Bias) -> FoldPoint { let mut cursor = self.transforms.cursor::<(FoldPoint, InlayPoint)>(&()); - cursor.seek(&point, Bias::Right, &()); + cursor.seek(&point, Bias::Right); if let Some(transform) = cursor.item() { let transform_start = cursor.start().0.0; if transform.placeholder.is_some() { if point.0 == transform_start || matches!(bias, Bias::Left) { FoldPoint(transform_start) } else { - FoldPoint(cursor.end(&()).0.0) + FoldPoint(cursor.end().0.0) } } else { let overshoot = InlayPoint(point.0 - transform_start); @@ -945,7 +938,7 @@ fn intersecting_folds<'a>( start_cmp == Ordering::Less && end_cmp == Ordering::Greater } }); - cursor.next(buffer); + cursor.next(); cursor } @@ -1211,7 +1204,7 @@ pub struct FoldRows<'a> { impl FoldRows<'_> { pub(crate) fn seek(&mut self, row: u32) { let fold_point = FoldPoint::new(row, 0); - self.cursor.seek(&fold_point, Bias::Left, &()); + self.cursor.seek(&fold_point, Bias::Left); let overshoot = fold_point.0 - self.cursor.start().0.0; let inlay_point = InlayPoint(self.cursor.start().1.0 + overshoot); self.input_rows.seek(inlay_point.row()); @@ -1224,8 +1217,8 @@ impl Iterator for FoldRows<'_> { fn next(&mut self) -> Option { let mut traversed_fold = false; - while self.fold_point > self.cursor.end(&()).0 { - self.cursor.next(&()); + while self.fold_point > self.cursor.end().0 { + self.cursor.next(); traversed_fold = true; if self.cursor.item().is_none() { break; @@ -1330,14 +1323,14 @@ pub struct FoldChunks<'a> { impl FoldChunks<'_> { pub(crate) fn seek(&mut self, range: Range) { - self.transform_cursor.seek(&range.start, Bias::Right, &()); + self.transform_cursor.seek(&range.start, Bias::Right); let inlay_start = { let overshoot = range.start.0 - self.transform_cursor.start().0.0; self.transform_cursor.start().1 + InlayOffset(overshoot) }; - let transform_end = self.transform_cursor.end(&()); + let transform_end = self.transform_cursor.end(); let inlay_end = if self .transform_cursor @@ -1376,10 +1369,10 @@ impl<'a> Iterator for FoldChunks<'a> { self.inlay_chunk.take(); self.inlay_offset += InlayOffset(transform.summary.input.len); - while self.inlay_offset >= self.transform_cursor.end(&()).1 + while self.inlay_offset >= self.transform_cursor.end().1 && self.transform_cursor.item().is_some() { - self.transform_cursor.next(&()); + self.transform_cursor.next(); } self.output_offset.0 += placeholder.text.len(); @@ -1396,7 +1389,7 @@ impl<'a> Iterator for FoldChunks<'a> { && self.inlay_chunks.offset() != self.inlay_offset { let transform_start = self.transform_cursor.start(); - let transform_end = self.transform_cursor.end(&()); + let transform_end = self.transform_cursor.end(); let inlay_end = if self.max_output_offset < transform_end.0 { let overshoot = self.max_output_offset.0 - transform_start.0.0; transform_start.1 + InlayOffset(overshoot) @@ -1417,14 +1410,14 @@ impl<'a> Iterator for FoldChunks<'a> { if let Some((buffer_chunk_start, mut inlay_chunk)) = self.inlay_chunk.clone() { let chunk = &mut inlay_chunk.chunk; let buffer_chunk_end = buffer_chunk_start + InlayOffset(chunk.text.len()); - let transform_end = self.transform_cursor.end(&()).1; + let transform_end = self.transform_cursor.end().1; let chunk_end = buffer_chunk_end.min(transform_end); chunk.text = &chunk.text [(self.inlay_offset - buffer_chunk_start).0..(chunk_end - buffer_chunk_start).0]; if chunk_end == transform_end { - self.transform_cursor.next(&()); + self.transform_cursor.next(); } else if chunk_end == buffer_chunk_end { self.inlay_chunk.take(); } @@ -1456,7 +1449,7 @@ impl FoldOffset { let mut cursor = snapshot .transforms .cursor::<(FoldOffset, TransformSummary)>(&()); - cursor.seek(&self, Bias::Right, &()); + cursor.seek(&self, Bias::Right); let overshoot = if cursor.item().map_or(true, |t| t.is_fold()) { Point::new(0, (self.0 - cursor.start().0.0) as u32) } else { @@ -1470,7 +1463,7 @@ impl FoldOffset { #[cfg(test)] pub fn to_inlay_offset(self, snapshot: &FoldSnapshot) -> InlayOffset { let mut cursor = snapshot.transforms.cursor::<(FoldOffset, InlayOffset)>(&()); - cursor.seek(&self, Bias::Right, &()); + cursor.seek(&self, Bias::Right); let overshoot = self.0 - cursor.start().0.0; InlayOffset(cursor.start().1.0 + overshoot) } diff --git a/crates/editor/src/display_map/inlay_map.rs b/crates/editor/src/display_map/inlay_map.rs index f7a696860a..a36d18ff6d 100644 --- a/crates/editor/src/display_map/inlay_map.rs +++ b/crates/editor/src/display_map/inlay_map.rs @@ -263,7 +263,7 @@ pub struct InlayChunk<'a> { impl InlayChunks<'_> { pub fn seek(&mut self, new_range: Range) { - self.transforms.seek(&new_range.start, Bias::Right, &()); + self.transforms.seek(&new_range.start, Bias::Right); let buffer_range = self.snapshot.to_buffer_offset(new_range.start) ..self.snapshot.to_buffer_offset(new_range.end); @@ -296,12 +296,12 @@ impl<'a> Iterator for InlayChunks<'a> { *chunk = self.buffer_chunks.next().unwrap(); } - let desired_bytes = self.transforms.end(&()).0.0 - self.output_offset.0; + let desired_bytes = self.transforms.end().0.0 - self.output_offset.0; // If we're already at the transform boundary, skip to the next transform if desired_bytes == 0 { self.inlay_chunks = None; - self.transforms.next(&()); + self.transforms.next(); return self.next(); } @@ -397,7 +397,7 @@ impl<'a> Iterator for InlayChunks<'a> { let inlay_chunks = self.inlay_chunks.get_or_insert_with(|| { let start = offset_in_inlay; - let end = cmp::min(self.max_output_offset, self.transforms.end(&()).0) + let end = cmp::min(self.max_output_offset, self.transforms.end().0) - self.transforms.start().0; inlay.text.chunks_in_range(start.0..end.0) }); @@ -441,9 +441,9 @@ impl<'a> Iterator for InlayChunks<'a> { } }; - if self.output_offset >= self.transforms.end(&()).0 { + if self.output_offset >= self.transforms.end().0 { self.inlay_chunks = None; - self.transforms.next(&()); + self.transforms.next(); } Some(chunk) @@ -453,7 +453,7 @@ impl<'a> Iterator for InlayChunks<'a> { impl InlayBufferRows<'_> { pub fn seek(&mut self, row: u32) { let inlay_point = InlayPoint::new(row, 0); - self.transforms.seek(&inlay_point, Bias::Left, &()); + self.transforms.seek(&inlay_point, Bias::Left); let mut buffer_point = self.transforms.start().1; let buffer_row = MultiBufferRow(if row == 0 { @@ -487,7 +487,7 @@ impl Iterator for InlayBufferRows<'_> { self.inlay_row += 1; self.transforms - .seek_forward(&InlayPoint::new(self.inlay_row, 0), Bias::Left, &()); + .seek_forward(&InlayPoint::new(self.inlay_row, 0), Bias::Left); Some(buffer_row) } @@ -556,18 +556,18 @@ impl InlayMap { let mut cursor = snapshot.transforms.cursor::<(usize, InlayOffset)>(&()); let mut buffer_edits_iter = buffer_edits.iter().peekable(); while let Some(buffer_edit) = buffer_edits_iter.next() { - new_transforms.append(cursor.slice(&buffer_edit.old.start, Bias::Left, &()), &()); + new_transforms.append(cursor.slice(&buffer_edit.old.start, Bias::Left), &()); if let Some(Transform::Isomorphic(transform)) = cursor.item() { - if cursor.end(&()).0 == buffer_edit.old.start { + if cursor.end().0 == buffer_edit.old.start { push_isomorphic(&mut new_transforms, *transform); - cursor.next(&()); + cursor.next(); } } // Remove all the inlays and transforms contained by the edit. let old_start = cursor.start().1 + InlayOffset(buffer_edit.old.start - cursor.start().0); - cursor.seek(&buffer_edit.old.end, Bias::Right, &()); + cursor.seek(&buffer_edit.old.end, Bias::Right); let old_end = cursor.start().1 + InlayOffset(buffer_edit.old.end - cursor.start().0); @@ -625,20 +625,20 @@ impl InlayMap { // we can push its remainder. if buffer_edits_iter .peek() - .map_or(true, |edit| edit.old.start >= cursor.end(&()).0) + .map_or(true, |edit| edit.old.start >= cursor.end().0) { let transform_start = new_transforms.summary().input.len; let transform_end = - buffer_edit.new.end + (cursor.end(&()).0 - buffer_edit.old.end); + buffer_edit.new.end + (cursor.end().0 - buffer_edit.old.end); push_isomorphic( &mut new_transforms, buffer_snapshot.text_summary_for_range(transform_start..transform_end), ); - cursor.next(&()); + cursor.next(); } } - new_transforms.append(cursor.suffix(&()), &()); + new_transforms.append(cursor.suffix(), &()); if new_transforms.is_empty() { new_transforms.push(Transform::Isomorphic(Default::default()), &()); } @@ -773,7 +773,7 @@ impl InlaySnapshot { let mut cursor = self .transforms .cursor::<(InlayOffset, (InlayPoint, usize))>(&()); - cursor.seek(&offset, Bias::Right, &()); + cursor.seek(&offset, Bias::Right); let overshoot = offset.0 - cursor.start().0.0; match cursor.item() { Some(Transform::Isomorphic(_)) => { @@ -803,7 +803,7 @@ impl InlaySnapshot { let mut cursor = self .transforms .cursor::<(InlayPoint, (InlayOffset, Point))>(&()); - cursor.seek(&point, Bias::Right, &()); + cursor.seek(&point, Bias::Right); let overshoot = point.0 - cursor.start().0.0; match cursor.item() { Some(Transform::Isomorphic(_)) => { @@ -822,7 +822,7 @@ impl InlaySnapshot { } pub fn to_buffer_point(&self, point: InlayPoint) -> Point { let mut cursor = self.transforms.cursor::<(InlayPoint, Point)>(&()); - cursor.seek(&point, Bias::Right, &()); + cursor.seek(&point, Bias::Right); match cursor.item() { Some(Transform::Isomorphic(_)) => { let overshoot = point.0 - cursor.start().0.0; @@ -834,7 +834,7 @@ impl InlaySnapshot { } pub fn to_buffer_offset(&self, offset: InlayOffset) -> usize { let mut cursor = self.transforms.cursor::<(InlayOffset, usize)>(&()); - cursor.seek(&offset, Bias::Right, &()); + cursor.seek(&offset, Bias::Right); match cursor.item() { Some(Transform::Isomorphic(_)) => { let overshoot = offset - cursor.start().0; @@ -847,19 +847,19 @@ impl InlaySnapshot { pub fn to_inlay_offset(&self, offset: usize) -> InlayOffset { let mut cursor = self.transforms.cursor::<(usize, InlayOffset)>(&()); - cursor.seek(&offset, Bias::Left, &()); + cursor.seek(&offset, Bias::Left); loop { match cursor.item() { Some(Transform::Isomorphic(_)) => { - if offset == cursor.end(&()).0 { + if offset == cursor.end().0 { while let Some(Transform::Inlay(inlay)) = cursor.next_item() { if inlay.position.bias() == Bias::Right { break; } else { - cursor.next(&()); + cursor.next(); } } - return cursor.end(&()).1; + return cursor.end().1; } else { let overshoot = offset - cursor.start().0; return InlayOffset(cursor.start().1.0 + overshoot); @@ -867,7 +867,7 @@ impl InlaySnapshot { } Some(Transform::Inlay(inlay)) => { if inlay.position.bias() == Bias::Left { - cursor.next(&()); + cursor.next(); } else { return cursor.start().1; } @@ -880,19 +880,19 @@ impl InlaySnapshot { } pub fn to_inlay_point(&self, point: Point) -> InlayPoint { let mut cursor = self.transforms.cursor::<(Point, InlayPoint)>(&()); - cursor.seek(&point, Bias::Left, &()); + cursor.seek(&point, Bias::Left); loop { match cursor.item() { Some(Transform::Isomorphic(_)) => { - if point == cursor.end(&()).0 { + if point == cursor.end().0 { while let Some(Transform::Inlay(inlay)) = cursor.next_item() { if inlay.position.bias() == Bias::Right { break; } else { - cursor.next(&()); + cursor.next(); } } - return cursor.end(&()).1; + return cursor.end().1; } else { let overshoot = point - cursor.start().0; return InlayPoint(cursor.start().1.0 + overshoot); @@ -900,7 +900,7 @@ impl InlaySnapshot { } Some(Transform::Inlay(inlay)) => { if inlay.position.bias() == Bias::Left { - cursor.next(&()); + cursor.next(); } else { return cursor.start().1; } @@ -914,7 +914,7 @@ impl InlaySnapshot { pub fn clip_point(&self, mut point: InlayPoint, mut bias: Bias) -> InlayPoint { let mut cursor = self.transforms.cursor::<(InlayPoint, Point)>(&()); - cursor.seek(&point, Bias::Left, &()); + cursor.seek(&point, Bias::Left); loop { match cursor.item() { Some(Transform::Isomorphic(transform)) => { @@ -923,7 +923,7 @@ impl InlaySnapshot { if inlay.position.bias() == Bias::Left { return point; } else if bias == Bias::Left { - cursor.prev(&()); + cursor.prev(); } else if transform.first_line_chars == 0 { point.0 += Point::new(1, 0); } else { @@ -932,12 +932,12 @@ impl InlaySnapshot { } else { return point; } - } else if cursor.end(&()).0 == point { + } else if cursor.end().0 == point { if let Some(Transform::Inlay(inlay)) = cursor.next_item() { if inlay.position.bias() == Bias::Right { return point; } else if bias == Bias::Right { - cursor.next(&()); + cursor.next(); } else if point.0.column == 0 { point.0.row -= 1; point.0.column = self.line_len(point.0.row); @@ -970,7 +970,7 @@ impl InlaySnapshot { } _ => return point, } - } else if point == cursor.end(&()).0 && inlay.position.bias() == Bias::Left { + } else if point == cursor.end().0 && inlay.position.bias() == Bias::Left { match cursor.next_item() { Some(Transform::Inlay(inlay)) => { if inlay.position.bias() == Bias::Right { @@ -983,9 +983,9 @@ impl InlaySnapshot { if bias == Bias::Left { point = cursor.start().0; - cursor.prev(&()); + cursor.prev(); } else { - cursor.next(&()); + cursor.next(); point = cursor.start().0; } } @@ -993,9 +993,9 @@ impl InlaySnapshot { bias = bias.invert(); if bias == Bias::Left { point = cursor.start().0; - cursor.prev(&()); + cursor.prev(); } else { - cursor.next(&()); + cursor.next(); point = cursor.start().0; } } @@ -1011,7 +1011,7 @@ impl InlaySnapshot { let mut summary = TextSummary::default(); let mut cursor = self.transforms.cursor::<(InlayOffset, usize)>(&()); - cursor.seek(&range.start, Bias::Right, &()); + cursor.seek(&range.start, Bias::Right); let overshoot = range.start.0 - cursor.start().0.0; match cursor.item() { @@ -1019,22 +1019,22 @@ impl InlaySnapshot { let buffer_start = cursor.start().1; let suffix_start = buffer_start + overshoot; let suffix_end = - buffer_start + (cmp::min(cursor.end(&()).0, range.end).0 - cursor.start().0.0); + buffer_start + (cmp::min(cursor.end().0, range.end).0 - cursor.start().0.0); summary = self.buffer.text_summary_for_range(suffix_start..suffix_end); - cursor.next(&()); + cursor.next(); } Some(Transform::Inlay(inlay)) => { let suffix_start = overshoot; - let suffix_end = cmp::min(cursor.end(&()).0, range.end).0 - cursor.start().0.0; + let suffix_end = cmp::min(cursor.end().0, range.end).0 - cursor.start().0.0; summary = inlay.text.cursor(suffix_start).summary(suffix_end); - cursor.next(&()); + cursor.next(); } None => {} } if range.end > cursor.start().0 { summary += cursor - .summary::<_, TransformSummary>(&range.end, Bias::Right, &()) + .summary::<_, TransformSummary>(&range.end, Bias::Right) .output; let overshoot = range.end.0 - cursor.start().0.0; @@ -1060,7 +1060,7 @@ impl InlaySnapshot { pub fn row_infos(&self, row: u32) -> InlayBufferRows<'_> { let mut cursor = self.transforms.cursor::<(InlayPoint, Point)>(&()); let inlay_point = InlayPoint::new(row, 0); - cursor.seek(&inlay_point, Bias::Left, &()); + cursor.seek(&inlay_point, Bias::Left); let max_buffer_row = self.buffer.max_row(); let mut buffer_point = cursor.start().1; @@ -1101,7 +1101,7 @@ impl InlaySnapshot { highlights: Highlights<'a>, ) -> InlayChunks<'a> { let mut cursor = self.transforms.cursor::<(InlayOffset, usize)>(&()); - cursor.seek(&range.start, Bias::Right, &()); + cursor.seek(&range.start, Bias::Right); let buffer_range = self.to_buffer_offset(range.start)..self.to_buffer_offset(range.end); let buffer_chunks = CustomHighlightsChunks::new( diff --git a/crates/editor/src/display_map/wrap_map.rs b/crates/editor/src/display_map/wrap_map.rs index a29bf53882..d55577826e 100644 --- a/crates/editor/src/display_map/wrap_map.rs +++ b/crates/editor/src/display_map/wrap_map.rs @@ -72,7 +72,7 @@ pub struct WrapRows<'a> { impl WrapRows<'_> { pub(crate) fn seek(&mut self, start_row: u32) { self.transforms - .seek(&WrapPoint::new(start_row, 0), Bias::Left, &()); + .seek(&WrapPoint::new(start_row, 0), Bias::Left); let mut input_row = self.transforms.start().1.row(); if self.transforms.item().map_or(false, |t| t.is_isomorphic()) { input_row += start_row - self.transforms.start().0.row(); @@ -340,7 +340,7 @@ impl WrapSnapshot { let mut tab_edits_iter = tab_edits.iter().peekable(); new_transforms = - old_cursor.slice(&tab_edits_iter.peek().unwrap().old.start, Bias::Right, &()); + old_cursor.slice(&tab_edits_iter.peek().unwrap().old.start, Bias::Right); while let Some(edit) = tab_edits_iter.next() { if edit.new.start > TabPoint::from(new_transforms.summary().input.lines) { @@ -356,31 +356,29 @@ impl WrapSnapshot { )); } - old_cursor.seek_forward(&edit.old.end, Bias::Right, &()); + old_cursor.seek_forward(&edit.old.end, Bias::Right); if let Some(next_edit) = tab_edits_iter.peek() { - if next_edit.old.start > old_cursor.end(&()) { - if old_cursor.end(&()) > edit.old.end { + if next_edit.old.start > old_cursor.end() { + if old_cursor.end() > edit.old.end { let summary = self .tab_snapshot - .text_summary_for_range(edit.old.end..old_cursor.end(&())); + .text_summary_for_range(edit.old.end..old_cursor.end()); new_transforms.push_or_extend(Transform::isomorphic(summary)); } - old_cursor.next(&()); - new_transforms.append( - old_cursor.slice(&next_edit.old.start, Bias::Right, &()), - &(), - ); + old_cursor.next(); + new_transforms + .append(old_cursor.slice(&next_edit.old.start, Bias::Right), &()); } } else { - if old_cursor.end(&()) > edit.old.end { + if old_cursor.end() > edit.old.end { let summary = self .tab_snapshot - .text_summary_for_range(edit.old.end..old_cursor.end(&())); + .text_summary_for_range(edit.old.end..old_cursor.end()); new_transforms.push_or_extend(Transform::isomorphic(summary)); } - old_cursor.next(&()); - new_transforms.append(old_cursor.suffix(&()), &()); + old_cursor.next(); + new_transforms.append(old_cursor.suffix(), &()); } } } @@ -441,7 +439,6 @@ impl WrapSnapshot { new_transforms = old_cursor.slice( &TabPoint::new(row_edits.peek().unwrap().old_rows.start, 0), Bias::Right, - &(), ); while let Some(edit) = row_edits.next() { @@ -516,34 +513,31 @@ impl WrapSnapshot { } new_transforms.extend(edit_transforms, &()); - old_cursor.seek_forward(&TabPoint::new(edit.old_rows.end, 0), Bias::Right, &()); + old_cursor.seek_forward(&TabPoint::new(edit.old_rows.end, 0), Bias::Right); if let Some(next_edit) = row_edits.peek() { - if next_edit.old_rows.start > old_cursor.end(&()).row() { - if old_cursor.end(&()) > TabPoint::new(edit.old_rows.end, 0) { + if next_edit.old_rows.start > old_cursor.end().row() { + if old_cursor.end() > TabPoint::new(edit.old_rows.end, 0) { let summary = self.tab_snapshot.text_summary_for_range( - TabPoint::new(edit.old_rows.end, 0)..old_cursor.end(&()), + TabPoint::new(edit.old_rows.end, 0)..old_cursor.end(), ); new_transforms.push_or_extend(Transform::isomorphic(summary)); } - old_cursor.next(&()); + old_cursor.next(); new_transforms.append( - old_cursor.slice( - &TabPoint::new(next_edit.old_rows.start, 0), - Bias::Right, - &(), - ), + old_cursor + .slice(&TabPoint::new(next_edit.old_rows.start, 0), Bias::Right), &(), ); } } else { - if old_cursor.end(&()) > TabPoint::new(edit.old_rows.end, 0) { + if old_cursor.end() > TabPoint::new(edit.old_rows.end, 0) { let summary = self.tab_snapshot.text_summary_for_range( - TabPoint::new(edit.old_rows.end, 0)..old_cursor.end(&()), + TabPoint::new(edit.old_rows.end, 0)..old_cursor.end(), ); new_transforms.push_or_extend(Transform::isomorphic(summary)); } - old_cursor.next(&()); - new_transforms.append(old_cursor.suffix(&()), &()); + old_cursor.next(); + new_transforms.append(old_cursor.suffix(), &()); } } } @@ -570,19 +564,19 @@ impl WrapSnapshot { tab_edit.new.start.0.column = 0; tab_edit.new.end.0 += Point::new(1, 0); - old_cursor.seek(&tab_edit.old.start, Bias::Right, &()); + old_cursor.seek(&tab_edit.old.start, Bias::Right); let mut old_start = old_cursor.start().output.lines; old_start += tab_edit.old.start.0 - old_cursor.start().input.lines; - old_cursor.seek(&tab_edit.old.end, Bias::Right, &()); + old_cursor.seek(&tab_edit.old.end, Bias::Right); let mut old_end = old_cursor.start().output.lines; old_end += tab_edit.old.end.0 - old_cursor.start().input.lines; - new_cursor.seek(&tab_edit.new.start, Bias::Right, &()); + new_cursor.seek(&tab_edit.new.start, Bias::Right); let mut new_start = new_cursor.start().output.lines; new_start += tab_edit.new.start.0 - new_cursor.start().input.lines; - new_cursor.seek(&tab_edit.new.end, Bias::Right, &()); + new_cursor.seek(&tab_edit.new.end, Bias::Right); let mut new_end = new_cursor.start().output.lines; new_end += tab_edit.new.end.0 - new_cursor.start().input.lines; @@ -605,7 +599,7 @@ impl WrapSnapshot { let output_start = WrapPoint::new(rows.start, 0); let output_end = WrapPoint::new(rows.end, 0); let mut transforms = self.transforms.cursor::<(WrapPoint, TabPoint)>(&()); - transforms.seek(&output_start, Bias::Right, &()); + transforms.seek(&output_start, Bias::Right); let mut input_start = TabPoint(transforms.start().1.0); if transforms.item().map_or(false, |t| t.is_isomorphic()) { input_start.0 += output_start.0 - transforms.start().0.0; @@ -633,7 +627,7 @@ impl WrapSnapshot { pub fn line_len(&self, row: u32) -> u32 { let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>(&()); - cursor.seek(&WrapPoint::new(row + 1, 0), Bias::Left, &()); + cursor.seek(&WrapPoint::new(row + 1, 0), Bias::Left); if cursor .item() .map_or(false, |transform| transform.is_isomorphic()) @@ -658,10 +652,10 @@ impl WrapSnapshot { let end = WrapPoint::new(rows.end, 0); let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>(&()); - cursor.seek(&start, Bias::Right, &()); + cursor.seek(&start, Bias::Right); if let Some(transform) = cursor.item() { let start_in_transform = start.0 - cursor.start().0.0; - let end_in_transform = cmp::min(end, cursor.end(&()).0).0 - cursor.start().0.0; + let end_in_transform = cmp::min(end, cursor.end().0).0 - cursor.start().0.0; if transform.is_isomorphic() { let tab_start = TabPoint(cursor.start().1.0 + start_in_transform); let tab_end = TabPoint(cursor.start().1.0 + end_in_transform); @@ -678,12 +672,12 @@ impl WrapSnapshot { }; } - cursor.next(&()); + cursor.next(); } if rows.end > cursor.start().0.row() { summary += &cursor - .summary::<_, TransformSummary>(&WrapPoint::new(rows.end, 0), Bias::Right, &()) + .summary::<_, TransformSummary>(&WrapPoint::new(rows.end, 0), Bias::Right) .output; if let Some(transform) = cursor.item() { @@ -712,7 +706,7 @@ impl WrapSnapshot { pub fn soft_wrap_indent(&self, row: u32) -> Option { let mut cursor = self.transforms.cursor::(&()); - cursor.seek(&WrapPoint::new(row + 1, 0), Bias::Right, &()); + cursor.seek(&WrapPoint::new(row + 1, 0), Bias::Right); cursor.item().and_then(|transform| { if transform.is_isomorphic() { None @@ -728,7 +722,7 @@ impl WrapSnapshot { pub fn row_infos(&self, start_row: u32) -> WrapRows<'_> { let mut transforms = self.transforms.cursor::<(WrapPoint, TabPoint)>(&()); - transforms.seek(&WrapPoint::new(start_row, 0), Bias::Left, &()); + transforms.seek(&WrapPoint::new(start_row, 0), Bias::Left); let mut input_row = transforms.start().1.row(); if transforms.item().map_or(false, |t| t.is_isomorphic()) { input_row += start_row - transforms.start().0.row(); @@ -748,7 +742,7 @@ impl WrapSnapshot { pub fn to_tab_point(&self, point: WrapPoint) -> TabPoint { let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>(&()); - cursor.seek(&point, Bias::Right, &()); + cursor.seek(&point, Bias::Right); let mut tab_point = cursor.start().1.0; if cursor.item().map_or(false, |t| t.is_isomorphic()) { tab_point += point.0 - cursor.start().0.0; @@ -766,14 +760,14 @@ impl WrapSnapshot { pub fn tab_point_to_wrap_point(&self, point: TabPoint) -> WrapPoint { let mut cursor = self.transforms.cursor::<(TabPoint, WrapPoint)>(&()); - cursor.seek(&point, Bias::Right, &()); + cursor.seek(&point, Bias::Right); WrapPoint(cursor.start().1.0 + (point.0 - cursor.start().0.0)) } pub fn clip_point(&self, mut point: WrapPoint, bias: Bias) -> WrapPoint { if bias == Bias::Left { let mut cursor = self.transforms.cursor::(&()); - cursor.seek(&point, Bias::Right, &()); + cursor.seek(&point, Bias::Right); if cursor.item().map_or(false, |t| !t.is_isomorphic()) { point = *cursor.start(); *point.column_mut() -= 1; @@ -791,16 +785,16 @@ impl WrapSnapshot { *point.column_mut() = 0; let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>(&()); - cursor.seek(&point, Bias::Right, &()); + cursor.seek(&point, Bias::Right); if cursor.item().is_none() { - cursor.prev(&()); + cursor.prev(); } while let Some(transform) = cursor.item() { if transform.is_isomorphic() && cursor.start().1.column() == 0 { - return cmp::min(cursor.end(&()).0.row(), point.row()); + return cmp::min(cursor.end().0.row(), point.row()); } else { - cursor.prev(&()); + cursor.prev(); } } @@ -811,12 +805,12 @@ impl WrapSnapshot { point.0 += Point::new(1, 0); let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>(&()); - cursor.seek(&point, Bias::Right, &()); + cursor.seek(&point, Bias::Right); while let Some(transform) = cursor.item() { if transform.is_isomorphic() && cursor.start().1.column() == 0 { return Some(cmp::max(cursor.start().0.row(), point.row())); } else { - cursor.next(&()); + cursor.next(); } } @@ -889,7 +883,7 @@ impl WrapChunks<'_> { pub(crate) fn seek(&mut self, rows: Range) { let output_start = WrapPoint::new(rows.start, 0); let output_end = WrapPoint::new(rows.end, 0); - self.transforms.seek(&output_start, Bias::Right, &()); + self.transforms.seek(&output_start, Bias::Right); let mut input_start = TabPoint(self.transforms.start().1.0); if self.transforms.item().map_or(false, |t| t.is_isomorphic()) { input_start.0 += output_start.0 - self.transforms.start().0.0; @@ -930,7 +924,7 @@ impl<'a> Iterator for WrapChunks<'a> { } self.output_position.0 += summary; - self.transforms.next(&()); + self.transforms.next(); return Some(Chunk { text: &display_text[start_ix..end_ix], ..Default::default() @@ -942,7 +936,7 @@ impl<'a> Iterator for WrapChunks<'a> { } let mut input_len = 0; - let transform_end = self.transforms.end(&()).0; + let transform_end = self.transforms.end().0; for c in self.input_chunk.text.chars() { let char_len = c.len_utf8(); input_len += char_len; @@ -954,7 +948,7 @@ impl<'a> Iterator for WrapChunks<'a> { } if self.output_position >= transform_end { - self.transforms.next(&()); + self.transforms.next(); break; } } @@ -982,7 +976,7 @@ impl Iterator for WrapRows<'_> { self.output_row += 1; self.transforms - .seek_forward(&WrapPoint::new(self.output_row, 0), Bias::Left, &()); + .seek_forward(&WrapPoint::new(self.output_row, 0), Bias::Left); if self.transforms.item().map_or(false, |t| t.is_isomorphic()) { self.input_buffer_row = self.input_buffer_rows.next().unwrap(); self.soft_wrapped = false; diff --git a/crates/editor/src/git/blame.rs b/crates/editor/src/git/blame.rs index d4c9e37895..fc350a5a15 100644 --- a/crates/editor/src/git/blame.rs +++ b/crates/editor/src/git/blame.rs @@ -296,7 +296,7 @@ impl GitBlame { let row = info .buffer_row .filter(|_| info.buffer_id == Some(buffer_id))?; - cursor.seek_forward(&row, Bias::Right, &()); + cursor.seek_forward(&row, Bias::Right); cursor.item()?.blame.clone() }) } @@ -389,7 +389,7 @@ impl GitBlame { } } - new_entries.append(cursor.slice(&edit.old.start, Bias::Right, &()), &()); + new_entries.append(cursor.slice(&edit.old.start, Bias::Right), &()); if edit.new.start > new_entries.summary().rows { new_entries.push( @@ -401,7 +401,7 @@ impl GitBlame { ); } - cursor.seek(&edit.old.end, Bias::Right, &()); + cursor.seek(&edit.old.end, Bias::Right); if !edit.new.is_empty() { new_entries.push( GitBlameEntry { @@ -412,7 +412,7 @@ impl GitBlame { ); } - let old_end = cursor.end(&()); + let old_end = cursor.end(); if row_edits .peek() .map_or(true, |next_edit| next_edit.old.start >= old_end) @@ -421,18 +421,18 @@ impl GitBlame { if old_end > edit.old.end { new_entries.push( GitBlameEntry { - rows: cursor.end(&()) - edit.old.end, + rows: cursor.end() - edit.old.end, blame: entry.blame.clone(), }, &(), ); } - cursor.next(&()); + cursor.next(); } } } - new_entries.append(cursor.suffix(&()), &()); + new_entries.append(cursor.suffix(), &()); drop(cursor); self.buffer_snapshot = new_snapshot; diff --git a/crates/gpui/src/elements/list.rs b/crates/gpui/src/elements/list.rs index f24d38794f..328a6a4cc1 100644 --- a/crates/gpui/src/elements/list.rs +++ b/crates/gpui/src/elements/list.rs @@ -249,8 +249,8 @@ impl ListState { let state = &mut *self.0.borrow_mut(); let mut old_items = state.items.cursor::(&()); - let mut new_items = old_items.slice(&Count(old_range.start), Bias::Right, &()); - old_items.seek_forward(&Count(old_range.end), Bias::Right, &()); + let mut new_items = old_items.slice(&Count(old_range.start), Bias::Right); + old_items.seek_forward(&Count(old_range.end), Bias::Right); let mut spliced_count = 0; new_items.extend( @@ -260,7 +260,7 @@ impl ListState { }), &(), ); - new_items.append(old_items.suffix(&()), &()); + new_items.append(old_items.suffix(), &()); drop(old_items); state.items = new_items; @@ -300,14 +300,14 @@ impl ListState { let current_offset = self.logical_scroll_top(); let state = &mut *self.0.borrow_mut(); let mut cursor = state.items.cursor::(&()); - cursor.seek(&Count(current_offset.item_ix), Bias::Right, &()); + cursor.seek(&Count(current_offset.item_ix), Bias::Right); let start_pixel_offset = cursor.start().height + current_offset.offset_in_item; let new_pixel_offset = (start_pixel_offset + distance).max(px(0.)); if new_pixel_offset > start_pixel_offset { - cursor.seek_forward(&Height(new_pixel_offset), Bias::Right, &()); + cursor.seek_forward(&Height(new_pixel_offset), Bias::Right); } else { - cursor.seek(&Height(new_pixel_offset), Bias::Right, &()); + cursor.seek(&Height(new_pixel_offset), Bias::Right); } state.logical_scroll_top = Some(ListOffset { @@ -343,11 +343,11 @@ impl ListState { scroll_top.offset_in_item = px(0.); } else { let mut cursor = state.items.cursor::(&()); - cursor.seek(&Count(ix + 1), Bias::Right, &()); + cursor.seek(&Count(ix + 1), Bias::Right); let bottom = cursor.start().height + padding.top; let goal_top = px(0.).max(bottom - height + padding.bottom); - cursor.seek(&Height(goal_top), Bias::Left, &()); + cursor.seek(&Height(goal_top), Bias::Left); let start_ix = cursor.start().count; let start_item_top = cursor.start().height; @@ -372,11 +372,11 @@ impl ListState { } let mut cursor = state.items.cursor::<(Count, Height)>(&()); - cursor.seek(&Count(scroll_top.item_ix), Bias::Right, &()); + cursor.seek(&Count(scroll_top.item_ix), Bias::Right); let scroll_top = cursor.start().1.0 + scroll_top.offset_in_item; - cursor.seek_forward(&Count(ix), Bias::Right, &()); + cursor.seek_forward(&Count(ix), Bias::Right); if let Some(&ListItem::Measured { size, .. }) = cursor.item() { let &(Count(count), Height(top)) = cursor.start(); if count == ix { @@ -431,7 +431,7 @@ impl ListState { let mut cursor = state.items.cursor::(&()); let summary: ListItemSummary = - cursor.summary(&Count(logical_scroll_top.item_ix), Bias::Right, &()); + cursor.summary(&Count(logical_scroll_top.item_ix), Bias::Right); let content_height = state.items.summary().height; let drag_offset = // if dragging the scrollbar, we want to offset the point if the height changed @@ -450,9 +450,9 @@ impl ListState { impl StateInner { fn visible_range(&self, height: Pixels, scroll_top: &ListOffset) -> Range { let mut cursor = self.items.cursor::(&()); - cursor.seek(&Count(scroll_top.item_ix), Bias::Right, &()); + cursor.seek(&Count(scroll_top.item_ix), Bias::Right); let start_y = cursor.start().height + scroll_top.offset_in_item; - cursor.seek_forward(&Height(start_y + height), Bias::Left, &()); + cursor.seek_forward(&Height(start_y + height), Bias::Left); scroll_top.item_ix..cursor.start().count + 1 } @@ -482,7 +482,7 @@ impl StateInner { self.logical_scroll_top = None; } else { let mut cursor = self.items.cursor::(&()); - cursor.seek(&Height(new_scroll_top), Bias::Right, &()); + cursor.seek(&Height(new_scroll_top), Bias::Right); let item_ix = cursor.start().count; let offset_in_item = new_scroll_top - cursor.start().height; self.logical_scroll_top = Some(ListOffset { @@ -523,7 +523,7 @@ impl StateInner { fn scroll_top(&self, logical_scroll_top: &ListOffset) -> Pixels { let mut cursor = self.items.cursor::(&()); - cursor.seek(&Count(logical_scroll_top.item_ix), Bias::Right, &()); + cursor.seek(&Count(logical_scroll_top.item_ix), Bias::Right); cursor.start().height + logical_scroll_top.offset_in_item } @@ -553,7 +553,7 @@ impl StateInner { let mut cursor = old_items.cursor::(&()); // Render items after the scroll top, including those in the trailing overdraw - cursor.seek(&Count(scroll_top.item_ix), Bias::Right, &()); + cursor.seek(&Count(scroll_top.item_ix), Bias::Right); for (ix, item) in cursor.by_ref().enumerate() { let visible_height = rendered_height - scroll_top.offset_in_item; if visible_height >= available_height + self.overdraw { @@ -592,13 +592,13 @@ impl StateInner { rendered_height += padding.bottom; // Prepare to start walking upward from the item at the scroll top. - cursor.seek(&Count(scroll_top.item_ix), Bias::Right, &()); + cursor.seek(&Count(scroll_top.item_ix), Bias::Right); // If the rendered items do not fill the visible region, then adjust // the scroll top upward. if rendered_height - scroll_top.offset_in_item < available_height { while rendered_height < available_height { - cursor.prev(&()); + cursor.prev(); if let Some(item) = cursor.item() { let item_index = cursor.start().0; let mut element = (self.render_item)(item_index, window, cx); @@ -645,7 +645,7 @@ impl StateInner { // Measure items in the leading overdraw let mut leading_overdraw = scroll_top.offset_in_item; while leading_overdraw < self.overdraw { - cursor.prev(&()); + cursor.prev(); if let Some(item) = cursor.item() { let size = if let ListItem::Measured { size, .. } = item { *size @@ -666,10 +666,10 @@ impl StateInner { let measured_range = cursor.start().0..(cursor.start().0 + measured_items.len()); let mut cursor = old_items.cursor::(&()); - let mut new_items = cursor.slice(&Count(measured_range.start), Bias::Right, &()); + let mut new_items = cursor.slice(&Count(measured_range.start), Bias::Right); new_items.extend(measured_items, &()); - cursor.seek(&Count(measured_range.end), Bias::Right, &()); - new_items.append(cursor.suffix(&()), &()); + cursor.seek(&Count(measured_range.end), Bias::Right); + new_items.append(cursor.suffix(), &()); self.items = new_items; // If none of the visible items are focused, check if an off-screen item is focused @@ -679,7 +679,7 @@ impl StateInner { let mut cursor = self .items .filter::<_, Count>(&(), |summary| summary.has_focus_handles); - cursor.next(&()); + cursor.next(); while let Some(item) = cursor.item() { if item.contains_focused(window, cx) { let item_index = cursor.start().0; @@ -692,7 +692,7 @@ impl StateInner { }); break; } - cursor.next(&()); + cursor.next(); } } @@ -741,7 +741,7 @@ impl StateInner { }); } else if autoscroll_bounds.bottom() > bounds.bottom() { let mut cursor = self.items.cursor::(&()); - cursor.seek(&Count(item.index), Bias::Right, &()); + cursor.seek(&Count(item.index), Bias::Right); let mut height = bounds.size.height - padding.top - padding.bottom; // Account for the height of the element down until the autoscroll bottom. @@ -749,7 +749,7 @@ impl StateInner { // Keep decreasing the scroll top until we fill all the available space. while height > Pixels::ZERO { - cursor.prev(&()); + cursor.prev(); let Some(item) = cursor.item() else { break }; let size = item.size().unwrap_or_else(|| { @@ -806,7 +806,7 @@ impl StateInner { self.logical_scroll_top = None; } else { let mut cursor = self.items.cursor::(&()); - cursor.seek(&Height(new_scroll_top), Bias::Right, &()); + cursor.seek(&Height(new_scroll_top), Bias::Right); let item_ix = cursor.start().count; let offset_in_item = new_scroll_top - cursor.start().height; diff --git a/crates/language/src/diagnostic_set.rs b/crates/language/src/diagnostic_set.rs index 661e3ef217..613c445652 100644 --- a/crates/language/src/diagnostic_set.rs +++ b/crates/language/src/diagnostic_set.rs @@ -158,17 +158,17 @@ impl DiagnosticSet { }); if reversed { - cursor.prev(buffer); + cursor.prev(); } else { - cursor.next(buffer); + cursor.next(); } iter::from_fn({ move || { if let Some(diagnostic) = cursor.item() { if reversed { - cursor.prev(buffer); + cursor.prev(); } else { - cursor.next(buffer); + cursor.next(); } Some(diagnostic.resolve(buffer)) } else { diff --git a/crates/language/src/syntax_map.rs b/crates/language/src/syntax_map.rs index da05416e89..f441114a90 100644 --- a/crates/language/src/syntax_map.rs +++ b/crates/language/src/syntax_map.rs @@ -297,10 +297,10 @@ impl SyntaxSnapshot { let mut first_edit_ix_for_depth = 0; let mut prev_depth = 0; let mut cursor = self.layers.cursor::(text); - cursor.next(text); + cursor.next(); 'outer: loop { - let depth = cursor.end(text).max_depth; + let depth = cursor.end().max_depth; if depth > prev_depth { first_edit_ix_for_depth = 0; prev_depth = depth; @@ -313,7 +313,7 @@ impl SyntaxSnapshot { position: edit_range.start, }; if target.cmp(cursor.start(), text).is_gt() { - let slice = cursor.slice(&target, Bias::Left, text); + let slice = cursor.slice(&target, Bias::Left); layers.append(slice, text); } } @@ -327,7 +327,6 @@ impl SyntaxSnapshot { language: None, }, Bias::Left, - text, ); layers.append(slice, text); continue; @@ -394,10 +393,10 @@ impl SyntaxSnapshot { } layers.push(layer, text); - cursor.next(text); + cursor.next(); } - layers.append(cursor.suffix(text), text); + layers.append(cursor.suffix(), text); drop(cursor); self.layers = layers; } @@ -420,7 +419,7 @@ impl SyntaxSnapshot { let mut cursor = self .layers .filter::<_, ()>(text, |summary| summary.contains_unknown_injections); - cursor.next(text); + cursor.next(); while let Some(layer) = cursor.item() { let SyntaxLayerContent::Pending { language_name } = &layer.content else { unreachable!() @@ -436,7 +435,7 @@ impl SyntaxSnapshot { resolved_injection_ranges.push(range); } - cursor.next(text); + cursor.next(); } drop(cursor); @@ -469,7 +468,7 @@ impl SyntaxSnapshot { let max_depth = self.layers.summary().max_depth; let mut cursor = self.layers.cursor::(text); - cursor.next(text); + cursor.next(); let mut layers = SumTree::new(text); let mut changed_regions = ChangeRegionSet::default(); @@ -514,7 +513,7 @@ impl SyntaxSnapshot { }; let mut done = cursor.item().is_none(); - while !done && position.cmp(&cursor.end(text), text).is_gt() { + while !done && position.cmp(&cursor.end(), text).is_gt() { done = true; let bounded_position = SyntaxLayerPositionBeforeChange { @@ -522,16 +521,16 @@ impl SyntaxSnapshot { change: changed_regions.start_position(), }; if bounded_position.cmp(cursor.start(), text).is_gt() { - let slice = cursor.slice(&bounded_position, Bias::Left, text); + let slice = cursor.slice(&bounded_position, Bias::Left); if !slice.is_empty() { layers.append(slice, text); - if changed_regions.prune(cursor.end(text), text) { + if changed_regions.prune(cursor.end(), text) { done = false; } } } - while position.cmp(&cursor.end(text), text).is_gt() { + while position.cmp(&cursor.end(), text).is_gt() { let Some(layer) = cursor.item() else { break }; if changed_regions.intersects(layer, text) { @@ -555,8 +554,8 @@ impl SyntaxSnapshot { layers.push(layer.clone(), text); } - cursor.next(text); - if changed_regions.prune(cursor.end(text), text) { + cursor.next(); + if changed_regions.prune(cursor.end(), text) { done = false; } } @@ -572,7 +571,7 @@ impl SyntaxSnapshot { if layer.range.to_offset(text) == (step_start_byte..step_end_byte) && layer.content.language_id() == step.language.id() { - cursor.next(text); + cursor.next(); } else { old_layer = None; } @@ -918,7 +917,7 @@ impl SyntaxSnapshot { } }); - cursor.next(buffer); + cursor.next(); iter::from_fn(move || { while let Some(layer) = cursor.item() { let mut info = None; @@ -940,7 +939,7 @@ impl SyntaxSnapshot { }); } } - cursor.next(buffer); + cursor.next(); if info.is_some() { return info; } diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs index 2cc8ea59ab..f0913e30fb 100644 --- a/crates/multi_buffer/src/multi_buffer.rs +++ b/crates/multi_buffer/src/multi_buffer.rs @@ -1211,7 +1211,7 @@ impl MultiBuffer { let buffer = buffer_state.buffer.read(cx); for range in buffer.edited_ranges_for_transaction_id::(*buffer_transaction) { for excerpt_id in &buffer_state.excerpts { - cursor.seek(excerpt_id, Bias::Left, &()); + cursor.seek(excerpt_id, Bias::Left); if let Some(excerpt) = cursor.item() { if excerpt.locator == *excerpt_id { let excerpt_buffer_start = @@ -1322,7 +1322,7 @@ impl MultiBuffer { let start_locator = snapshot.excerpt_locator_for_id(selection.start.excerpt_id); let end_locator = snapshot.excerpt_locator_for_id(selection.end.excerpt_id); - cursor.seek(&Some(start_locator), Bias::Left, &()); + cursor.seek(&Some(start_locator), Bias::Left); while let Some(excerpt) = cursor.item() { if excerpt.locator > *end_locator { break; @@ -1347,7 +1347,7 @@ impl MultiBuffer { goal: selection.goal, }); - cursor.next(&()); + cursor.next(); } } @@ -1769,13 +1769,13 @@ impl MultiBuffer { let mut next_excerpt_id = move || ExcerptId(post_inc(&mut next_excerpt_id)); let mut excerpts_cursor = snapshot.excerpts.cursor::>(&()); - excerpts_cursor.next(&()); + excerpts_cursor.next(); loop { let new = new_iter.peek(); let existing = if let Some(existing_id) = existing_iter.peek() { let locator = snapshot.excerpt_locator_for_id(*existing_id); - excerpts_cursor.seek_forward(&Some(locator), Bias::Left, &()); + excerpts_cursor.seek_forward(&Some(locator), Bias::Left); if let Some(excerpt) = excerpts_cursor.item() { if excerpt.buffer_id != buffer_snapshot.remote_id() { to_remove.push(*existing_id); @@ -1970,7 +1970,7 @@ impl MultiBuffer { let mut prev_locator = snapshot.excerpt_locator_for_id(prev_excerpt_id).clone(); let mut new_excerpt_ids = mem::take(&mut snapshot.excerpt_ids); let mut cursor = snapshot.excerpts.cursor::>(&()); - let mut new_excerpts = cursor.slice(&prev_locator, Bias::Right, &()); + let mut new_excerpts = cursor.slice(&prev_locator, Bias::Right); prev_locator = cursor.start().unwrap_or(Locator::min_ref()).clone(); let edit_start = ExcerptOffset::new(new_excerpts.summary().text.len); @@ -2019,7 +2019,7 @@ impl MultiBuffer { let edit_end = ExcerptOffset::new(new_excerpts.summary().text.len); - let suffix = cursor.suffix(&()); + let suffix = cursor.suffix(); let changed_trailing_excerpt = suffix.is_empty(); new_excerpts.append(suffix, &()); drop(cursor); @@ -2104,7 +2104,7 @@ impl MultiBuffer { .into_iter() .flatten() { - cursor.seek_forward(&Some(locator), Bias::Left, &()); + cursor.seek_forward(&Some(locator), Bias::Left); if let Some(excerpt) = cursor.item() { if excerpt.locator == *locator { excerpts.push((excerpt.id, excerpt.range.clone())); @@ -2124,25 +2124,25 @@ impl MultiBuffer { let mut diff_transforms = snapshot .diff_transforms .cursor::<(ExcerptDimension, OutputDimension)>(&()); - diff_transforms.next(&()); + diff_transforms.next(); let locators = buffers .get(&buffer_id) .into_iter() .flat_map(|state| &state.excerpts); let mut result = Vec::new(); for locator in locators { - excerpts.seek_forward(&Some(locator), Bias::Left, &()); + excerpts.seek_forward(&Some(locator), Bias::Left); if let Some(excerpt) = excerpts.item() { if excerpt.locator == *locator { let excerpt_start = excerpts.start().1.clone(); let excerpt_end = ExcerptDimension(excerpt_start.0 + excerpt.text_summary.lines); - diff_transforms.seek_forward(&excerpt_start, Bias::Left, &()); + diff_transforms.seek_forward(&excerpt_start, Bias::Left); let overshoot = excerpt_start.0 - diff_transforms.start().0.0; let start = diff_transforms.start().1.0 + overshoot; - diff_transforms.seek_forward(&excerpt_end, Bias::Right, &()); + diff_transforms.seek_forward(&excerpt_end, Bias::Right); let overshoot = excerpt_end.0 - diff_transforms.start().0.0; let end = diff_transforms.start().1.0 + overshoot; @@ -2290,7 +2290,7 @@ impl MultiBuffer { self.paths_by_excerpt.remove(&excerpt_id); // Seek to the next excerpt to remove, preserving any preceding excerpts. let locator = snapshot.excerpt_locator_for_id(excerpt_id); - new_excerpts.append(cursor.slice(&Some(locator), Bias::Left, &()), &()); + new_excerpts.append(cursor.slice(&Some(locator), Bias::Left), &()); if let Some(mut excerpt) = cursor.item() { if excerpt.id != excerpt_id { @@ -2311,7 +2311,7 @@ impl MultiBuffer { removed_buffer_ids.push(excerpt.buffer_id); } } - cursor.next(&()); + cursor.next(); // Skip over any subsequent excerpts that are also removed. if let Some(&next_excerpt_id) = excerpt_ids.peek() { @@ -2344,7 +2344,7 @@ impl MultiBuffer { }); } } - let suffix = cursor.suffix(&()); + let suffix = cursor.suffix(); let changed_trailing_excerpt = suffix.is_empty(); new_excerpts.append(suffix, &()); drop(cursor); @@ -2493,7 +2493,7 @@ impl MultiBuffer { let mut cursor = snapshot .excerpts .cursor::<(Option<&Locator>, ExcerptOffset)>(&()); - cursor.seek_forward(&Some(locator), Bias::Left, &()); + cursor.seek_forward(&Some(locator), Bias::Left); if let Some(excerpt) = cursor.item() { if excerpt.locator == *locator { let excerpt_buffer_range = excerpt.range.context.to_offset(&excerpt.buffer); @@ -2724,7 +2724,7 @@ impl MultiBuffer { let snapshot = self.read(cx); let mut cursor = snapshot.diff_transforms.cursor::(&()); let offset_range = range.to_offset(&snapshot); - cursor.seek(&offset_range.start, Bias::Left, &()); + cursor.seek(&offset_range.start, Bias::Left); while let Some(item) = cursor.item() { if *cursor.start() >= offset_range.end && *cursor.start() > offset_range.start { break; @@ -2732,7 +2732,7 @@ impl MultiBuffer { if item.hunk_info().is_some() { return true; } - cursor.next(&()); + cursor.next(); } false } @@ -2746,7 +2746,7 @@ impl MultiBuffer { let end = snapshot.point_to_offset(Point::new(range.end.row + 1, 0)); let start = start.saturating_sub(1); let end = snapshot.len().min(end + 1); - cursor.seek(&start, Bias::Right, &()); + cursor.seek(&start, Bias::Right); while let Some(item) = cursor.item() { if *cursor.start() >= end { break; @@ -2754,7 +2754,7 @@ impl MultiBuffer { if item.hunk_info().is_some() { return true; } - cursor.next(&()); + cursor.next(); } } false @@ -2848,7 +2848,7 @@ impl MultiBuffer { .cursor::<(Option<&Locator>, ExcerptOffset)>(&()); let mut edits = Vec::>::new(); - let prefix = cursor.slice(&Some(locator), Bias::Left, &()); + let prefix = cursor.slice(&Some(locator), Bias::Left); new_excerpts.append(prefix, &()); let mut excerpt = cursor.item().unwrap().clone(); @@ -2883,9 +2883,9 @@ impl MultiBuffer { new_excerpts.push(excerpt, &()); - cursor.next(&()); + cursor.next(); - new_excerpts.append(cursor.suffix(&()), &()); + new_excerpts.append(cursor.suffix(), &()); drop(cursor); snapshot.excerpts = new_excerpts; @@ -2925,7 +2925,7 @@ impl MultiBuffer { let mut edits = Vec::>::new(); for locator in &locators { - let prefix = cursor.slice(&Some(locator), Bias::Left, &()); + let prefix = cursor.slice(&Some(locator), Bias::Left); new_excerpts.append(prefix, &()); let mut excerpt = cursor.item().unwrap().clone(); @@ -2987,10 +2987,10 @@ impl MultiBuffer { new_excerpts.push(excerpt, &()); - cursor.next(&()); + cursor.next(); } - new_excerpts.append(cursor.suffix(&()), &()); + new_excerpts.append(cursor.suffix(), &()); drop(cursor); snapshot.excerpts = new_excerpts; @@ -3070,7 +3070,7 @@ impl MultiBuffer { .cursor::<(Option<&Locator>, ExcerptOffset)>(&()); for (locator, buffer, buffer_edited) in excerpts_to_edit { - new_excerpts.append(cursor.slice(&Some(locator), Bias::Left, &()), &()); + new_excerpts.append(cursor.slice(&Some(locator), Bias::Left), &()); let old_excerpt = cursor.item().unwrap(); let buffer = buffer.read(cx); let buffer_id = buffer.remote_id(); @@ -3112,9 +3112,9 @@ impl MultiBuffer { } new_excerpts.push(new_excerpt, &()); - cursor.next(&()); + cursor.next(); } - new_excerpts.append(cursor.suffix(&()), &()); + new_excerpts.append(cursor.suffix(), &()); drop(cursor); snapshot.excerpts = new_excerpts; @@ -3145,23 +3145,22 @@ impl MultiBuffer { let mut excerpt_edits = excerpt_edits.into_iter().peekable(); while let Some(edit) = excerpt_edits.next() { - excerpts.seek_forward(&edit.new.start, Bias::Right, &()); + excerpts.seek_forward(&edit.new.start, Bias::Right); if excerpts.item().is_none() && *excerpts.start() == edit.new.start { - excerpts.prev(&()); + excerpts.prev(); } // Keep any transforms that are before the edit. if at_transform_boundary { at_transform_boundary = false; - let transforms_before_edit = - old_diff_transforms.slice(&edit.old.start, Bias::Left, &()); + let transforms_before_edit = old_diff_transforms.slice(&edit.old.start, Bias::Left); self.append_diff_transforms(&mut new_diff_transforms, transforms_before_edit); if let Some(transform) = old_diff_transforms.item() { - if old_diff_transforms.end(&()).0 == edit.old.start + if old_diff_transforms.end().0 == edit.old.start && old_diff_transforms.start().0 < edit.old.start { self.push_diff_transform(&mut new_diff_transforms, transform.clone()); - old_diff_transforms.next(&()); + old_diff_transforms.next(); } } } @@ -3203,7 +3202,7 @@ impl MultiBuffer { // then recreate the content up to the end of this transform, to prepare // for reusing additional slices of the old transforms. if excerpt_edits.peek().map_or(true, |next_edit| { - next_edit.old.start >= old_diff_transforms.end(&()).0 + next_edit.old.start >= old_diff_transforms.end().0 }) { let keep_next_old_transform = (old_diff_transforms.start().0 >= edit.old.end) && match old_diff_transforms.item() { @@ -3218,8 +3217,8 @@ impl MultiBuffer { let mut excerpt_offset = edit.new.end; if !keep_next_old_transform { - excerpt_offset += old_diff_transforms.end(&()).0 - edit.old.end; - old_diff_transforms.next(&()); + excerpt_offset += old_diff_transforms.end().0 - edit.old.end; + old_diff_transforms.next(); } old_expanded_hunks.clear(); @@ -3234,7 +3233,7 @@ impl MultiBuffer { } // Keep any transforms that are after the last edit. - self.append_diff_transforms(&mut new_diff_transforms, old_diff_transforms.suffix(&())); + self.append_diff_transforms(&mut new_diff_transforms, old_diff_transforms.suffix()); // Ensure there's always at least one buffer content transform. if new_diff_transforms.is_empty() { @@ -3283,10 +3282,10 @@ impl MultiBuffer { ); old_expanded_hunks.insert(hunk_info); } - if old_diff_transforms.end(&()).0 > edit.old.end { + if old_diff_transforms.end().0 > edit.old.end { break; } - old_diff_transforms.next(&()); + old_diff_transforms.next(); } // Avoid querying diff hunks if there's no possibility of hunks being expanded. @@ -3413,8 +3412,8 @@ impl MultiBuffer { } } - if excerpts.end(&()) <= edit.new.end { - excerpts.next(&()); + if excerpts.end() <= edit.new.end { + excerpts.next(); } else { break; } @@ -3439,9 +3438,9 @@ impl MultiBuffer { *summary, ) { let mut cursor = subtree.cursor::<()>(&()); - cursor.next(&()); - cursor.next(&()); - new_transforms.append(cursor.suffix(&()), &()); + cursor.next(); + cursor.next(); + new_transforms.append(cursor.suffix(), &()); return; } } @@ -4715,14 +4714,14 @@ impl MultiBufferSnapshot { { let range = range.start.to_offset(self)..range.end.to_offset(self); let mut cursor = self.diff_transforms.cursor::<(usize, ExcerptOffset)>(&()); - cursor.seek(&range.start, Bias::Right, &()); + cursor.seek(&range.start, Bias::Right); let Some(first_transform) = cursor.item() else { return D::from_text_summary(&TextSummary::default()); }; let diff_transform_start = cursor.start().0; - let diff_transform_end = cursor.end(&()).0; + let diff_transform_end = cursor.end().0; let diff_start = range.start; let start_overshoot = diff_start - diff_transform_start; let end_overshoot = std::cmp::min(range.end, diff_transform_end) - diff_transform_start; @@ -4765,12 +4764,10 @@ impl MultiBufferSnapshot { return result; } - cursor.next(&()); - result.add_assign(&D::from_text_summary(&cursor.summary( - &range.end, - Bias::Right, - &(), - ))); + cursor.next(); + result.add_assign(&D::from_text_summary( + &cursor.summary(&range.end, Bias::Right), + )); let Some(last_transform) = cursor.item() else { return result; @@ -4813,9 +4810,9 @@ impl MultiBufferSnapshot { // let mut range = range.start..range.end; let mut summary = D::zero(&()); let mut cursor = self.excerpts.cursor::(&()); - cursor.seek(&range.start, Bias::Right, &()); + cursor.seek(&range.start, Bias::Right); if let Some(excerpt) = cursor.item() { - let mut end_before_newline = cursor.end(&()); + let mut end_before_newline = cursor.end(); if excerpt.has_trailing_newline { end_before_newline -= ExcerptOffset::new(1); } @@ -4834,13 +4831,13 @@ impl MultiBufferSnapshot { summary.add_assign(&D::from_text_summary(&TextSummary::from("\n"))); } - cursor.next(&()); + cursor.next(); } if range.end > *cursor.start() { summary.add_assign( &cursor - .summary::<_, ExcerptDimension>(&range.end, Bias::Right, &()) + .summary::<_, ExcerptDimension>(&range.end, Bias::Right) .0, ); if let Some(excerpt) = cursor.item() { @@ -4876,11 +4873,11 @@ impl MultiBufferSnapshot { D: TextDimension + Ord + Sub, { loop { - let transform_end_position = diff_transforms.end(&()).0.0; + let transform_end_position = diff_transforms.end().0.0; let at_transform_end = excerpt_position == transform_end_position && diff_transforms.item().is_some(); if at_transform_end && anchor.text_anchor.bias == Bias::Right { - diff_transforms.next(&()); + diff_transforms.next(); continue; } @@ -4906,7 +4903,7 @@ impl MultiBufferSnapshot { ); position.add_assign(&position_in_hunk); } else if at_transform_end { - diff_transforms.next(&()); + diff_transforms.next(); continue; } } @@ -4915,7 +4912,7 @@ impl MultiBufferSnapshot { } _ => { if at_transform_end && anchor.diff_base_anchor.is_some() { - diff_transforms.next(&()); + diff_transforms.next(); continue; } let overshoot = excerpt_position - diff_transforms.start().0.0; @@ -4933,9 +4930,9 @@ impl MultiBufferSnapshot { .cursor::<(Option<&Locator>, ExcerptOffset)>(&()); let locator = self.excerpt_locator_for_id(anchor.excerpt_id); - cursor.seek(&Some(locator), Bias::Left, &()); + cursor.seek(&Some(locator), Bias::Left); if cursor.item().is_none() { - cursor.next(&()); + cursor.next(); } let mut position = cursor.start().1; @@ -4975,7 +4972,7 @@ impl MultiBufferSnapshot { let mut diff_transforms_cursor = self .diff_transforms .cursor::<(ExcerptDimension, OutputDimension)>(&()); - diff_transforms_cursor.next(&()); + diff_transforms_cursor.next(); let mut summaries = Vec::new(); while let Some(anchor) = anchors.peek() { @@ -4990,9 +4987,9 @@ impl MultiBufferSnapshot { }); let locator = self.excerpt_locator_for_id(excerpt_id); - cursor.seek_forward(locator, Bias::Left, &()); + cursor.seek_forward(locator, Bias::Left); if cursor.item().is_none() { - cursor.next(&()); + cursor.next(); } let excerpt_start_position = D::from_text_summary(&cursor.start().text); @@ -5022,11 +5019,8 @@ impl MultiBufferSnapshot { } if position > diff_transforms_cursor.start().0.0 { - diff_transforms_cursor.seek_forward( - &ExcerptDimension(position), - Bias::Left, - &(), - ); + diff_transforms_cursor + .seek_forward(&ExcerptDimension(position), Bias::Left); } summaries.push(self.resolve_summary_for_anchor( @@ -5036,11 +5030,8 @@ impl MultiBufferSnapshot { )); } } else { - diff_transforms_cursor.seek_forward( - &ExcerptDimension(excerpt_start_position), - Bias::Left, - &(), - ); + diff_transforms_cursor + .seek_forward(&ExcerptDimension(excerpt_start_position), Bias::Left); let position = self.resolve_summary_for_anchor( &Anchor::max(), excerpt_start_position, @@ -5099,7 +5090,7 @@ impl MultiBufferSnapshot { { let mut anchors = anchors.into_iter().enumerate().peekable(); let mut cursor = self.excerpts.cursor::>(&()); - cursor.next(&()); + cursor.next(); let mut result = Vec::new(); @@ -5108,10 +5099,10 @@ impl MultiBufferSnapshot { // Find the location where this anchor's excerpt should be. let old_locator = self.excerpt_locator_for_id(old_excerpt_id); - cursor.seek_forward(&Some(old_locator), Bias::Left, &()); + cursor.seek_forward(&Some(old_locator), Bias::Left); if cursor.item().is_none() { - cursor.next(&()); + cursor.next(); } let next_excerpt = cursor.item(); @@ -5211,13 +5202,13 @@ impl MultiBufferSnapshot { // Find the given position in the diff transforms. Determine the corresponding // offset in the excerpts, and whether the position is within a deleted hunk. let mut diff_transforms = self.diff_transforms.cursor::<(usize, ExcerptOffset)>(&()); - diff_transforms.seek(&offset, Bias::Right, &()); + diff_transforms.seek(&offset, Bias::Right); if offset == diff_transforms.start().0 && bias == Bias::Left { if let Some(prev_item) = diff_transforms.prev_item() { match prev_item { DiffTransform::DeletedHunk { .. } => { - diff_transforms.prev(&()); + diff_transforms.prev(); } _ => {} } @@ -5260,13 +5251,13 @@ impl MultiBufferSnapshot { let mut excerpts = self .excerpts .cursor::<(ExcerptOffset, Option)>(&()); - excerpts.seek(&excerpt_offset, Bias::Right, &()); + excerpts.seek(&excerpt_offset, Bias::Right); if excerpts.item().is_none() && excerpt_offset == excerpts.start().0 && bias == Bias::Left { - excerpts.prev(&()); + excerpts.prev(); } if let Some(excerpt) = excerpts.item() { let mut overshoot = excerpt_offset.saturating_sub(excerpts.start().0).value; - if excerpt.has_trailing_newline && excerpt_offset == excerpts.end(&()).0 { + if excerpt.has_trailing_newline && excerpt_offset == excerpts.end().0 { overshoot -= 1; bias = Bias::Right; } @@ -5297,7 +5288,7 @@ impl MultiBufferSnapshot { let excerpt_id = self.latest_excerpt_id(excerpt_id); let locator = self.excerpt_locator_for_id(excerpt_id); let mut cursor = self.excerpts.cursor::>(&()); - cursor.seek(locator, Bias::Left, &()); + cursor.seek(locator, Bias::Left); if let Some(excerpt) = cursor.item() { if excerpt.id == excerpt_id { let text_anchor = excerpt.clip_anchor(text_anchor); @@ -5351,13 +5342,13 @@ impl MultiBufferSnapshot { let mut excerpts = self .excerpts .cursor::<(Option<&Locator>, ExcerptDimension)>(&()); - excerpts.seek(&Some(start_locator), Bias::Left, &()); - excerpts.prev(&()); + excerpts.seek(&Some(start_locator), Bias::Left); + excerpts.prev(); let mut diff_transforms = self.diff_transforms.cursor::>(&()); - diff_transforms.seek(&excerpts.start().1, Bias::Left, &()); - if diff_transforms.end(&()).excerpt_dimension < excerpts.start().1 { - diff_transforms.next(&()); + diff_transforms.seek(&excerpts.start().1, Bias::Left); + if diff_transforms.end().excerpt_dimension < excerpts.start().1 { + diff_transforms.next(); } let excerpt = excerpts.item()?; @@ -6193,7 +6184,7 @@ impl MultiBufferSnapshot { Locator::max_ref() } else { let mut cursor = self.excerpt_ids.cursor::(&()); - cursor.seek(&id, Bias::Left, &()); + cursor.seek(&id, Bias::Left); if let Some(entry) = cursor.item() { if entry.id == id { return &entry.locator; @@ -6229,7 +6220,7 @@ impl MultiBufferSnapshot { let mut cursor = self.excerpt_ids.cursor::(&()); for id in sorted_ids { - if cursor.seek_forward(&id, Bias::Left, &()) { + if cursor.seek_forward(&id, Bias::Left) { locators.push(cursor.item().unwrap().locator.clone()); } else { panic!("invalid excerpt id {:?}", id); @@ -6253,16 +6244,16 @@ impl MultiBufferSnapshot { .excerpts .cursor::<(Option<&Locator>, ExcerptDimension)>(&()); let locator = self.excerpt_locator_for_id(excerpt_id); - if cursor.seek(&Some(locator), Bias::Left, &()) { + if cursor.seek(&Some(locator), Bias::Left) { let start = cursor.start().1.clone(); - let end = cursor.end(&()).1; + let end = cursor.end().1; let mut diff_transforms = self .diff_transforms .cursor::<(ExcerptDimension, OutputDimension)>(&()); - diff_transforms.seek(&start, Bias::Left, &()); + diff_transforms.seek(&start, Bias::Left); let overshoot = start.0 - diff_transforms.start().0.0; let start = diff_transforms.start().1.0 + overshoot; - diff_transforms.seek(&end, Bias::Right, &()); + diff_transforms.seek(&end, Bias::Right); let overshoot = end.0 - diff_transforms.start().0.0; let end = diff_transforms.start().1.0 + overshoot; Some(start..end) @@ -6274,7 +6265,7 @@ impl MultiBufferSnapshot { pub fn buffer_range_for_excerpt(&self, excerpt_id: ExcerptId) -> Option> { let mut cursor = self.excerpts.cursor::>(&()); let locator = self.excerpt_locator_for_id(excerpt_id); - if cursor.seek(&Some(locator), Bias::Left, &()) { + if cursor.seek(&Some(locator), Bias::Left) { if let Some(excerpt) = cursor.item() { return Some(excerpt.range.context.clone()); } @@ -6285,7 +6276,7 @@ impl MultiBufferSnapshot { fn excerpt(&self, excerpt_id: ExcerptId) -> Option<&Excerpt> { let mut cursor = self.excerpts.cursor::>(&()); let locator = self.excerpt_locator_for_id(excerpt_id); - cursor.seek(&Some(locator), Bias::Left, &()); + cursor.seek(&Some(locator), Bias::Left); if let Some(excerpt) = cursor.item() { if excerpt.id == excerpt_id { return Some(excerpt); @@ -6333,7 +6324,7 @@ impl MultiBufferSnapshot { let mut cursor = self.excerpts.cursor::(&()); let start_locator = self.excerpt_locator_for_id(range.start.excerpt_id); let end_locator = self.excerpt_locator_for_id(range.end.excerpt_id); - cursor.seek(start_locator, Bias::Left, &()); + cursor.seek(start_locator, Bias::Left); cursor .take_while(move |excerpt| excerpt.locator <= *end_locator) .flat_map(move |excerpt| { @@ -6472,11 +6463,11 @@ where fn seek(&mut self, position: &D) { self.cached_region.take(); self.diff_transforms - .seek(&OutputDimension(*position), Bias::Right, &()); + .seek(&OutputDimension(*position), Bias::Right); if self.diff_transforms.item().is_none() && *position == self.diff_transforms.start().output_dimension.0 { - self.diff_transforms.prev(&()); + self.diff_transforms.prev(); } let mut excerpt_position = self.diff_transforms.start().excerpt_dimension.0; @@ -6486,20 +6477,20 @@ where } self.excerpts - .seek(&ExcerptDimension(excerpt_position), Bias::Right, &()); + .seek(&ExcerptDimension(excerpt_position), Bias::Right); if self.excerpts.item().is_none() && excerpt_position == self.excerpts.start().0 { - self.excerpts.prev(&()); + self.excerpts.prev(); } } fn seek_forward(&mut self, position: &D) { self.cached_region.take(); self.diff_transforms - .seek_forward(&OutputDimension(*position), Bias::Right, &()); + .seek_forward(&OutputDimension(*position), Bias::Right); if self.diff_transforms.item().is_none() && *position == self.diff_transforms.start().output_dimension.0 { - self.diff_transforms.prev(&()); + self.diff_transforms.prev(); } let overshoot = *position - self.diff_transforms.start().output_dimension.0; @@ -6509,31 +6500,30 @@ where } self.excerpts - .seek_forward(&ExcerptDimension(excerpt_position), Bias::Right, &()); + .seek_forward(&ExcerptDimension(excerpt_position), Bias::Right); if self.excerpts.item().is_none() && excerpt_position == self.excerpts.start().0 { - self.excerpts.prev(&()); + self.excerpts.prev(); } } fn next_excerpt(&mut self) { - self.excerpts.next(&()); + self.excerpts.next(); self.seek_to_start_of_current_excerpt(); } fn prev_excerpt(&mut self) { - self.excerpts.prev(&()); + self.excerpts.prev(); self.seek_to_start_of_current_excerpt(); } fn seek_to_start_of_current_excerpt(&mut self) { self.cached_region.take(); - self.diff_transforms - .seek(self.excerpts.start(), Bias::Left, &()); - if self.diff_transforms.end(&()).excerpt_dimension == *self.excerpts.start() + self.diff_transforms.seek(self.excerpts.start(), Bias::Left); + if self.diff_transforms.end().excerpt_dimension == *self.excerpts.start() && self.diff_transforms.start().excerpt_dimension < *self.excerpts.start() && self.diff_transforms.next_item().is_some() { - self.diff_transforms.next(&()); + self.diff_transforms.next(); } } @@ -6541,18 +6531,18 @@ where self.cached_region.take(); match self .diff_transforms - .end(&()) + .end() .excerpt_dimension - .cmp(&self.excerpts.end(&())) + .cmp(&self.excerpts.end()) { - cmp::Ordering::Less => self.diff_transforms.next(&()), - cmp::Ordering::Greater => self.excerpts.next(&()), + cmp::Ordering::Less => self.diff_transforms.next(), + cmp::Ordering::Greater => self.excerpts.next(), cmp::Ordering::Equal => { - self.diff_transforms.next(&()); - if self.diff_transforms.end(&()).excerpt_dimension > self.excerpts.end(&()) + self.diff_transforms.next(); + if self.diff_transforms.end().excerpt_dimension > self.excerpts.end() || self.diff_transforms.item().is_none() { - self.excerpts.next(&()); + self.excerpts.next(); } else if let Some(DiffTransform::DeletedHunk { hunk_info, .. }) = self.diff_transforms.item() { @@ -6561,7 +6551,7 @@ where .item() .map_or(false, |excerpt| excerpt.id != hunk_info.excerpt_id) { - self.excerpts.next(&()); + self.excerpts.next(); } } } @@ -6576,14 +6566,14 @@ where .excerpt_dimension .cmp(self.excerpts.start()) { - cmp::Ordering::Less => self.excerpts.prev(&()), - cmp::Ordering::Greater => self.diff_transforms.prev(&()), + cmp::Ordering::Less => self.excerpts.prev(), + cmp::Ordering::Greater => self.diff_transforms.prev(), cmp::Ordering::Equal => { - self.diff_transforms.prev(&()); + self.diff_transforms.prev(); if self.diff_transforms.start().excerpt_dimension < *self.excerpts.start() || self.diff_transforms.item().is_none() { - self.excerpts.prev(&()); + self.excerpts.prev(); } } } @@ -6603,9 +6593,9 @@ where return true; } - self.diff_transforms.prev(&()); + self.diff_transforms.prev(); let prev_transform = self.diff_transforms.item(); - self.diff_transforms.next(&()); + self.diff_transforms.next(); prev_transform.map_or(true, |next_transform| { matches!(next_transform, DiffTransform::BufferContent { .. }) @@ -6613,9 +6603,9 @@ where } fn is_at_end_of_excerpt(&mut self) -> bool { - if self.diff_transforms.end(&()).excerpt_dimension < self.excerpts.end(&()) { + if self.diff_transforms.end().excerpt_dimension < self.excerpts.end() { return false; - } else if self.diff_transforms.end(&()).excerpt_dimension > self.excerpts.end(&()) + } else if self.diff_transforms.end().excerpt_dimension > self.excerpts.end() || self.diff_transforms.item().is_none() { return true; @@ -6636,7 +6626,7 @@ where let buffer = &excerpt.buffer; let buffer_context_start = excerpt.range.context.start.summary::(buffer); let mut buffer_start = buffer_context_start; - let overshoot = self.diff_transforms.end(&()).excerpt_dimension.0 - self.excerpts.start().0; + let overshoot = self.diff_transforms.end().excerpt_dimension.0 - self.excerpts.start().0; buffer_start.add_assign(&overshoot); Some(buffer_start) } @@ -6659,7 +6649,7 @@ where let mut buffer_end = buffer_start; buffer_end.add_assign(&buffer_range_len); let start = self.diff_transforms.start().output_dimension.0; - let end = self.diff_transforms.end(&()).output_dimension.0; + let end = self.diff_transforms.end().output_dimension.0; return Some(MultiBufferRegion { buffer, excerpt, @@ -6693,16 +6683,16 @@ where let mut end; let mut buffer_end; let has_trailing_newline; - if self.diff_transforms.end(&()).excerpt_dimension.0 < self.excerpts.end(&()).0 { + if self.diff_transforms.end().excerpt_dimension.0 < self.excerpts.end().0 { let overshoot = - self.diff_transforms.end(&()).excerpt_dimension.0 - self.excerpts.start().0; - end = self.diff_transforms.end(&()).output_dimension.0; + self.diff_transforms.end().excerpt_dimension.0 - self.excerpts.start().0; + end = self.diff_transforms.end().output_dimension.0; buffer_end = buffer_context_start; buffer_end.add_assign(&overshoot); has_trailing_newline = false; } else { let overshoot = - self.excerpts.end(&()).0 - self.diff_transforms.start().excerpt_dimension.0; + self.excerpts.end().0 - self.diff_transforms.start().excerpt_dimension.0; end = self.diff_transforms.start().output_dimension.0; end.add_assign(&overshoot); buffer_end = excerpt.range.context.end.summary::(buffer); @@ -7086,11 +7076,11 @@ impl<'a> MultiBufferExcerpt<'a> { /// Maps a range within the [`MultiBuffer`] to a range within the [`Buffer`] pub fn map_range_to_buffer(&mut self, range: Range) -> Range { self.diff_transforms - .seek(&OutputDimension(range.start), Bias::Right, &()); + .seek(&OutputDimension(range.start), Bias::Right); let start = self.map_offset_to_buffer_internal(range.start); let end = if range.end > range.start { self.diff_transforms - .seek_forward(&OutputDimension(range.end), Bias::Right, &()); + .seek_forward(&OutputDimension(range.end), Bias::Right); self.map_offset_to_buffer_internal(range.end) } else { start @@ -7123,7 +7113,7 @@ impl<'a> MultiBufferExcerpt<'a> { } let overshoot = buffer_range.start - self.buffer_offset; let excerpt_offset = ExcerptDimension(self.excerpt_offset.0 + overshoot); - self.diff_transforms.seek(&excerpt_offset, Bias::Right, &()); + self.diff_transforms.seek(&excerpt_offset, Bias::Right); if excerpt_offset.0 < self.diff_transforms.start().excerpt_dimension.0 { log::warn!( "Attempting to map a range from a buffer offset that starts before the current buffer offset" @@ -7137,7 +7127,7 @@ impl<'a> MultiBufferExcerpt<'a> { let overshoot = buffer_range.end - self.buffer_offset; let excerpt_offset = ExcerptDimension(self.excerpt_offset.0 + overshoot); self.diff_transforms - .seek_forward(&excerpt_offset, Bias::Right, &()); + .seek_forward(&excerpt_offset, Bias::Right); let overshoot = excerpt_offset.0 - self.diff_transforms.start().excerpt_dimension.0; self.diff_transforms.start().output_dimension.0 + overshoot } else { @@ -7509,7 +7499,7 @@ impl Iterator for MultiBufferRows<'_> { if let Some(next_region) = self.cursor.region() { region = next_region; } else { - if self.point == self.cursor.diff_transforms.end(&()).output_dimension.0 { + if self.point == self.cursor.diff_transforms.end().output_dimension.0 { let multibuffer_row = MultiBufferRow(self.point.row); let last_excerpt = self .cursor @@ -7615,14 +7605,14 @@ impl<'a> MultiBufferChunks<'a> { } pub fn seek(&mut self, range: Range) { - self.diff_transforms.seek(&range.end, Bias::Right, &()); + self.diff_transforms.seek(&range.end, Bias::Right); let mut excerpt_end = self.diff_transforms.start().1; if let Some(DiffTransform::BufferContent { .. }) = self.diff_transforms.item() { let overshoot = range.end - self.diff_transforms.start().0; excerpt_end.value += overshoot; } - self.diff_transforms.seek(&range.start, Bias::Right, &()); + self.diff_transforms.seek(&range.start, Bias::Right); let mut excerpt_start = self.diff_transforms.start().1; if let Some(DiffTransform::BufferContent { .. }) = self.diff_transforms.item() { let overshoot = range.start - self.diff_transforms.start().0; @@ -7636,7 +7626,7 @@ impl<'a> MultiBufferChunks<'a> { fn seek_to_excerpt_offset_range(&mut self, new_range: Range) { self.excerpt_offset_range = new_range.clone(); - self.excerpts.seek(&new_range.start, Bias::Right, &()); + self.excerpts.seek(&new_range.start, Bias::Right); if let Some(excerpt) = self.excerpts.item() { let excerpt_start = *self.excerpts.start(); if let Some(excerpt_chunks) = self @@ -7669,7 +7659,7 @@ impl<'a> MultiBufferChunks<'a> { self.excerpt_offset_range.start.value += chunk.text.len(); return Some(chunk); } else { - self.excerpts.next(&()); + self.excerpts.next(); let excerpt = self.excerpts.item()?; self.excerpt_chunks = Some(excerpt.chunks_in_range( 0..(self.excerpt_offset_range.end - *self.excerpts.start()).value, @@ -7712,12 +7702,12 @@ impl<'a> Iterator for MultiBufferChunks<'a> { if self.range.start >= self.range.end { return None; } - if self.range.start == self.diff_transforms.end(&()).0 { - self.diff_transforms.next(&()); + if self.range.start == self.diff_transforms.end().0 { + self.diff_transforms.next(); } let diff_transform_start = self.diff_transforms.start().0; - let diff_transform_end = self.diff_transforms.end(&()).0; + let diff_transform_end = self.diff_transforms.end().0; debug_assert!(self.range.start < diff_transform_end); let diff_transform = self.diff_transforms.item()?; diff --git a/crates/notifications/src/notification_store.rs b/crates/notifications/src/notification_store.rs index c2f18e5700..0329a53cc7 100644 --- a/crates/notifications/src/notification_store.rs +++ b/crates/notifications/src/notification_store.rs @@ -132,12 +132,12 @@ impl NotificationStore { } let ix = count - 1 - ix; let mut cursor = self.notifications.cursor::(&()); - cursor.seek(&Count(ix), Bias::Right, &()); + cursor.seek(&Count(ix), Bias::Right); cursor.item() } pub fn notification_for_id(&self, id: u64) -> Option<&NotificationEntry> { let mut cursor = self.notifications.cursor::(&()); - cursor.seek(&NotificationId(id), Bias::Left, &()); + cursor.seek(&NotificationId(id), Bias::Left); if let Some(item) = cursor.item() { if item.id == id { return Some(item); @@ -365,7 +365,7 @@ impl NotificationStore { let mut old_range = 0..0; for (i, (id, new_notification)) in notifications.into_iter().enumerate() { - new_notifications.append(cursor.slice(&NotificationId(id), Bias::Left, &()), &()); + new_notifications.append(cursor.slice(&NotificationId(id), Bias::Left), &()); if i == 0 { old_range.start = cursor.start().1.0; @@ -374,7 +374,7 @@ impl NotificationStore { let old_notification = cursor.item(); if let Some(old_notification) = old_notification { if old_notification.id == id { - cursor.next(&()); + cursor.next(); if let Some(new_notification) = &new_notification { if new_notification.is_read { @@ -403,7 +403,7 @@ impl NotificationStore { old_range.end = cursor.start().1.0; let new_count = new_notifications.summary().count - old_range.start; - new_notifications.append(cursor.suffix(&()), &()); + new_notifications.append(cursor.suffix(), &()); drop(cursor); self.notifications = new_notifications; diff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rs index 6e3d27deff..eb16446daf 100644 --- a/crates/project/src/git_store.rs +++ b/crates/project/src/git_store.rs @@ -4279,7 +4279,7 @@ impl Repository { for (repo_path, status) in &*statuses.entries { changed_paths.remove(repo_path); - if cursor.seek_forward(&PathTarget::Path(repo_path), Bias::Left, &()) { + if cursor.seek_forward(&PathTarget::Path(repo_path), Bias::Left) { if cursor.item().is_some_and(|entry| entry.status == *status) { continue; } @@ -4292,7 +4292,7 @@ impl Repository { } let mut cursor = prev_statuses.cursor::(&()); for path in changed_paths.into_iter() { - if cursor.seek_forward(&PathTarget::Path(&path), Bias::Left, &()) { + if cursor.seek_forward(&PathTarget::Path(&path), Bias::Left) { changed_path_statuses.push(Edit::Remove(PathKey(path.0))); } } diff --git a/crates/project/src/git_store/git_traversal.rs b/crates/project/src/git_store/git_traversal.rs index 68ed03cfe9..cd173d5714 100644 --- a/crates/project/src/git_store/git_traversal.rs +++ b/crates/project/src/git_store/git_traversal.rs @@ -72,14 +72,13 @@ impl<'a> GitTraversal<'a> { if entry.is_dir() { let mut statuses = statuses.clone(); - statuses.seek_forward(&PathTarget::Path(repo_path.as_ref()), Bias::Left, &()); - let summary = - statuses.summary(&PathTarget::Successor(repo_path.as_ref()), Bias::Left, &()); + statuses.seek_forward(&PathTarget::Path(repo_path.as_ref()), Bias::Left); + let summary = statuses.summary(&PathTarget::Successor(repo_path.as_ref()), Bias::Left); self.current_entry_summary = Some(summary); } else if entry.is_file() { // For a file entry, park the cursor on the corresponding status - if statuses.seek_forward(&PathTarget::Path(repo_path.as_ref()), Bias::Left, &()) { + if statuses.seek_forward(&PathTarget::Path(repo_path.as_ref()), Bias::Left) { // TODO: Investigate statuses.item() being None here. self.current_entry_summary = statuses.item().map(|item| item.status.into()); } else { diff --git a/crates/rope/src/rope.rs b/crates/rope/src/rope.rs index 535b863b7d..515cd71331 100644 --- a/crates/rope/src/rope.rs +++ b/crates/rope/src/rope.rs @@ -41,9 +41,9 @@ impl Rope { self.push_chunk(chunk.as_slice()); let mut chunks = rope.chunks.cursor::<()>(&()); - chunks.next(&()); - chunks.next(&()); - self.chunks.append(chunks.suffix(&()), &()); + chunks.next(); + chunks.next(); + self.chunks.append(chunks.suffix(), &()); self.check_invariants(); return; } @@ -283,7 +283,7 @@ impl Rope { return self.summary().len_utf16; } let mut cursor = self.chunks.cursor::<(usize, OffsetUtf16)>(&()); - cursor.seek(&offset, Bias::Left, &()); + cursor.seek(&offset, Bias::Left); let overshoot = offset - cursor.start().0; cursor.start().1 + cursor.item().map_or(Default::default(), |chunk| { @@ -296,7 +296,7 @@ impl Rope { return self.summary().len; } let mut cursor = self.chunks.cursor::<(OffsetUtf16, usize)>(&()); - cursor.seek(&offset, Bias::Left, &()); + cursor.seek(&offset, Bias::Left); let overshoot = offset - cursor.start().0; cursor.start().1 + cursor.item().map_or(Default::default(), |chunk| { @@ -309,7 +309,7 @@ impl Rope { return self.summary().lines; } let mut cursor = self.chunks.cursor::<(usize, Point)>(&()); - cursor.seek(&offset, Bias::Left, &()); + cursor.seek(&offset, Bias::Left); let overshoot = offset - cursor.start().0; cursor.start().1 + cursor.item().map_or(Point::zero(), |chunk| { @@ -322,7 +322,7 @@ impl Rope { return self.summary().lines_utf16(); } let mut cursor = self.chunks.cursor::<(usize, PointUtf16)>(&()); - cursor.seek(&offset, Bias::Left, &()); + cursor.seek(&offset, Bias::Left); let overshoot = offset - cursor.start().0; cursor.start().1 + cursor.item().map_or(PointUtf16::zero(), |chunk| { @@ -335,7 +335,7 @@ impl Rope { return self.summary().lines_utf16(); } let mut cursor = self.chunks.cursor::<(Point, PointUtf16)>(&()); - cursor.seek(&point, Bias::Left, &()); + cursor.seek(&point, Bias::Left); let overshoot = point - cursor.start().0; cursor.start().1 + cursor.item().map_or(PointUtf16::zero(), |chunk| { @@ -348,7 +348,7 @@ impl Rope { return self.summary().len; } let mut cursor = self.chunks.cursor::<(Point, usize)>(&()); - cursor.seek(&point, Bias::Left, &()); + cursor.seek(&point, Bias::Left); let overshoot = point - cursor.start().0; cursor.start().1 + cursor @@ -369,7 +369,7 @@ impl Rope { return self.summary().len; } let mut cursor = self.chunks.cursor::<(PointUtf16, usize)>(&()); - cursor.seek(&point, Bias::Left, &()); + cursor.seek(&point, Bias::Left); let overshoot = point - cursor.start().0; cursor.start().1 + cursor.item().map_or(0, |chunk| { @@ -382,7 +382,7 @@ impl Rope { return self.summary().lines; } let mut cursor = self.chunks.cursor::<(PointUtf16, Point)>(&()); - cursor.seek(&point.0, Bias::Left, &()); + cursor.seek(&point.0, Bias::Left); let overshoot = Unclipped(point.0 - cursor.start().0); cursor.start().1 + cursor.item().map_or(Point::zero(), |chunk| { @@ -392,7 +392,7 @@ impl Rope { pub fn clip_offset(&self, mut offset: usize, bias: Bias) -> usize { let mut cursor = self.chunks.cursor::(&()); - cursor.seek(&offset, Bias::Left, &()); + cursor.seek(&offset, Bias::Left); if let Some(chunk) = cursor.item() { let mut ix = offset - cursor.start(); while !chunk.text.is_char_boundary(ix) { @@ -415,7 +415,7 @@ impl Rope { pub fn clip_offset_utf16(&self, offset: OffsetUtf16, bias: Bias) -> OffsetUtf16 { let mut cursor = self.chunks.cursor::(&()); - cursor.seek(&offset, Bias::Right, &()); + cursor.seek(&offset, Bias::Right); if let Some(chunk) = cursor.item() { let overshoot = offset - cursor.start(); *cursor.start() + chunk.as_slice().clip_offset_utf16(overshoot, bias) @@ -426,7 +426,7 @@ impl Rope { pub fn clip_point(&self, point: Point, bias: Bias) -> Point { let mut cursor = self.chunks.cursor::(&()); - cursor.seek(&point, Bias::Right, &()); + cursor.seek(&point, Bias::Right); if let Some(chunk) = cursor.item() { let overshoot = point - cursor.start(); *cursor.start() + chunk.as_slice().clip_point(overshoot, bias) @@ -437,7 +437,7 @@ impl Rope { pub fn clip_point_utf16(&self, point: Unclipped, bias: Bias) -> PointUtf16 { let mut cursor = self.chunks.cursor::(&()); - cursor.seek(&point.0, Bias::Right, &()); + cursor.seek(&point.0, Bias::Right); if let Some(chunk) = cursor.item() { let overshoot = Unclipped(point.0 - cursor.start()); *cursor.start() + chunk.as_slice().clip_point_utf16(overshoot, bias) @@ -450,10 +450,6 @@ impl Rope { self.clip_point(Point::new(row, u32::MAX), Bias::Left) .column } - - pub fn ptr_eq(&self, other: &Self) -> bool { - self.chunks.ptr_eq(&other.chunks) - } } impl<'a> From<&'a str> for Rope { @@ -514,7 +510,7 @@ pub struct Cursor<'a> { impl<'a> Cursor<'a> { pub fn new(rope: &'a Rope, offset: usize) -> Self { let mut chunks = rope.chunks.cursor(&()); - chunks.seek(&offset, Bias::Right, &()); + chunks.seek(&offset, Bias::Right); Self { rope, chunks, @@ -525,7 +521,7 @@ impl<'a> Cursor<'a> { pub fn seek_forward(&mut self, end_offset: usize) { debug_assert!(end_offset >= self.offset); - self.chunks.seek_forward(&end_offset, Bias::Right, &()); + self.chunks.seek_forward(&end_offset, Bias::Right); self.offset = end_offset; } @@ -540,14 +536,14 @@ impl<'a> Cursor<'a> { let mut slice = Rope::new(); if let Some(start_chunk) = self.chunks.item() { let start_ix = self.offset - self.chunks.start(); - let end_ix = cmp::min(end_offset, self.chunks.end(&())) - self.chunks.start(); + let end_ix = cmp::min(end_offset, self.chunks.end()) - self.chunks.start(); slice.push_chunk(start_chunk.slice(start_ix..end_ix)); } - if end_offset > self.chunks.end(&()) { - self.chunks.next(&()); + if end_offset > self.chunks.end() { + self.chunks.next(); slice.append(Rope { - chunks: self.chunks.slice(&end_offset, Bias::Right, &()), + chunks: self.chunks.slice(&end_offset, Bias::Right), }); if let Some(end_chunk) = self.chunks.item() { let end_ix = end_offset - self.chunks.start(); @@ -565,13 +561,13 @@ impl<'a> Cursor<'a> { let mut summary = D::zero(&()); if let Some(start_chunk) = self.chunks.item() { let start_ix = self.offset - self.chunks.start(); - let end_ix = cmp::min(end_offset, self.chunks.end(&())) - self.chunks.start(); + let end_ix = cmp::min(end_offset, self.chunks.end()) - self.chunks.start(); summary.add_assign(&D::from_chunk(start_chunk.slice(start_ix..end_ix))); } - if end_offset > self.chunks.end(&()) { - self.chunks.next(&()); - summary.add_assign(&self.chunks.summary(&end_offset, Bias::Right, &())); + if end_offset > self.chunks.end() { + self.chunks.next(); + summary.add_assign(&self.chunks.summary(&end_offset, Bias::Right)); if let Some(end_chunk) = self.chunks.item() { let end_ix = end_offset - self.chunks.start(); summary.add_assign(&D::from_chunk(end_chunk.slice(0..end_ix))); @@ -603,10 +599,10 @@ impl<'a> Chunks<'a> { pub fn new(rope: &'a Rope, range: Range, reversed: bool) -> Self { let mut chunks = rope.chunks.cursor(&()); let offset = if reversed { - chunks.seek(&range.end, Bias::Left, &()); + chunks.seek(&range.end, Bias::Left); range.end } else { - chunks.seek(&range.start, Bias::Right, &()); + chunks.seek(&range.start, Bias::Right); range.start }; Self { @@ -642,10 +638,10 @@ impl<'a> Chunks<'a> { Bias::Right }; - if offset >= self.chunks.end(&()) { - self.chunks.seek_forward(&offset, bias, &()); + if offset >= self.chunks.end() { + self.chunks.seek_forward(&offset, bias); } else { - self.chunks.seek(&offset, bias, &()); + self.chunks.seek(&offset, bias); } self.offset = offset; @@ -674,25 +670,25 @@ impl<'a> Chunks<'a> { found = self.offset <= self.range.end; } else { self.chunks - .search_forward(|summary| summary.text.lines.row > 0, &()); + .search_forward(|summary| summary.text.lines.row > 0); self.offset = *self.chunks.start(); if let Some(newline_ix) = self.peek().and_then(|chunk| chunk.find('\n')) { self.offset += newline_ix + 1; found = self.offset <= self.range.end; } else { - self.offset = self.chunks.end(&()); + self.offset = self.chunks.end(); } } - if self.offset == self.chunks.end(&()) { + if self.offset == self.chunks.end() { self.next(); } } if self.offset > self.range.end { self.offset = cmp::min(self.offset, self.range.end); - self.chunks.seek(&self.offset, Bias::Right, &()); + self.chunks.seek(&self.offset, Bias::Right); } found @@ -711,7 +707,7 @@ impl<'a> Chunks<'a> { let initial_offset = self.offset; if self.offset == *self.chunks.start() { - self.chunks.prev(&()); + self.chunks.prev(); } if let Some(chunk) = self.chunks.item() { @@ -729,14 +725,14 @@ impl<'a> Chunks<'a> { } self.chunks - .search_backward(|summary| summary.text.lines.row > 0, &()); + .search_backward(|summary| summary.text.lines.row > 0); self.offset = *self.chunks.start(); if let Some(chunk) = self.chunks.item() { if let Some(newline_ix) = chunk.text.rfind('\n') { self.offset += newline_ix + 1; if self.offset_is_valid() { - if self.offset == self.chunks.end(&()) { - self.chunks.next(&()); + if self.offset == self.chunks.end() { + self.chunks.next(); } return true; @@ -746,7 +742,7 @@ impl<'a> Chunks<'a> { if !self.offset_is_valid() || self.chunks.item().is_none() { self.offset = self.range.start; - self.chunks.seek(&self.offset, Bias::Right, &()); + self.chunks.seek(&self.offset, Bias::Right); } self.offset < initial_offset && self.offset == 0 @@ -765,7 +761,7 @@ impl<'a> Chunks<'a> { slice_start..slice_end } else { let slice_start = self.offset - chunk_start; - let slice_end = cmp::min(self.chunks.end(&()), self.range.end) - chunk_start; + let slice_end = cmp::min(self.chunks.end(), self.range.end) - chunk_start; slice_start..slice_end }; @@ -825,12 +821,12 @@ impl<'a> Iterator for Chunks<'a> { if self.reversed { self.offset -= chunk.len(); if self.offset <= *self.chunks.start() { - self.chunks.prev(&()); + self.chunks.prev(); } } else { self.offset += chunk.len(); - if self.offset >= self.chunks.end(&()) { - self.chunks.next(&()); + if self.offset >= self.chunks.end() { + self.chunks.next(); } } @@ -848,9 +844,9 @@ impl<'a> Bytes<'a> { pub fn new(rope: &'a Rope, range: Range, reversed: bool) -> Self { let mut chunks = rope.chunks.cursor(&()); if reversed { - chunks.seek(&range.end, Bias::Left, &()); + chunks.seek(&range.end, Bias::Left); } else { - chunks.seek(&range.start, Bias::Right, &()); + chunks.seek(&range.start, Bias::Right); } Self { chunks, @@ -861,7 +857,7 @@ impl<'a> Bytes<'a> { pub fn peek(&self) -> Option<&'a [u8]> { let chunk = self.chunks.item()?; - if self.reversed && self.range.start >= self.chunks.end(&()) { + if self.reversed && self.range.start >= self.chunks.end() { return None; } let chunk_start = *self.chunks.start(); @@ -881,9 +877,9 @@ impl<'a> Iterator for Bytes<'a> { let result = self.peek(); if result.is_some() { if self.reversed { - self.chunks.prev(&()); + self.chunks.prev(); } else { - self.chunks.next(&()); + self.chunks.next(); } } result @@ -905,9 +901,9 @@ impl io::Read for Bytes<'_> { if len == chunk.len() { if self.reversed { - self.chunks.prev(&()); + self.chunks.prev(); } else { - self.chunks.next(&()); + self.chunks.next(); } } Ok(len) diff --git a/crates/sum_tree/src/cursor.rs b/crates/sum_tree/src/cursor.rs index 8edd04afce..50a556a6d2 100644 --- a/crates/sum_tree/src/cursor.rs +++ b/crates/sum_tree/src/cursor.rs @@ -25,6 +25,7 @@ pub struct Cursor<'a, T: Item, D> { position: D, did_seek: bool, at_end: bool, + cx: &'a ::Context, } impl fmt::Debug for Cursor<'_, T, D> @@ -52,21 +53,22 @@ where T: Item, D: Dimension<'a, T::Summary>, { - pub fn new(tree: &'a SumTree, cx: &::Context) -> Self { + pub fn new(tree: &'a SumTree, cx: &'a ::Context) -> Self { Self { tree, stack: ArrayVec::new(), position: D::zero(cx), did_seek: false, at_end: tree.is_empty(), + cx, } } - fn reset(&mut self, cx: &::Context) { + fn reset(&mut self) { self.did_seek = false; self.at_end = self.tree.is_empty(); self.stack.truncate(0); - self.position = D::zero(cx); + self.position = D::zero(self.cx); } pub fn start(&self) -> &D { @@ -74,10 +76,10 @@ where } #[track_caller] - pub fn end(&self, cx: &::Context) -> D { + pub fn end(&self) -> D { if let Some(item_summary) = self.item_summary() { let mut end = self.start().clone(); - end.add_summary(item_summary, cx); + end.add_summary(item_summary, self.cx); end } else { self.start().clone() @@ -202,12 +204,12 @@ where } #[track_caller] - pub fn prev(&mut self, cx: &::Context) { - self.search_backward(|_| true, cx) + pub fn prev(&mut self) { + self.search_backward(|_| true) } #[track_caller] - pub fn search_backward(&mut self, mut filter_node: F, cx: &::Context) + pub fn search_backward(&mut self, mut filter_node: F) where F: FnMut(&T::Summary) -> bool, { @@ -217,13 +219,13 @@ where } if self.at_end { - self.position = D::zero(cx); + self.position = D::zero(self.cx); self.at_end = self.tree.is_empty(); if !self.tree.is_empty() { self.stack.push(StackEntry { tree: self.tree, index: self.tree.0.child_summaries().len(), - position: D::from_summary(self.tree.summary(), cx), + position: D::from_summary(self.tree.summary(), self.cx), }); } } @@ -233,7 +235,7 @@ where if let Some(StackEntry { position, .. }) = self.stack.iter().rev().nth(1) { self.position = position.clone(); } else { - self.position = D::zero(cx); + self.position = D::zero(self.cx); } let entry = self.stack.last_mut().unwrap(); @@ -247,7 +249,7 @@ where } for summary in &entry.tree.0.child_summaries()[..entry.index] { - self.position.add_summary(summary, cx); + self.position.add_summary(summary, self.cx); } entry.position = self.position.clone(); @@ -257,7 +259,7 @@ where if descending { let tree = &child_trees[entry.index]; self.stack.push(StackEntry { - position: D::zero(cx), + position: D::zero(self.cx), tree, index: tree.0.child_summaries().len() - 1, }) @@ -273,12 +275,12 @@ where } #[track_caller] - pub fn next(&mut self, cx: &::Context) { - self.search_forward(|_| true, cx) + pub fn next(&mut self) { + self.search_forward(|_| true) } #[track_caller] - pub fn search_forward(&mut self, mut filter_node: F, cx: &::Context) + pub fn search_forward(&mut self, mut filter_node: F) where F: FnMut(&T::Summary) -> bool, { @@ -289,7 +291,7 @@ where self.stack.push(StackEntry { tree: self.tree, index: 0, - position: D::zero(cx), + position: D::zero(self.cx), }); descend = true; } @@ -316,8 +318,8 @@ where break; } else { entry.index += 1; - entry.position.add_summary(next_summary, cx); - self.position.add_summary(next_summary, cx); + entry.position.add_summary(next_summary, self.cx); + self.position.add_summary(next_summary, self.cx); } } @@ -327,8 +329,8 @@ where if !descend { let item_summary = &item_summaries[entry.index]; entry.index += 1; - entry.position.add_summary(item_summary, cx); - self.position.add_summary(item_summary, cx); + entry.position.add_summary(item_summary, self.cx); + self.position.add_summary(item_summary, self.cx); } loop { @@ -337,8 +339,8 @@ where return; } else { entry.index += 1; - entry.position.add_summary(next_item_summary, cx); - self.position.add_summary(next_item_summary, cx); + entry.position.add_summary(next_item_summary, self.cx); + self.position.add_summary(next_item_summary, self.cx); } } else { break None; @@ -380,71 +382,51 @@ where D: Dimension<'a, T::Summary>, { #[track_caller] - pub fn seek( - &mut self, - pos: &Target, - bias: Bias, - cx: &::Context, - ) -> bool + pub fn seek(&mut self, pos: &Target, bias: Bias) -> bool where Target: SeekTarget<'a, T::Summary, D>, { - self.reset(cx); - self.seek_internal(pos, bias, &mut (), cx) + self.reset(); + self.seek_internal(pos, bias, &mut ()) } #[track_caller] - pub fn seek_forward( - &mut self, - pos: &Target, - bias: Bias, - cx: &::Context, - ) -> bool + pub fn seek_forward(&mut self, pos: &Target, bias: Bias) -> bool where Target: SeekTarget<'a, T::Summary, D>, { - self.seek_internal(pos, bias, &mut (), cx) + self.seek_internal(pos, bias, &mut ()) } /// Advances the cursor and returns traversed items as a tree. #[track_caller] - pub fn slice( - &mut self, - end: &Target, - bias: Bias, - cx: &::Context, - ) -> SumTree + pub fn slice(&mut self, end: &Target, bias: Bias) -> SumTree where Target: SeekTarget<'a, T::Summary, D>, { let mut slice = SliceSeekAggregate { - tree: SumTree::new(cx), + tree: SumTree::new(self.cx), leaf_items: ArrayVec::new(), leaf_item_summaries: ArrayVec::new(), - leaf_summary: ::zero(cx), + leaf_summary: ::zero(self.cx), }; - self.seek_internal(end, bias, &mut slice, cx); + self.seek_internal(end, bias, &mut slice); slice.tree } #[track_caller] - pub fn suffix(&mut self, cx: &::Context) -> SumTree { - self.slice(&End::new(), Bias::Right, cx) + pub fn suffix(&mut self) -> SumTree { + self.slice(&End::new(), Bias::Right) } #[track_caller] - pub fn summary( - &mut self, - end: &Target, - bias: Bias, - cx: &::Context, - ) -> Output + pub fn summary(&mut self, end: &Target, bias: Bias) -> Output where Target: SeekTarget<'a, T::Summary, D>, Output: Dimension<'a, T::Summary>, { - let mut summary = SummarySeekAggregate(Output::zero(cx)); - self.seek_internal(end, bias, &mut summary, cx); + let mut summary = SummarySeekAggregate(Output::zero(self.cx)); + self.seek_internal(end, bias, &mut summary); summary.0 } @@ -455,10 +437,9 @@ where target: &dyn SeekTarget<'a, T::Summary, D>, bias: Bias, aggregate: &mut dyn SeekAggregate<'a, T>, - cx: &::Context, ) -> bool { assert!( - target.cmp(&self.position, cx) >= Ordering::Equal, + target.cmp(&self.position, self.cx) >= Ordering::Equal, "cannot seek backward", ); @@ -467,7 +448,7 @@ where self.stack.push(StackEntry { tree: self.tree, index: 0, - position: D::zero(cx), + position: D::zero(self.cx), }); } @@ -489,14 +470,14 @@ where .zip(&child_summaries[entry.index..]) { let mut child_end = self.position.clone(); - child_end.add_summary(child_summary, cx); + child_end.add_summary(child_summary, self.cx); - let comparison = target.cmp(&child_end, cx); + let comparison = target.cmp(&child_end, self.cx); if comparison == Ordering::Greater || (comparison == Ordering::Equal && bias == Bias::Right) { self.position = child_end; - aggregate.push_tree(child_tree, child_summary, cx); + aggregate.push_tree(child_tree, child_summary, self.cx); entry.index += 1; entry.position = self.position.clone(); } else { @@ -522,22 +503,22 @@ where .zip(&item_summaries[entry.index..]) { let mut child_end = self.position.clone(); - child_end.add_summary(item_summary, cx); + child_end.add_summary(item_summary, self.cx); - let comparison = target.cmp(&child_end, cx); + let comparison = target.cmp(&child_end, self.cx); if comparison == Ordering::Greater || (comparison == Ordering::Equal && bias == Bias::Right) { self.position = child_end; - aggregate.push_item(item, item_summary, cx); + aggregate.push_item(item, item_summary, self.cx); entry.index += 1; } else { - aggregate.end_leaf(cx); + aggregate.end_leaf(self.cx); break 'outer; } } - aggregate.end_leaf(cx); + aggregate.end_leaf(self.cx); } } @@ -551,11 +532,11 @@ where let mut end = self.position.clone(); if bias == Bias::Left { if let Some(summary) = self.item_summary() { - end.add_summary(summary, cx); + end.add_summary(summary, self.cx); } } - target.cmp(&end, cx) == Ordering::Equal + target.cmp(&end, self.cx) == Ordering::Equal } } @@ -624,21 +605,19 @@ impl<'a, T: Item> Iterator for Iter<'a, T> { } } -impl<'a, T, S, D> Iterator for Cursor<'a, T, D> +impl<'a, T: Item, D> Iterator for Cursor<'a, T, D> where - T: Item, - S: Summary, D: Dimension<'a, T::Summary>, { type Item = &'a T; fn next(&mut self) -> Option { if !self.did_seek { - self.next(&()); + self.next(); } if let Some(item) = self.item() { - self.next(&()); + self.next(); Some(item) } else { None @@ -651,7 +630,7 @@ pub struct FilterCursor<'a, F, T: Item, D> { filter_node: F, } -impl<'a, F, T, D> FilterCursor<'a, F, T, D> +impl<'a, F, T: Item, D> FilterCursor<'a, F, T, D> where F: FnMut(&T::Summary) -> bool, T: Item, @@ -659,7 +638,7 @@ where { pub fn new( tree: &'a SumTree, - cx: &::Context, + cx: &'a ::Context, filter_node: F, ) -> Self { let cursor = tree.cursor::(cx); @@ -673,8 +652,8 @@ where self.cursor.start() } - pub fn end(&self, cx: &::Context) -> D { - self.cursor.end(cx) + pub fn end(&self) -> D { + self.cursor.end() } pub fn item(&self) -> Option<&'a T> { @@ -685,31 +664,29 @@ where self.cursor.item_summary() } - pub fn next(&mut self, cx: &::Context) { - self.cursor.search_forward(&mut self.filter_node, cx); + pub fn next(&mut self) { + self.cursor.search_forward(&mut self.filter_node); } - pub fn prev(&mut self, cx: &::Context) { - self.cursor.search_backward(&mut self.filter_node, cx); + pub fn prev(&mut self) { + self.cursor.search_backward(&mut self.filter_node); } } -impl<'a, F, T, S, U> Iterator for FilterCursor<'a, F, T, U> +impl<'a, F, T: Item, U> Iterator for FilterCursor<'a, F, T, U> where F: FnMut(&T::Summary) -> bool, - T: Item, - S: Summary, //Context for the summary must be unit type, as .next() doesn't take arguments U: Dimension<'a, T::Summary>, { type Item = &'a T; fn next(&mut self) -> Option { if !self.cursor.did_seek { - self.next(&()); + self.next(); } if let Some(item) = self.item() { - self.cursor.search_forward(&mut self.filter_node, &()); + self.cursor.search_forward(&mut self.filter_node); Some(item) } else { None @@ -795,3 +772,23 @@ where self.0.add_summary(summary, cx); } } + +struct End(PhantomData); + +impl End { + fn new() -> Self { + Self(PhantomData) + } +} + +impl<'a, S: Summary, D: Dimension<'a, S>> SeekTarget<'a, S, D> for End { + fn cmp(&self, _: &D, _: &S::Context) -> Ordering { + Ordering::Greater + } +} + +impl fmt::Debug for End { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("End").finish() + } +} diff --git a/crates/sum_tree/src/sum_tree.rs b/crates/sum_tree/src/sum_tree.rs index 82022d6685..4f9e01ce20 100644 --- a/crates/sum_tree/src/sum_tree.rs +++ b/crates/sum_tree/src/sum_tree.rs @@ -38,7 +38,6 @@ pub trait Summary: Clone { type Context; fn zero(cx: &Self::Context) -> Self; - fn add_summary(&mut self, summary: &Self, cx: &Self::Context); } @@ -138,26 +137,6 @@ where } } -struct End(PhantomData); - -impl End { - fn new() -> Self { - Self(PhantomData) - } -} - -impl<'a, S: Summary, D: Dimension<'a, S>> SeekTarget<'a, S, D> for End { - fn cmp(&self, _: &D, _: &S::Context) -> Ordering { - Ordering::Greater - } -} - -impl fmt::Debug for End { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_tuple("End").finish() - } -} - /// Bias is used to settle ambiguities when determining positions in an ordered sequence. /// /// The primary use case is for text, where Bias influences @@ -372,10 +351,10 @@ impl SumTree { pub fn items(&self, cx: &::Context) -> Vec { let mut items = Vec::new(); let mut cursor = self.cursor::<()>(cx); - cursor.next(cx); + cursor.next(); while let Some(item) = cursor.item() { items.push(item.clone()); - cursor.next(cx); + cursor.next(); } items } @@ -384,7 +363,7 @@ impl SumTree { Iter::new(self) } - pub fn cursor<'a, S>(&'a self, cx: &::Context) -> Cursor<'a, T, S> + pub fn cursor<'a, S>(&'a self, cx: &'a ::Context) -> Cursor<'a, T, S> where S: Dimension<'a, T::Summary>, { @@ -395,7 +374,7 @@ impl SumTree { /// that is returned cannot be used with Rust's iterators. pub fn filter<'a, F, U>( &'a self, - cx: &::Context, + cx: &'a ::Context, filter_node: F, ) -> FilterCursor<'a, F, T, U> where @@ -525,10 +504,6 @@ impl SumTree { } } - pub fn ptr_eq(&self, other: &Self) -> bool { - Arc::ptr_eq(&self.0, &other.0) - } - fn push_tree_recursive( &mut self, other: SumTree, @@ -686,11 +661,6 @@ impl SumTree { } => child_trees.last().unwrap().rightmost_leaf(), } } - - #[cfg(debug_assertions)] - pub fn _debug_entries(&self) -> Vec<&T> { - self.iter().collect::>() - } } impl PartialEq for SumTree { @@ -710,15 +680,15 @@ impl SumTree { let mut replaced = None; *self = { let mut cursor = self.cursor::(cx); - let mut new_tree = cursor.slice(&item.key(), Bias::Left, cx); + let mut new_tree = cursor.slice(&item.key(), Bias::Left); if let Some(cursor_item) = cursor.item() { if cursor_item.key() == item.key() { replaced = Some(cursor_item.clone()); - cursor.next(cx); + cursor.next(); } } new_tree.push(item, cx); - new_tree.append(cursor.suffix(cx), cx); + new_tree.append(cursor.suffix(), cx); new_tree }; replaced @@ -728,14 +698,14 @@ impl SumTree { let mut removed = None; *self = { let mut cursor = self.cursor::(cx); - let mut new_tree = cursor.slice(key, Bias::Left, cx); + let mut new_tree = cursor.slice(key, Bias::Left); if let Some(item) = cursor.item() { if item.key() == *key { removed = Some(item.clone()); - cursor.next(cx); + cursor.next(); } } - new_tree.append(cursor.suffix(cx), cx); + new_tree.append(cursor.suffix(), cx); new_tree }; removed @@ -758,7 +728,7 @@ impl SumTree { let mut new_tree = SumTree::new(cx); let mut buffered_items = Vec::new(); - cursor.seek(&T::Key::zero(cx), Bias::Left, cx); + cursor.seek(&T::Key::zero(cx), Bias::Left); for edit in edits { let new_key = edit.key(); let mut old_item = cursor.item(); @@ -768,7 +738,7 @@ impl SumTree { .map_or(false, |old_item| old_item.key() < new_key) { new_tree.extend(buffered_items.drain(..), cx); - let slice = cursor.slice(&new_key, Bias::Left, cx); + let slice = cursor.slice(&new_key, Bias::Left); new_tree.append(slice, cx); old_item = cursor.item(); } @@ -776,7 +746,7 @@ impl SumTree { if let Some(old_item) = old_item { if old_item.key() == new_key { removed.push(old_item.clone()); - cursor.next(cx); + cursor.next(); } } @@ -789,70 +759,25 @@ impl SumTree { } new_tree.extend(buffered_items, cx); - new_tree.append(cursor.suffix(cx), cx); + new_tree.append(cursor.suffix(), cx); new_tree }; removed } - pub fn get(&self, key: &T::Key, cx: &::Context) -> Option<&T> { + pub fn get<'a>( + &'a self, + key: &T::Key, + cx: &'a ::Context, + ) -> Option<&'a T> { let mut cursor = self.cursor::(cx); - if cursor.seek(key, Bias::Left, cx) { + if cursor.seek(key, Bias::Left) { cursor.item() } else { None } } - - #[inline] - pub fn contains(&self, key: &T::Key, cx: &::Context) -> bool { - self.get(key, cx).is_some() - } - - pub fn update( - &mut self, - key: &T::Key, - cx: &::Context, - f: F, - ) -> Option - where - F: FnOnce(&mut T) -> R, - { - let mut cursor = self.cursor::(cx); - let mut new_tree = cursor.slice(key, Bias::Left, cx); - let mut result = None; - if Ord::cmp(key, &cursor.end(cx)) == Ordering::Equal { - let mut updated = cursor.item().unwrap().clone(); - result = Some(f(&mut updated)); - new_tree.push(updated, cx); - cursor.next(cx); - } - new_tree.append(cursor.suffix(cx), cx); - drop(cursor); - *self = new_tree; - result - } - - pub fn retain bool>( - &mut self, - cx: &::Context, - mut predicate: F, - ) { - let mut new_map = SumTree::new(cx); - - let mut cursor = self.cursor::(cx); - cursor.next(cx); - while let Some(item) = cursor.item() { - if predicate(&item) { - new_map.push(item.clone(), cx); - } - cursor.next(cx); - } - drop(cursor); - - *self = new_map; - } } impl Default for SumTree @@ -1061,14 +986,14 @@ mod tests { tree = { let mut cursor = tree.cursor::(&()); - let mut new_tree = cursor.slice(&Count(splice_start), Bias::Right, &()); + let mut new_tree = cursor.slice(&Count(splice_start), Bias::Right); if rng.r#gen() { new_tree.extend(new_items, &()); } else { new_tree.par_extend(new_items, &()); } - cursor.seek(&Count(splice_end), Bias::Right, &()); - new_tree.append(cursor.slice(&tree_end, Bias::Right, &()), &()); + cursor.seek(&Count(splice_end), Bias::Right); + new_tree.append(cursor.slice(&tree_end, Bias::Right), &()); new_tree }; @@ -1090,10 +1015,10 @@ mod tests { .collect::>(); let mut item_ix = if rng.r#gen() { - filter_cursor.next(&()); + filter_cursor.next(); 0 } else { - filter_cursor.prev(&()); + filter_cursor.prev(); expected_filtered_items.len().saturating_sub(1) }; while item_ix < expected_filtered_items.len() { @@ -1103,19 +1028,19 @@ mod tests { assert_eq!(actual_item, &reference_item); assert_eq!(filter_cursor.start().0, reference_index); log::info!("next"); - filter_cursor.next(&()); + filter_cursor.next(); item_ix += 1; while item_ix > 0 && rng.gen_bool(0.2) { log::info!("prev"); - filter_cursor.prev(&()); + filter_cursor.prev(); item_ix -= 1; if item_ix == 0 && rng.gen_bool(0.2) { - filter_cursor.prev(&()); + filter_cursor.prev(); assert_eq!(filter_cursor.item(), None); assert_eq!(filter_cursor.start().0, 0); - filter_cursor.next(&()); + filter_cursor.next(); } } } @@ -1124,9 +1049,9 @@ mod tests { let mut before_start = false; let mut cursor = tree.cursor::(&()); let start_pos = rng.gen_range(0..=reference_items.len()); - cursor.seek(&Count(start_pos), Bias::Right, &()); + cursor.seek(&Count(start_pos), Bias::Right); let mut pos = rng.gen_range(start_pos..=reference_items.len()); - cursor.seek_forward(&Count(pos), Bias::Right, &()); + cursor.seek_forward(&Count(pos), Bias::Right); for i in 0..10 { assert_eq!(cursor.start().0, pos); @@ -1152,13 +1077,13 @@ mod tests { } if i < 5 { - cursor.next(&()); + cursor.next(); if pos < reference_items.len() { pos += 1; before_start = false; } } else { - cursor.prev(&()); + cursor.prev(); if pos == 0 { before_start = true; } @@ -1174,11 +1099,11 @@ mod tests { let end_bias = if rng.r#gen() { Bias::Left } else { Bias::Right }; let mut cursor = tree.cursor::(&()); - cursor.seek(&Count(start), start_bias, &()); - let slice = cursor.slice(&Count(end), end_bias, &()); + cursor.seek(&Count(start), start_bias); + let slice = cursor.slice(&Count(end), end_bias); - cursor.seek(&Count(start), start_bias, &()); - let summary = cursor.summary::<_, Sum>(&Count(end), end_bias, &()); + cursor.seek(&Count(start), start_bias); + let summary = cursor.summary::<_, Sum>(&Count(end), end_bias); assert_eq!(summary.0, slice.summary().sum); } @@ -1191,19 +1116,19 @@ mod tests { let tree = SumTree::::default(); let mut cursor = tree.cursor::(&()); assert_eq!( - cursor.slice(&Count(0), Bias::Right, &()).items(&()), + cursor.slice(&Count(0), Bias::Right).items(&()), Vec::::new() ); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), None); assert_eq!(cursor.next_item(), None); assert_eq!(cursor.start().sum, 0); - cursor.prev(&()); + cursor.prev(); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), None); assert_eq!(cursor.next_item(), None); assert_eq!(cursor.start().sum, 0); - cursor.next(&()); + cursor.next(); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), None); assert_eq!(cursor.next_item(), None); @@ -1214,7 +1139,7 @@ mod tests { tree.extend(vec![1], &()); let mut cursor = tree.cursor::(&()); assert_eq!( - cursor.slice(&Count(0), Bias::Right, &()).items(&()), + cursor.slice(&Count(0), Bias::Right).items(&()), Vec::::new() ); assert_eq!(cursor.item(), Some(&1)); @@ -1222,29 +1147,29 @@ mod tests { assert_eq!(cursor.next_item(), None); assert_eq!(cursor.start().sum, 0); - cursor.next(&()); + cursor.next(); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), Some(&1)); assert_eq!(cursor.next_item(), None); assert_eq!(cursor.start().sum, 1); - cursor.prev(&()); + cursor.prev(); assert_eq!(cursor.item(), Some(&1)); assert_eq!(cursor.prev_item(), None); assert_eq!(cursor.next_item(), None); assert_eq!(cursor.start().sum, 0); let mut cursor = tree.cursor::(&()); - assert_eq!(cursor.slice(&Count(1), Bias::Right, &()).items(&()), [1]); + assert_eq!(cursor.slice(&Count(1), Bias::Right).items(&()), [1]); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), Some(&1)); assert_eq!(cursor.next_item(), None); assert_eq!(cursor.start().sum, 1); - cursor.seek(&Count(0), Bias::Right, &()); + cursor.seek(&Count(0), Bias::Right); assert_eq!( cursor - .slice(&tree.extent::(&()), Bias::Right, &()) + .slice(&tree.extent::(&()), Bias::Right) .items(&()), [1] ); @@ -1258,80 +1183,80 @@ mod tests { tree.extend(vec![1, 2, 3, 4, 5, 6], &()); let mut cursor = tree.cursor::(&()); - assert_eq!(cursor.slice(&Count(2), Bias::Right, &()).items(&()), [1, 2]); + assert_eq!(cursor.slice(&Count(2), Bias::Right).items(&()), [1, 2]); assert_eq!(cursor.item(), Some(&3)); assert_eq!(cursor.prev_item(), Some(&2)); assert_eq!(cursor.next_item(), Some(&4)); assert_eq!(cursor.start().sum, 3); - cursor.next(&()); + cursor.next(); assert_eq!(cursor.item(), Some(&4)); assert_eq!(cursor.prev_item(), Some(&3)); assert_eq!(cursor.next_item(), Some(&5)); assert_eq!(cursor.start().sum, 6); - cursor.next(&()); + cursor.next(); assert_eq!(cursor.item(), Some(&5)); assert_eq!(cursor.prev_item(), Some(&4)); assert_eq!(cursor.next_item(), Some(&6)); assert_eq!(cursor.start().sum, 10); - cursor.next(&()); + cursor.next(); assert_eq!(cursor.item(), Some(&6)); assert_eq!(cursor.prev_item(), Some(&5)); assert_eq!(cursor.next_item(), None); assert_eq!(cursor.start().sum, 15); - cursor.next(&()); - cursor.next(&()); + cursor.next(); + cursor.next(); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), Some(&6)); assert_eq!(cursor.next_item(), None); assert_eq!(cursor.start().sum, 21); - cursor.prev(&()); + cursor.prev(); assert_eq!(cursor.item(), Some(&6)); assert_eq!(cursor.prev_item(), Some(&5)); assert_eq!(cursor.next_item(), None); assert_eq!(cursor.start().sum, 15); - cursor.prev(&()); + cursor.prev(); assert_eq!(cursor.item(), Some(&5)); assert_eq!(cursor.prev_item(), Some(&4)); assert_eq!(cursor.next_item(), Some(&6)); assert_eq!(cursor.start().sum, 10); - cursor.prev(&()); + cursor.prev(); assert_eq!(cursor.item(), Some(&4)); assert_eq!(cursor.prev_item(), Some(&3)); assert_eq!(cursor.next_item(), Some(&5)); assert_eq!(cursor.start().sum, 6); - cursor.prev(&()); + cursor.prev(); assert_eq!(cursor.item(), Some(&3)); assert_eq!(cursor.prev_item(), Some(&2)); assert_eq!(cursor.next_item(), Some(&4)); assert_eq!(cursor.start().sum, 3); - cursor.prev(&()); + cursor.prev(); assert_eq!(cursor.item(), Some(&2)); assert_eq!(cursor.prev_item(), Some(&1)); assert_eq!(cursor.next_item(), Some(&3)); assert_eq!(cursor.start().sum, 1); - cursor.prev(&()); + cursor.prev(); assert_eq!(cursor.item(), Some(&1)); assert_eq!(cursor.prev_item(), None); assert_eq!(cursor.next_item(), Some(&2)); assert_eq!(cursor.start().sum, 0); - cursor.prev(&()); + cursor.prev(); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), None); assert_eq!(cursor.next_item(), Some(&1)); assert_eq!(cursor.start().sum, 0); - cursor.next(&()); + cursor.next(); assert_eq!(cursor.item(), Some(&1)); assert_eq!(cursor.prev_item(), None); assert_eq!(cursor.next_item(), Some(&2)); @@ -1340,7 +1265,7 @@ mod tests { let mut cursor = tree.cursor::(&()); assert_eq!( cursor - .slice(&tree.extent::(&()), Bias::Right, &()) + .slice(&tree.extent::(&()), Bias::Right) .items(&()), tree.items(&()) ); @@ -1349,10 +1274,10 @@ mod tests { assert_eq!(cursor.next_item(), None); assert_eq!(cursor.start().sum, 21); - cursor.seek(&Count(3), Bias::Right, &()); + cursor.seek(&Count(3), Bias::Right); assert_eq!( cursor - .slice(&tree.extent::(&()), Bias::Right, &()) + .slice(&tree.extent::(&()), Bias::Right) .items(&()), [4, 5, 6] ); @@ -1362,25 +1287,16 @@ mod tests { assert_eq!(cursor.start().sum, 21); // Seeking can bias left or right - cursor.seek(&Count(1), Bias::Left, &()); + cursor.seek(&Count(1), Bias::Left); assert_eq!(cursor.item(), Some(&1)); - cursor.seek(&Count(1), Bias::Right, &()); + cursor.seek(&Count(1), Bias::Right); assert_eq!(cursor.item(), Some(&2)); // Slicing without resetting starts from where the cursor is parked at. - cursor.seek(&Count(1), Bias::Right, &()); - assert_eq!( - cursor.slice(&Count(3), Bias::Right, &()).items(&()), - vec![2, 3] - ); - assert_eq!( - cursor.slice(&Count(6), Bias::Left, &()).items(&()), - vec![4, 5] - ); - assert_eq!( - cursor.slice(&Count(6), Bias::Right, &()).items(&()), - vec![6] - ); + cursor.seek(&Count(1), Bias::Right); + assert_eq!(cursor.slice(&Count(3), Bias::Right).items(&()), vec![2, 3]); + assert_eq!(cursor.slice(&Count(6), Bias::Left).items(&()), vec![4, 5]); + assert_eq!(cursor.slice(&Count(6), Bias::Right).items(&()), vec![6]); } #[test] diff --git a/crates/sum_tree/src/tree_map.rs b/crates/sum_tree/src/tree_map.rs index 884042b722..0397f16182 100644 --- a/crates/sum_tree/src/tree_map.rs +++ b/crates/sum_tree/src/tree_map.rs @@ -54,7 +54,7 @@ impl TreeMap { pub fn get(&self, key: &K) -> Option<&V> { let mut cursor = self.0.cursor::>(&()); - cursor.seek(&MapKeyRef(Some(key)), Bias::Left, &()); + cursor.seek(&MapKeyRef(Some(key)), Bias::Left); if let Some(item) = cursor.item() { if Some(key) == item.key().0.as_ref() { Some(&item.value) @@ -86,12 +86,12 @@ impl TreeMap { let mut removed = None; let mut cursor = self.0.cursor::>(&()); let key = MapKeyRef(Some(key)); - let mut new_tree = cursor.slice(&key, Bias::Left, &()); - if key.cmp(&cursor.end(&()), &()) == Ordering::Equal { + let mut new_tree = cursor.slice(&key, Bias::Left); + if key.cmp(&cursor.end(), &()) == Ordering::Equal { removed = Some(cursor.item().unwrap().value.clone()); - cursor.next(&()); + cursor.next(); } - new_tree.append(cursor.suffix(&()), &()); + new_tree.append(cursor.suffix(), &()); drop(cursor); self.0 = new_tree; removed @@ -101,9 +101,9 @@ impl TreeMap { let start = MapSeekTargetAdaptor(start); let end = MapSeekTargetAdaptor(end); let mut cursor = self.0.cursor::>(&()); - let mut new_tree = cursor.slice(&start, Bias::Left, &()); - cursor.seek(&end, Bias::Left, &()); - new_tree.append(cursor.suffix(&()), &()); + let mut new_tree = cursor.slice(&start, Bias::Left); + cursor.seek(&end, Bias::Left); + new_tree.append(cursor.suffix(), &()); drop(cursor); self.0 = new_tree; } @@ -112,15 +112,15 @@ impl TreeMap { pub fn closest(&self, key: &K) -> Option<(&K, &V)> { let mut cursor = self.0.cursor::>(&()); let key = MapKeyRef(Some(key)); - cursor.seek(&key, Bias::Right, &()); - cursor.prev(&()); + cursor.seek(&key, Bias::Right); + cursor.prev(); cursor.item().map(|item| (&item.key, &item.value)) } pub fn iter_from<'a>(&'a self, from: &K) -> impl Iterator + 'a { let mut cursor = self.0.cursor::>(&()); let from_key = MapKeyRef(Some(from)); - cursor.seek(&from_key, Bias::Left, &()); + cursor.seek(&from_key, Bias::Left); cursor.map(|map_entry| (&map_entry.key, &map_entry.value)) } @@ -131,15 +131,15 @@ impl TreeMap { { let mut cursor = self.0.cursor::>(&()); let key = MapKeyRef(Some(key)); - let mut new_tree = cursor.slice(&key, Bias::Left, &()); + let mut new_tree = cursor.slice(&key, Bias::Left); let mut result = None; - if key.cmp(&cursor.end(&()), &()) == Ordering::Equal { + if key.cmp(&cursor.end(), &()) == Ordering::Equal { let mut updated = cursor.item().unwrap().clone(); result = Some(f(&mut updated.value)); new_tree.push(updated, &()); - cursor.next(&()); + cursor.next(); } - new_tree.append(cursor.suffix(&()), &()); + new_tree.append(cursor.suffix(), &()); drop(cursor); self.0 = new_tree; result @@ -149,12 +149,12 @@ impl TreeMap { let mut new_map = SumTree::>::default(); let mut cursor = self.0.cursor::>(&()); - cursor.next(&()); + cursor.next(); while let Some(item) = cursor.item() { if predicate(&item.key, &item.value) { new_map.push(item.clone(), &()); } - cursor.next(&()); + cursor.next(); } drop(cursor); diff --git a/crates/text/src/anchor.rs b/crates/text/src/anchor.rs index 83a4fc8429..5807d3aae0 100644 --- a/crates/text/src/anchor.rs +++ b/crates/text/src/anchor.rs @@ -101,7 +101,7 @@ impl Anchor { } else { let fragment_id = buffer.fragment_id_for_anchor(self); let mut fragment_cursor = buffer.fragments.cursor::<(Option<&Locator>, usize)>(&None); - fragment_cursor.seek(&Some(fragment_id), Bias::Left, &None); + fragment_cursor.seek(&Some(fragment_id), Bias::Left); fragment_cursor .item() .map_or(false, |fragment| fragment.visible) diff --git a/crates/text/src/text.rs b/crates/text/src/text.rs index aa9682029e..c1da0649da 100644 --- a/crates/text/src/text.rs +++ b/crates/text/src/text.rs @@ -856,14 +856,13 @@ impl Buffer { let mut new_ropes = RopeBuilder::new(self.visible_text.cursor(0), self.deleted_text.cursor(0)); let mut old_fragments = self.fragments.cursor::(&None); - let mut new_fragments = - old_fragments.slice(&edits.peek().unwrap().0.start, Bias::Right, &None); + let mut new_fragments = old_fragments.slice(&edits.peek().unwrap().0.start, Bias::Right); new_ropes.append(new_fragments.summary().text); let mut fragment_start = old_fragments.start().visible; for (range, new_text) in edits { let new_text = LineEnding::normalize_arc(new_text.into()); - let fragment_end = old_fragments.end(&None).visible; + let fragment_end = old_fragments.end().visible; // If the current fragment ends before this range, then jump ahead to the first fragment // that extends past the start of this range, reusing any intervening fragments. @@ -879,10 +878,10 @@ impl Buffer { new_ropes.push_fragment(&suffix, suffix.visible); new_fragments.push(suffix, &None); } - old_fragments.next(&None); + old_fragments.next(); } - let slice = old_fragments.slice(&range.start, Bias::Right, &None); + let slice = old_fragments.slice(&range.start, Bias::Right); new_ropes.append(slice.summary().text); new_fragments.append(slice, &None); fragment_start = old_fragments.start().visible; @@ -935,7 +934,7 @@ impl Buffer { // portions as deleted. while fragment_start < range.end { let fragment = old_fragments.item().unwrap(); - let fragment_end = old_fragments.end(&None).visible; + let fragment_end = old_fragments.end().visible; let mut intersection = fragment.clone(); let intersection_end = cmp::min(range.end, fragment_end); if fragment.visible { @@ -962,7 +961,7 @@ impl Buffer { fragment_start = intersection_end; } if fragment_end <= range.end { - old_fragments.next(&None); + old_fragments.next(); } } @@ -974,7 +973,7 @@ impl Buffer { // If the current fragment has been partially consumed, then consume the rest of it // and advance to the next fragment before slicing. if fragment_start > old_fragments.start().visible { - let fragment_end = old_fragments.end(&None).visible; + let fragment_end = old_fragments.end().visible; if fragment_end > fragment_start { let mut suffix = old_fragments.item().unwrap().clone(); suffix.len = fragment_end - fragment_start; @@ -983,10 +982,10 @@ impl Buffer { new_ropes.push_fragment(&suffix, suffix.visible); new_fragments.push(suffix, &None); } - old_fragments.next(&None); + old_fragments.next(); } - let suffix = old_fragments.suffix(&None); + let suffix = old_fragments.suffix(); new_ropes.append(suffix.summary().text); new_fragments.append(suffix, &None); let (visible_text, deleted_text) = new_ropes.finish(); @@ -1073,16 +1072,13 @@ impl Buffer { let mut new_ropes = RopeBuilder::new(self.visible_text.cursor(0), self.deleted_text.cursor(0)); let mut old_fragments = self.fragments.cursor::<(VersionedFullOffset, usize)>(&cx); - let mut new_fragments = old_fragments.slice( - &VersionedFullOffset::Offset(ranges[0].start), - Bias::Left, - &cx, - ); + let mut new_fragments = + old_fragments.slice(&VersionedFullOffset::Offset(ranges[0].start), Bias::Left); new_ropes.append(new_fragments.summary().text); let mut fragment_start = old_fragments.start().0.full_offset(); for (range, new_text) in edits { - let fragment_end = old_fragments.end(&cx).0.full_offset(); + let fragment_end = old_fragments.end().0.full_offset(); // If the current fragment ends before this range, then jump ahead to the first fragment // that extends past the start of this range, reusing any intervening fragments. @@ -1099,18 +1095,18 @@ impl Buffer { new_ropes.push_fragment(&suffix, suffix.visible); new_fragments.push(suffix, &None); } - old_fragments.next(&cx); + old_fragments.next(); } let slice = - old_fragments.slice(&VersionedFullOffset::Offset(range.start), Bias::Left, &cx); + old_fragments.slice(&VersionedFullOffset::Offset(range.start), Bias::Left); new_ropes.append(slice.summary().text); new_fragments.append(slice, &None); fragment_start = old_fragments.start().0.full_offset(); } // If we are at the end of a non-concurrent fragment, advance to the next one. - let fragment_end = old_fragments.end(&cx).0.full_offset(); + let fragment_end = old_fragments.end().0.full_offset(); if fragment_end == range.start && fragment_end > fragment_start { let mut fragment = old_fragments.item().unwrap().clone(); fragment.len = fragment_end.0 - fragment_start.0; @@ -1118,7 +1114,7 @@ impl Buffer { new_insertions.push(InsertionFragment::insert_new(&fragment)); new_ropes.push_fragment(&fragment, fragment.visible); new_fragments.push(fragment, &None); - old_fragments.next(&cx); + old_fragments.next(); fragment_start = old_fragments.start().0.full_offset(); } @@ -1128,7 +1124,7 @@ impl Buffer { if fragment_start == range.start && fragment.timestamp > timestamp { new_ropes.push_fragment(fragment, fragment.visible); new_fragments.push(fragment.clone(), &None); - old_fragments.next(&cx); + old_fragments.next(); debug_assert_eq!(fragment_start, range.start); } else { break; @@ -1184,7 +1180,7 @@ impl Buffer { // portions as deleted. while fragment_start < range.end { let fragment = old_fragments.item().unwrap(); - let fragment_end = old_fragments.end(&cx).0.full_offset(); + let fragment_end = old_fragments.end().0.full_offset(); let mut intersection = fragment.clone(); let intersection_end = cmp::min(range.end, fragment_end); if fragment.was_visible(version, &self.undo_map) { @@ -1213,7 +1209,7 @@ impl Buffer { fragment_start = intersection_end; } if fragment_end <= range.end { - old_fragments.next(&cx); + old_fragments.next(); } } } @@ -1221,7 +1217,7 @@ impl Buffer { // If the current fragment has been partially consumed, then consume the rest of it // and advance to the next fragment before slicing. if fragment_start > old_fragments.start().0.full_offset() { - let fragment_end = old_fragments.end(&cx).0.full_offset(); + let fragment_end = old_fragments.end().0.full_offset(); if fragment_end > fragment_start { let mut suffix = old_fragments.item().unwrap().clone(); suffix.len = fragment_end.0 - fragment_start.0; @@ -1230,10 +1226,10 @@ impl Buffer { new_ropes.push_fragment(&suffix, suffix.visible); new_fragments.push(suffix, &None); } - old_fragments.next(&cx); + old_fragments.next(); } - let suffix = old_fragments.suffix(&cx); + let suffix = old_fragments.suffix(); new_ropes.append(suffix.summary().text); new_fragments.append(suffix, &None); let (visible_text, deleted_text) = new_ropes.finish(); @@ -1282,7 +1278,6 @@ impl Buffer { split_offset: insertion_slice.range.start, }, Bias::Left, - &(), ); } while let Some(item) = insertions_cursor.item() { @@ -1292,7 +1287,7 @@ impl Buffer { break; } fragment_ids.push(&item.fragment_id); - insertions_cursor.next(&()); + insertions_cursor.next(); } } fragment_ids.sort_unstable(); @@ -1309,7 +1304,7 @@ impl Buffer { RopeBuilder::new(self.visible_text.cursor(0), self.deleted_text.cursor(0)); for fragment_id in self.fragment_ids_for_edits(undo.counts.keys()) { - let preceding_fragments = old_fragments.slice(&Some(fragment_id), Bias::Left, &None); + let preceding_fragments = old_fragments.slice(&Some(fragment_id), Bias::Left); new_ropes.append(preceding_fragments.summary().text); new_fragments.append(preceding_fragments, &None); @@ -1336,11 +1331,11 @@ impl Buffer { new_ropes.push_fragment(&fragment, fragment_was_visible); new_fragments.push(fragment, &None); - old_fragments.next(&None); + old_fragments.next(); } } - let suffix = old_fragments.suffix(&None); + let suffix = old_fragments.suffix(); new_ropes.append(suffix.summary().text); new_fragments.append(suffix, &None); @@ -1571,7 +1566,7 @@ impl Buffer { .fragment_ids_for_edits(edit_ids.into_iter()) .into_iter() .filter_map(move |fragment_id| { - cursor.seek_forward(&Some(fragment_id), Bias::Left, &None); + cursor.seek_forward(&Some(fragment_id), Bias::Left); let fragment = cursor.item()?; let start_offset = cursor.start().1; let end_offset = start_offset + if fragment.visible { fragment.len } else { 0 }; @@ -1793,7 +1788,7 @@ impl Buffer { let mut cursor = self.snapshot.fragments.cursor::>(&None); for insertion_fragment in self.snapshot.insertions.cursor::<()>(&()) { - cursor.seek(&Some(&insertion_fragment.fragment_id), Bias::Left, &None); + cursor.seek(&Some(&insertion_fragment.fragment_id), Bias::Left); let fragment = cursor.item().unwrap(); assert_eq!(insertion_fragment.fragment_id, fragment.id); assert_eq!(insertion_fragment.split_offset, fragment.insertion_offset); @@ -1912,7 +1907,7 @@ impl BufferSnapshot { .filter::<_, FragmentTextSummary>(&None, move |summary| { !version.observed_all(&summary.max_version) }); - cursor.next(&None); + cursor.next(); let mut visible_cursor = self.visible_text.cursor(0); let mut deleted_cursor = self.deleted_text.cursor(0); @@ -1925,18 +1920,18 @@ impl BufferSnapshot { if fragment.was_visible(version, &self.undo_map) { if fragment.visible { - let text = visible_cursor.slice(cursor.end(&None).visible); + let text = visible_cursor.slice(cursor.end().visible); rope.append(text); } else { deleted_cursor.seek_forward(cursor.start().deleted); - let text = deleted_cursor.slice(cursor.end(&None).deleted); + let text = deleted_cursor.slice(cursor.end().deleted); rope.append(text); } } else if fragment.visible { - visible_cursor.seek_forward(cursor.end(&None).visible); + visible_cursor.seek_forward(cursor.end().visible); } - cursor.next(&None); + cursor.next(); } if cursor.start().visible > visible_cursor.offset() { @@ -2252,7 +2247,7 @@ impl BufferSnapshot { timestamp: anchor.timestamp, split_offset: anchor.offset, }; - insertion_cursor.seek(&anchor_key, anchor.bias, &()); + insertion_cursor.seek(&anchor_key, anchor.bias); if let Some(insertion) = insertion_cursor.item() { let comparison = sum_tree::KeyedItem::key(insertion).cmp(&anchor_key); if comparison == Ordering::Greater @@ -2260,15 +2255,15 @@ impl BufferSnapshot { && comparison == Ordering::Equal && anchor.offset > 0) { - insertion_cursor.prev(&()); + insertion_cursor.prev(); } } else { - insertion_cursor.prev(&()); + insertion_cursor.prev(); } let insertion = insertion_cursor.item().expect("invalid insertion"); assert_eq!(insertion.timestamp, anchor.timestamp, "invalid insertion"); - fragment_cursor.seek_forward(&Some(&insertion.fragment_id), Bias::Left, &None); + fragment_cursor.seek_forward(&Some(&insertion.fragment_id), Bias::Left); let fragment = fragment_cursor.item().unwrap(); let mut fragment_offset = fragment_cursor.start().1; if fragment.visible { @@ -2299,7 +2294,7 @@ impl BufferSnapshot { split_offset: anchor.offset, }; let mut insertion_cursor = self.insertions.cursor::(&()); - insertion_cursor.seek(&anchor_key, anchor.bias, &()); + insertion_cursor.seek(&anchor_key, anchor.bias); if let Some(insertion) = insertion_cursor.item() { let comparison = sum_tree::KeyedItem::key(insertion).cmp(&anchor_key); if comparison == Ordering::Greater @@ -2307,10 +2302,10 @@ impl BufferSnapshot { && comparison == Ordering::Equal && anchor.offset > 0) { - insertion_cursor.prev(&()); + insertion_cursor.prev(); } } else { - insertion_cursor.prev(&()); + insertion_cursor.prev(); } let Some(insertion) = insertion_cursor @@ -2324,7 +2319,7 @@ impl BufferSnapshot { }; let mut fragment_cursor = self.fragments.cursor::<(Option<&Locator>, usize)>(&None); - fragment_cursor.seek(&Some(&insertion.fragment_id), Bias::Left, &None); + fragment_cursor.seek(&Some(&insertion.fragment_id), Bias::Left); let fragment = fragment_cursor.item().unwrap(); let mut fragment_offset = fragment_cursor.start().1; if fragment.visible { @@ -2345,7 +2340,7 @@ impl BufferSnapshot { split_offset: anchor.offset, }; let mut insertion_cursor = self.insertions.cursor::(&()); - insertion_cursor.seek(&anchor_key, anchor.bias, &()); + insertion_cursor.seek(&anchor_key, anchor.bias); if let Some(insertion) = insertion_cursor.item() { let comparison = sum_tree::KeyedItem::key(insertion).cmp(&anchor_key); if comparison == Ordering::Greater @@ -2353,10 +2348,10 @@ impl BufferSnapshot { && comparison == Ordering::Equal && anchor.offset > 0) { - insertion_cursor.prev(&()); + insertion_cursor.prev(); } } else { - insertion_cursor.prev(&()); + insertion_cursor.prev(); } let Some(insertion) = insertion_cursor.item().filter(|insertion| { @@ -2395,7 +2390,7 @@ impl BufferSnapshot { Anchor::MAX } else { let mut fragment_cursor = self.fragments.cursor::(&None); - fragment_cursor.seek(&offset, bias, &None); + fragment_cursor.seek(&offset, bias); let fragment = fragment_cursor.item().unwrap(); let overshoot = offset - *fragment_cursor.start(); Anchor { @@ -2475,7 +2470,7 @@ impl BufferSnapshot { let mut cursor = self.fragments.filter(&None, move |summary| { !since.observed_all(&summary.max_version) }); - cursor.next(&None); + cursor.next(); Some(cursor) }; let mut cursor = self @@ -2483,7 +2478,7 @@ impl BufferSnapshot { .cursor::<(Option<&Locator>, FragmentTextSummary)>(&None); let start_fragment_id = self.fragment_id_for_anchor(&range.start); - cursor.seek(&Some(start_fragment_id), Bias::Left, &None); + cursor.seek(&Some(start_fragment_id), Bias::Left); let mut visible_start = cursor.start().1.visible; let mut deleted_start = cursor.start().1.deleted; if let Some(fragment) = cursor.item() { @@ -2516,7 +2511,7 @@ impl BufferSnapshot { let mut cursor = self.fragments.filter::<_, usize>(&None, move |summary| { !since.observed_all(&summary.max_version) }); - cursor.next(&None); + cursor.next(); while let Some(fragment) = cursor.item() { if fragment.id > *end_fragment_id { break; @@ -2528,7 +2523,7 @@ impl BufferSnapshot { return true; } } - cursor.next(&None); + cursor.next(); } } false @@ -2539,14 +2534,14 @@ impl BufferSnapshot { let mut cursor = self.fragments.filter::<_, usize>(&None, move |summary| { !since.observed_all(&summary.max_version) }); - cursor.next(&None); + cursor.next(); while let Some(fragment) = cursor.item() { let was_visible = fragment.was_visible(since, &self.undo_map); let is_visible = fragment.visible; if was_visible != is_visible { return true; } - cursor.next(&None); + cursor.next(); } } false @@ -2651,7 +2646,7 @@ impl bool> Iterator for Ed while let Some(fragment) = cursor.item() { if fragment.id < *self.range.start.0 { - cursor.next(&None); + cursor.next(); continue; } else if fragment.id > *self.range.end.0 { break; @@ -2684,7 +2679,7 @@ impl bool> Iterator for Ed }; if !fragment.was_visible(self.since, self.undos) && fragment.visible { - let mut visible_end = cursor.end(&None).visible; + let mut visible_end = cursor.end().visible; if fragment.id == *self.range.end.0 { visible_end = cmp::min( visible_end, @@ -2710,7 +2705,7 @@ impl bool> Iterator for Ed self.new_end = new_end; } else if fragment.was_visible(self.since, self.undos) && !fragment.visible { - let mut deleted_end = cursor.end(&None).deleted; + let mut deleted_end = cursor.end().deleted; if fragment.id == *self.range.end.0 { deleted_end = cmp::min( deleted_end, @@ -2740,7 +2735,7 @@ impl bool> Iterator for Ed self.old_end = old_end; } - cursor.next(&None); + cursor.next(); } pending_edit diff --git a/crates/text/src/undo_map.rs b/crates/text/src/undo_map.rs index ed363cfc6b..6a409189fa 100644 --- a/crates/text/src/undo_map.rs +++ b/crates/text/src/undo_map.rs @@ -74,7 +74,6 @@ impl UndoMap { undo_id: Default::default(), }, Bias::Left, - &(), ); let mut undo_count = 0; @@ -99,7 +98,6 @@ impl UndoMap { undo_id: Default::default(), }, Bias::Left, - &(), ); let mut undo_count = 0; diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs index 8c407fdd3e..4fc6b91abb 100644 --- a/crates/worktree/src/worktree.rs +++ b/crates/worktree/src/worktree.rs @@ -2454,16 +2454,16 @@ impl Snapshot { self.entries_by_path = { let mut cursor = self.entries_by_path.cursor::(&()); let mut new_entries_by_path = - cursor.slice(&TraversalTarget::path(&removed_entry.path), Bias::Left, &()); + cursor.slice(&TraversalTarget::path(&removed_entry.path), Bias::Left); while let Some(entry) = cursor.item() { if entry.path.starts_with(&removed_entry.path) { self.entries_by_id.remove(&entry.id, &()); - cursor.next(&()); + cursor.next(); } else { break; } } - new_entries_by_path.append(cursor.suffix(&()), &()); + new_entries_by_path.append(cursor.suffix(), &()); new_entries_by_path }; @@ -2576,7 +2576,6 @@ impl Snapshot { include_ignored, }, Bias::Right, - &(), ); Traversal { snapshot: self, @@ -2632,7 +2631,7 @@ impl Snapshot { options: ChildEntriesOptions, ) -> ChildEntriesIter<'a> { let mut cursor = self.entries_by_path.cursor(&()); - cursor.seek(&TraversalTarget::path(parent_path), Bias::Right, &()); + cursor.seek(&TraversalTarget::path(parent_path), Bias::Right); let traversal = Traversal { snapshot: self, cursor, @@ -3056,9 +3055,9 @@ impl BackgroundScannerState { .snapshot .entries_by_path .cursor::(&()); - new_entries = cursor.slice(&TraversalTarget::path(path), Bias::Left, &()); - removed_entries = cursor.slice(&TraversalTarget::successor(path), Bias::Left, &()); - new_entries.append(cursor.suffix(&()), &()); + new_entries = cursor.slice(&TraversalTarget::path(path), Bias::Left); + removed_entries = cursor.slice(&TraversalTarget::successor(path), Bias::Left); + new_entries.append(cursor.suffix(), &()); } self.snapshot.entries_by_path = new_entries; @@ -4925,15 +4924,15 @@ fn build_diff( let mut old_paths = old_snapshot.entries_by_path.cursor::(&()); let mut new_paths = new_snapshot.entries_by_path.cursor::(&()); let mut last_newly_loaded_dir_path = None; - old_paths.next(&()); - new_paths.next(&()); + old_paths.next(); + new_paths.next(); for path in event_paths { let path = PathKey(path.clone()); if old_paths.item().map_or(false, |e| e.path < path.0) { - old_paths.seek_forward(&path, Bias::Left, &()); + old_paths.seek_forward(&path, Bias::Left); } if new_paths.item().map_or(false, |e| e.path < path.0) { - new_paths.seek_forward(&path, Bias::Left, &()); + new_paths.seek_forward(&path, Bias::Left); } loop { match (old_paths.item(), new_paths.item()) { @@ -4949,7 +4948,7 @@ fn build_diff( match Ord::cmp(&old_entry.path, &new_entry.path) { Ordering::Less => { changes.push((old_entry.path.clone(), old_entry.id, Removed)); - old_paths.next(&()); + old_paths.next(); } Ordering::Equal => { if phase == EventsReceivedDuringInitialScan { @@ -4975,8 +4974,8 @@ fn build_diff( changes.push((new_entry.path.clone(), new_entry.id, Updated)); } } - old_paths.next(&()); - new_paths.next(&()); + old_paths.next(); + new_paths.next(); } Ordering::Greater => { let is_newly_loaded = phase == InitialScan @@ -4988,13 +4987,13 @@ fn build_diff( new_entry.id, if is_newly_loaded { Loaded } else { Added }, )); - new_paths.next(&()); + new_paths.next(); } } } (Some(old_entry), None) => { changes.push((old_entry.path.clone(), old_entry.id, Removed)); - old_paths.next(&()); + old_paths.next(); } (None, Some(new_entry)) => { let is_newly_loaded = phase == InitialScan @@ -5006,7 +5005,7 @@ fn build_diff( new_entry.id, if is_newly_loaded { Loaded } else { Added }, )); - new_paths.next(&()); + new_paths.next(); } (None, None) => break, } @@ -5255,7 +5254,7 @@ impl<'a> Traversal<'a> { start_path: &Path, ) -> Self { let mut cursor = snapshot.entries_by_path.cursor(&()); - cursor.seek(&TraversalTarget::path(start_path), Bias::Left, &()); + cursor.seek(&TraversalTarget::path(start_path), Bias::Left); let mut traversal = Self { snapshot, cursor, @@ -5282,14 +5281,13 @@ impl<'a> Traversal<'a> { include_ignored: self.include_ignored, }, Bias::Left, - &(), ) } pub fn advance_to_sibling(&mut self) -> bool { while let Some(entry) = self.cursor.item() { self.cursor - .seek_forward(&TraversalTarget::successor(&entry.path), Bias::Left, &()); + .seek_forward(&TraversalTarget::successor(&entry.path), Bias::Left); if let Some(entry) = self.cursor.item() { if (self.include_files || !entry.is_file()) && (self.include_dirs || !entry.is_dir()) @@ -5307,7 +5305,7 @@ impl<'a> Traversal<'a> { return false; }; self.cursor - .seek(&TraversalTarget::path(parent_path), Bias::Left, &()) + .seek(&TraversalTarget::path(parent_path), Bias::Left) } pub fn entry(&self) -> Option<&'a Entry> { @@ -5326,7 +5324,7 @@ impl<'a> Traversal<'a> { pub fn end_offset(&self) -> usize { self.cursor - .end(&()) + .end() .count(self.include_files, self.include_dirs, self.include_ignored) } } From caa520c4999a06907e3cdc6a81ecb634421f0c6a Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Tue, 22 Jul 2025 18:52:17 +0200 Subject: [PATCH 0129/1052] workspace: Clean up empty panes left over from file opening failures (#34908) Closes #34583 Release Notes: - Fixed empty pane being left after a binary file is dropped into a new pane.s --- crates/workspace/src/pane.rs | 41 ++++++++++++++++++++++-------------- 1 file changed, 25 insertions(+), 16 deletions(-) diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs index e57b103c61..c7a2562a1b 100644 --- a/crates/workspace/src/pane.rs +++ b/crates/workspace/src/pane.rs @@ -3239,28 +3239,37 @@ impl Pane { split_direction = None; } - if let Ok(open_task) = workspace.update_in(cx, |workspace, window, cx| { - if let Some(split_direction) = split_direction { - to_pane = workspace.split_pane(to_pane, split_direction, window, cx); - } - workspace.open_paths( - paths, - OpenOptions { - visible: Some(OpenVisible::OnlyDirectories), - ..Default::default() - }, - Some(to_pane.downgrade()), - window, - cx, - ) - }) { + if let Ok((open_task, to_pane)) = + workspace.update_in(cx, |workspace, window, cx| { + if let Some(split_direction) = split_direction { + to_pane = + workspace.split_pane(to_pane, split_direction, window, cx); + } + ( + workspace.open_paths( + paths, + OpenOptions { + visible: Some(OpenVisible::OnlyDirectories), + ..Default::default() + }, + Some(to_pane.downgrade()), + window, + cx, + ), + to_pane, + ) + }) + { let opened_items: Vec<_> = open_task.await; - _ = workspace.update(cx, |workspace, cx| { + _ = workspace.update_in(cx, |workspace, window, cx| { for item in opened_items.into_iter().flatten() { if let Err(e) = item { workspace.show_error(&e, cx); } } + if to_pane.read(cx).items_len() == 0 { + workspace.remove_pane(to_pane, None, window, cx); + } }); } }) From 14cea06f0fb591129df0faac2163dcaf74444a83 Mon Sep 17 00:00:00 2001 From: Ben Kunkle Date: Tue, 22 Jul 2025 12:18:59 -0500 Subject: [PATCH 0130/1052] keymap_ui: Fix panic in clear keystrokes (#34909) Closes #ISSUE Release Notes: - N/A *or* Added/Fixed/Improved ... --- crates/settings_ui/src/keybindings.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/crates/settings_ui/src/keybindings.rs b/crates/settings_ui/src/keybindings.rs index 5f940e8a25..9e885f69f6 100644 --- a/crates/settings_ui/src/keybindings.rs +++ b/crates/settings_ui/src/keybindings.rs @@ -2784,6 +2784,7 @@ impl KeystrokeInput { else { log::trace!("No keybinding to stop recording keystrokes in keystroke input"); self.close_keystrokes.take(); + self.close_keystrokes_start.take(); return CloseKeystrokeResult::None; }; let action_keystrokes = keybind_for_close_action.keystrokes(); @@ -2976,7 +2977,9 @@ impl KeystrokeInput { return; } window.focus(&self.outer_focus_handle); - if let Some(close_keystrokes_start) = self.close_keystrokes_start.take() { + if let Some(close_keystrokes_start) = self.close_keystrokes_start.take() + && close_keystrokes_start < self.keystrokes.len() + { self.keystrokes.drain(close_keystrokes_start..); } self.close_keystrokes.take(); From d81a8178e916f92c3277098f1f199b05b0d20bde Mon Sep 17 00:00:00 2001 From: Michael Sloan Date: Tue, 22 Jul 2025 11:35:58 -0600 Subject: [PATCH 0131/1052] Bind "j k" to `NormalBefore` in initial keymap examples (#34912) It looks like typically vim configurations bind "j k" to be the same as escape, which has the "NormalBefore" behavior positioning the block cursor on the character before the insertion cursor. The [vim mode docs](https://zed.dev/docs/vim#useful-contexts-for-vim-mode-key-bindings) also use NormalBefore here. Thanks to @omniwrench for mentioning this in https://github.com/zed-industries/zed/discussions/6661#discussioncomment-13848043 . This was a mistake in #31163. Release Notes: - N/A --- assets/keymaps/initial.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/assets/keymaps/initial.json b/assets/keymaps/initial.json index 0cfd28f0e5..ff6069a816 100644 --- a/assets/keymaps/initial.json +++ b/assets/keymaps/initial.json @@ -15,7 +15,7 @@ { "context": "Editor && vim_mode == insert && !menu", "bindings": { - // "j k": "vim::SwitchToNormalMode" + // "j k": "vim::NormalBefore" } } ] From 9e280d09057ec1d8481f64b48b24869d325a5574 Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Tue, 22 Jul 2025 13:42:07 -0400 Subject: [PATCH 0132/1052] collab: Remove unneeded caching of Stripe price IDs by meter ID (#34915) This PR removes the caching of Stripe price IDs by meter ID on the `StripeBilling` object, as we weren't actually reading them anywhere. Release Notes: - N/A --- crates/collab/src/stripe_billing.rs | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/crates/collab/src/stripe_billing.rs b/crates/collab/src/stripe_billing.rs index 707928d5cd..50accf9557 100644 --- a/crates/collab/src/stripe_billing.rs +++ b/crates/collab/src/stripe_billing.rs @@ -30,7 +30,6 @@ pub struct StripeBilling { #[derive(Default)] struct StripeBillingState { - price_ids_by_meter_id: HashMap, prices_by_lookup_key: HashMap, } @@ -63,13 +62,7 @@ impl StripeBilling { for price in prices { if let Some(lookup_key) = price.lookup_key.clone() { - state.prices_by_lookup_key.insert(lookup_key, price.clone()); - } - - if let Some(recurring) = price.recurring { - if let Some(meter) = recurring.meter { - state.price_ids_by_meter_id.insert(meter, price.id); - } + state.prices_by_lookup_key.insert(lookup_key, price); } } From 99466f4aebbf20dc00077dcce55f3b4ce1d2b1d3 Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Tue, 22 Jul 2025 13:57:36 -0400 Subject: [PATCH 0133/1052] Make zooming from menus not persist (#34910) Closes: https://github.com/zed-industries/zed/issues/34479 Follow-up to: https://github.com/zed-industries/zed/issues/23505 View->Zoom In / Zoom Out / Reset Zoom were not reverted to match when the default keybindings were reverted. Release Notes: - N/A --- crates/zed/src/zed/app_menus.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/crates/zed/src/zed/app_menus.rs b/crates/zed/src/zed/app_menus.rs index c4131dbee9..78532b10b4 100644 --- a/crates/zed/src/zed/app_menus.rs +++ b/crates/zed/src/zed/app_menus.rs @@ -145,15 +145,15 @@ pub fn app_menus() -> Vec { items: vec![ MenuItem::action( "Zoom In", - zed_actions::IncreaseBufferFontSize { persist: true }, + zed_actions::IncreaseBufferFontSize { persist: false }, ), MenuItem::action( "Zoom Out", - zed_actions::DecreaseBufferFontSize { persist: true }, + zed_actions::DecreaseBufferFontSize { persist: false }, ), MenuItem::action( "Reset Zoom", - zed_actions::ResetBufferFontSize { persist: true }, + zed_actions::ResetBufferFontSize { persist: false }, ), MenuItem::separator(), MenuItem::action("Toggle Left Dock", workspace::ToggleLeftDock), From 4272c1508e22a96a5822b422ee5a0b3dd1621512 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Tue, 22 Jul 2025 15:41:12 -0300 Subject: [PATCH 0134/1052] ai onboarding: Copyedit the whole flow (#34916) Release Notes: - N/A Co-authored-by: Katie Geer --- .../src/agent_api_keys_onboarding.rs | 4 +- crates/ai_onboarding/src/ai_onboarding.rs | 41 ++++++++----------- .../ai_onboarding/src/young_account_banner.rs | 2 +- 3 files changed, 19 insertions(+), 28 deletions(-) diff --git a/crates/ai_onboarding/src/agent_api_keys_onboarding.rs b/crates/ai_onboarding/src/agent_api_keys_onboarding.rs index 883317e566..5f56e4d26e 100644 --- a/crates/ai_onboarding/src/agent_api_keys_onboarding.rs +++ b/crates/ai_onboarding/src/agent_api_keys_onboarding.rs @@ -93,7 +93,7 @@ impl Render for ApiKeysWithProviders { div() .w_full() .child( - Label::new("Or start now using API keys from your environment for the following providers:") + Label::new("Start now using API keys from your environment for the following providers:") .color(Color::Muted) ) ) @@ -129,7 +129,7 @@ impl RenderOnce for ApiKeysWithoutProviders { .child(Divider::horizontal()), ) .child(List::new().child(BulletItem::new( - "You can also use AI in Zed by bringing your own API keys", + "Add your own keys to use AI without signing in.", ))) .child( Button::new("configure-providers", "Configure Providers") diff --git a/crates/ai_onboarding/src/ai_onboarding.rs b/crates/ai_onboarding/src/ai_onboarding.rs index 88c962c1ba..e8ce22ff4e 100644 --- a/crates/ai_onboarding/src/ai_onboarding.rs +++ b/crates/ai_onboarding/src/ai_onboarding.rs @@ -141,22 +141,18 @@ impl ZedAiOnboarding { ) .child( List::new() + .child(BulletItem::new("50 prompts per month with Claude models")) .child(BulletItem::new( - "50 prompts per month with the Claude models", - )) - .child(BulletItem::new( - "2000 accepted edit predictions using our open-source Zeta model", + "2,000 accepted edit predictions with Zeta, our open-source model", )), ) } fn pro_trial_definition(&self) -> impl IntoElement { List::new() + .child(BulletItem::new("150 prompts with Claude models")) .child(BulletItem::new( - "150 prompts per month with the Claude models", - )) - .child(BulletItem::new( - "Unlimited accepted edit predictions using our open-source Zeta model", + "Unlimited accepted edit predictions with Zeta, our open-source model", )) } @@ -178,12 +174,12 @@ impl ZedAiOnboarding { List::new() .child(BulletItem::new("500 prompts per month with Claude models")) .child(BulletItem::new( - "Unlimited accepted edit predictions using our open-source Zeta model", + "Unlimited accepted edit predictions with Zeta, our open-source model", )) - .child(BulletItem::new("USD $20 per month")), + .child(BulletItem::new("$20 USD per month")), ) .child( - Button::new("pro", "Start with Pro") + Button::new("pro", "Get Started") .full_width() .style(ButtonStyle::Tinted(ui::TintColor::Accent)) .on_click(move |_, _window, cx| { @@ -206,11 +202,11 @@ impl ZedAiOnboarding { List::new() .child(self.pro_trial_definition()) .child(BulletItem::new( - "Try it out for 14 days with no charge and no credit card required", + "Try it out for 14 days for free, no credit card required", )), ) .child( - Button::new("pro", "Start Pro Trial") + Button::new("pro", "Start Free Trial") .full_width() .style(ButtonStyle::Tinted(ui::TintColor::Accent)) .on_click(move |_, _window, cx| { @@ -225,14 +221,14 @@ impl ZedAiOnboarding { v_flex() .gap_1() .w_full() - .child(Headline::new("Before starting…")) + .child(Headline::new("Accept Terms of Service")) .child( - Label::new("Make sure you have read and accepted Zed AI's terms of service.") + Label::new("We don’t sell your data, track you across the web, or compromise your privacy.") .color(Color::Muted) .mb_2(), ) .child( - Button::new("terms_of_service", "View and Read the Terms of Service") + Button::new("terms_of_service", "Review Terms of Service") .full_width() .style(ButtonStyle::Outlined) .icon(IconName::ArrowUpRight) @@ -241,7 +237,7 @@ impl ZedAiOnboarding { .on_click(move |_, _window, cx| cx.open_url(&zed_urls::terms_of_service(cx))), ) .child( - Button::new("accept_terms", "I've read it and accept it") + Button::new("accept_terms", "Accept") .full_width() .style(ButtonStyle::Tinted(TintColor::Accent)) .on_click({ @@ -259,13 +255,13 @@ impl ZedAiOnboarding { .gap_1() .child(Headline::new("Welcome to Zed AI")) .child( - Label::new("Sign in to start using AI in Zed with a free trial of the Pro plan, which includes:") + Label::new("Sign in to try Zed Pro for 14 days, no credit card required.") .color(Color::Muted) .mb_2(), ) .child(self.pro_trial_definition()) .child( - Button::new("sign_in", "Sign in to Start Trial") + Button::new("sign_in", "Try Zed Pro for Free") .disabled(signing_in) .full_width() .style(ButtonStyle::Tinted(ui::TintColor::Accent)) @@ -284,11 +280,6 @@ impl ZedAiOnboarding { .relative() .gap_1() .child(Headline::new("Welcome to Zed AI")) - .child( - Label::new("Choose how you want to start.") - .color(Color::Muted) - .mb_2(), - ) .map(|this| { if self.account_too_young { this.child(young_account_banner) @@ -318,7 +309,7 @@ impl ZedAiOnboarding { v_flex() .relative() .gap_1() - .child(Headline::new("Welcome to the Zed Pro free trial")) + .child(Headline::new("Welcome to the Zed Pro Trial")) .child( Label::new("Here's what you get for the next 14 days:") .color(Color::Muted) diff --git a/crates/ai_onboarding/src/young_account_banner.rs b/crates/ai_onboarding/src/young_account_banner.rs index 1e1ed3a865..a43625a60e 100644 --- a/crates/ai_onboarding/src/young_account_banner.rs +++ b/crates/ai_onboarding/src/young_account_banner.rs @@ -6,7 +6,7 @@ pub struct YoungAccountBanner; impl RenderOnce for YoungAccountBanner { fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement { - const YOUNG_ACCOUNT_DISCLAIMER: &str = "To prevent abuse of our service, we cannot offer plans to GitHub accounts created fewer than 30 days ago. To request an exception, reach out to billing@zed.dev."; + const YOUNG_ACCOUNT_DISCLAIMER: &str = "To prevent abuse of our service, we cannot offer plans to GitHub accounts created fewer than 30 days ago. To request an exception, reach out to billing-support@zed.dev."; let label = div() .w_full() From 708c2645d104e39d01122ada2ebc0771d4f1623b Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Tue, 22 Jul 2025 20:53:57 +0200 Subject: [PATCH 0135/1052] collab: Tweak screen selector appearance (#34919) Co-authored-by: Danilo Leal Release Notes: - N/A Co-authored-by: Danilo Leal --- crates/git_ui/src/git_ui.rs | 2 +- crates/title_bar/src/collab.rs | 21 +++++++--- .../ui/src/components/button/split_button.rs | 40 ++++++++++++++----- crates/ui/src/components/list/list.rs | 4 +- 4 files changed, 48 insertions(+), 19 deletions(-) diff --git a/crates/git_ui/src/git_ui.rs b/crates/git_ui/src/git_ui.rs index a9ccaf7160..02b9c243fb 100644 --- a/crates/git_ui/src/git_ui.rs +++ b/crates/git_ui/src/git_ui.rs @@ -501,7 +501,7 @@ mod remote_button { ) .into_any_element(); - SplitButton { left, right } + SplitButton::new(left, right) } } diff --git a/crates/title_bar/src/collab.rs b/crates/title_bar/src/collab.rs index 1eebc0de0c..056c981ccf 100644 --- a/crates/title_bar/src/collab.rs +++ b/crates/title_bar/src/collab.rs @@ -11,8 +11,8 @@ use gpui::{App, Task, Window, actions}; use rpc::proto::{self}; use theme::ActiveTheme; use ui::{ - Avatar, AvatarAudioStatusIndicator, ContextMenu, ContextMenuItem, Facepile, PopoverMenu, - SplitButton, TintColor, Tooltip, prelude::*, + Avatar, AvatarAudioStatusIndicator, ContextMenu, ContextMenuItem, Divider, Facepile, + PopoverMenu, SplitButton, SplitButtonStyle, TintColor, Tooltip, prelude::*, }; use util::maybe; use workspace::notifications::DetachAndPromptErr; @@ -383,6 +383,7 @@ impl TitleBar { .detach_and_log_err(cx); }), ) + .child(Divider::vertical()) .into_any_element(), ); @@ -497,6 +498,7 @@ impl TitleBar { trigger.render(window, cx), self.render_screen_list().into_any_element(), ) + .style(SplitButtonStyle::Outlined) .into_any_element(), ); } @@ -547,10 +549,17 @@ impl TitleBar { entry_render: Box::new(move |_, _| { h_flex() .gap_2() - .child(Icon::new(IconName::Screen).when( - active_screenshare_id == Some(meta.id), - |this| this.color(Color::Accent), - )) + .child( + Icon::new(IconName::Screen) + .size(IconSize::XSmall) + .map(|this| { + if active_screenshare_id == Some(meta.id) { + this.color(Color::Accent) + } else { + this.color(Color::Muted) + } + }), + ) .child(Label::new(label.clone())) .child( Label::new(resolution.clone()) diff --git a/crates/ui/src/components/button/split_button.rs b/crates/ui/src/components/button/split_button.rs index c0811ecbab..a7fa2106d1 100644 --- a/crates/ui/src/components/button/split_button.rs +++ b/crates/ui/src/components/button/split_button.rs @@ -1,6 +1,6 @@ use gpui::{ AnyElement, App, BoxShadow, IntoElement, ParentElement, RenderOnce, Styled, Window, div, hsla, - point, px, + point, prelude::FluentBuilder, px, }; use theme::ActiveTheme; @@ -8,6 +8,12 @@ use crate::{ElevationIndex, h_flex}; use super::ButtonLike; +#[derive(Clone, Copy, PartialEq)] +pub enum SplitButtonStyle { + Filled, + Outlined, +} + /// /// A button with two parts: a primary action on the left and a secondary action on the right. /// /// The left side is a [`ButtonLike`] with the main action, while the right side can contain @@ -18,11 +24,21 @@ use super::ButtonLike; pub struct SplitButton { pub left: ButtonLike, pub right: AnyElement, + style: SplitButtonStyle, } impl SplitButton { pub fn new(left: ButtonLike, right: AnyElement) -> Self { - Self { left, right } + Self { + left, + right, + style: SplitButtonStyle::Filled, + } + } + + pub fn style(mut self, style: SplitButtonStyle) -> Self { + self.style = style; + self } } @@ -31,21 +47,23 @@ impl RenderOnce for SplitButton { h_flex() .rounded_sm() .border_1() - .border_color(cx.theme().colors().text_muted.alpha(0.12)) + .border_color(cx.theme().colors().border.opacity(0.5)) .child(div().flex_grow().child(self.left)) .child( div() .h_full() .w_px() - .bg(cx.theme().colors().text_muted.alpha(0.16)), + .bg(cx.theme().colors().border.opacity(0.5)), ) .child(self.right) - .bg(ElevationIndex::Surface.on_elevation_bg(cx)) - .shadow(vec![BoxShadow { - color: hsla(0.0, 0.0, 0.0, 0.16), - offset: point(px(0.), px(1.)), - blur_radius: px(0.), - spread_radius: px(0.), - }]) + .when(self.style == SplitButtonStyle::Filled, |this| { + this.bg(ElevationIndex::Surface.on_elevation_bg(cx)) + .shadow(vec![BoxShadow { + color: hsla(0.0, 0.0, 0.0, 0.16), + offset: point(px(0.), px(1.)), + blur_radius: px(0.), + spread_radius: px(0.), + }]) + }) } } diff --git a/crates/ui/src/components/list/list.rs b/crates/ui/src/components/list/list.rs index 1402b5d3d3..b6950f06a4 100644 --- a/crates/ui/src/components/list/list.rs +++ b/crates/ui/src/components/list/list.rs @@ -84,7 +84,9 @@ impl RenderOnce for List { (false, _) => this.children(self.children), (true, Some(false)) => this, (true, _) => match self.empty_message { - EmptyMessage::Text(text) => this.child(Label::new(text).color(Color::Muted)), + EmptyMessage::Text(text) => { + this.px_2().child(Label::new(text).color(Color::Muted)) + } EmptyMessage::Element(element) => this.child(element), }, }) From c0f75e1a175f0bf7a0931ecad9fb9e803034a3b0 Mon Sep 17 00:00:00 2001 From: Remco Smits Date: Tue, 22 Jul 2025 21:39:52 +0200 Subject: [PATCH 0136/1052] debugger: Fix built-in JavaScript debug tasks were not working due missing `type` field value (#34894) Release Notes: - Debugger: Fix built-in JavaScript debug tasks were not working due missing `type` field value --- assets/settings/initial_debug_tasks.json | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/assets/settings/initial_debug_tasks.json b/assets/settings/initial_debug_tasks.json index 78fc1fc5f0..af4512bd51 100644 --- a/assets/settings/initial_debug_tasks.json +++ b/assets/settings/initial_debug_tasks.json @@ -15,13 +15,15 @@ "adapter": "JavaScript", "program": "$ZED_FILE", "request": "launch", - "cwd": "$ZED_WORKTREE_ROOT" + "cwd": "$ZED_WORKTREE_ROOT", + "type": "pwa-node" }, { "label": "JavaScript debug terminal", "adapter": "JavaScript", "request": "launch", "cwd": "$ZED_WORKTREE_ROOT", - "console": "integratedTerminal" + "console": "integratedTerminal", + "type": "pwa-node" } ] From 446d333515fc6d6fca0a8c5ef3e929506c49396f Mon Sep 17 00:00:00 2001 From: Remco Smits Date: Tue, 22 Jul 2025 21:40:11 +0200 Subject: [PATCH 0137/1052] debugger: Fix debug console persist to history when reusing a previous item (#34893) Closes #34887 Release Notes: - Debugger: Fix debug console persist to history when reusing a previous item --- crates/project/src/search_history.rs | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/crates/project/src/search_history.rs b/crates/project/src/search_history.rs index b84c2e0982..90b169bb0c 100644 --- a/crates/project/src/search_history.rs +++ b/crates/project/src/search_history.rs @@ -45,12 +45,6 @@ impl SearchHistory { } pub fn add(&mut self, cursor: &mut SearchHistoryCursor, search_string: String) { - if let Some(selected_ix) = cursor.selection { - if self.history.get(selected_ix) == Some(&search_string) { - return; - } - } - if self.insertion_behavior == QueryInsertionBehavior::ReplacePreviousIfContains { if let Some(previously_searched) = self.history.back_mut() { if search_string.contains(previously_searched.as_str()) { @@ -144,6 +138,14 @@ mod tests { ); assert_eq!(search_history.current(&cursor), Some("rustlang")); + // add item when it equals to current item if it's not the last one + search_history.add(&mut cursor, "php".to_string()); + search_history.previous(&mut cursor); + assert_eq!(search_history.current(&cursor), Some("rustlang")); + search_history.add(&mut cursor, "rustlang".to_string()); + assert_eq!(search_history.history.len(), 3, "Should add item"); + assert_eq!(search_history.current(&cursor), Some("rustlang")); + // push enough items to test SEARCH_HISTORY_LIMIT for i in 0..MAX_HISTORY_LEN * 2 { search_history.add(&mut cursor, format!("item{i}")); From f3c332d839a2fa4d3b8ba6906a497171f5de9a74 Mon Sep 17 00:00:00 2001 From: Umesh Yadav <23421535+imumesh18@users.noreply.github.com> Date: Wed, 23 Jul 2025 01:16:25 +0530 Subject: [PATCH 0138/1052] Fix new crate license symlink (#34922) The license file is not properly linked to actual license. This was casued due to new-crate script linking the license to wrong file. Fixed both of them. Reference logs: ``` 2025-07-22T17:16:19+05:30 ERROR [worktree] error reading target of symlink "/Users/umesh/code/zed/crates/onboarding/LICENSE-GPL": canonicalizing ``` Release Notes: - N/A --- crates/onboarding/LICENSE-GPL | 2 +- script/new-crate | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/onboarding/LICENSE-GPL b/crates/onboarding/LICENSE-GPL index dd648cce4f..89e542f750 120000 --- a/crates/onboarding/LICENSE-GPL +++ b/crates/onboarding/LICENSE-GPL @@ -1 +1 @@ -../../../LICENSE-GPL \ No newline at end of file +../../LICENSE-GPL \ No newline at end of file diff --git a/script/new-crate b/script/new-crate index df574981e7..52ee900b30 100755 --- a/script/new-crate +++ b/script/new-crate @@ -39,7 +39,7 @@ CRATE_PATH="crates/$CRATE_NAME" mkdir -p "$CRATE_PATH/src" # Symlink the license -ln -sf "../../../$LICENSE_FILE" "$CRATE_PATH/$LICENSE_FILE" +ln -sf "../../$LICENSE_FILE" "$CRATE_PATH/$LICENSE_FILE" CARGO_TOML_TEMPLATE=$(cat << 'EOF' [package] From 7f70325a93b63d47cc08ce9e040ba0dcb27f306c Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Tue, 22 Jul 2025 16:04:08 -0400 Subject: [PATCH 0139/1052] language_models: Rename `handler` to `handle` in Bedrock provider (#34923) This PR renames the `handler` field to `handle` on the `BedrockLanguageModelProvider` and `BedrockModel` structs. Release Notes: - N/A --- crates/language_models/src/provider/bedrock.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/crates/language_models/src/provider/bedrock.rs b/crates/language_models/src/provider/bedrock.rs index a022511b11..a86b3e78f5 100644 --- a/crates/language_models/src/provider/bedrock.rs +++ b/crates/language_models/src/provider/bedrock.rs @@ -243,7 +243,7 @@ impl State { pub struct BedrockLanguageModelProvider { http_client: AwsHttpClient, - handler: tokio::runtime::Handle, + handle: tokio::runtime::Handle, state: gpui::Entity, } @@ -260,7 +260,7 @@ impl BedrockLanguageModelProvider { Self { http_client: AwsHttpClient::new(http_client.clone()), - handler: Tokio::handle(cx), + handle: Tokio::handle(cx), state, } } @@ -270,7 +270,7 @@ impl BedrockLanguageModelProvider { id: LanguageModelId::from(model.id().to_string()), model, http_client: self.http_client.clone(), - handler: self.handler.clone(), + handle: self.handle.clone(), state: self.state.clone(), client: OnceCell::new(), request_limiter: RateLimiter::new(4), @@ -371,7 +371,7 @@ struct BedrockModel { id: LanguageModelId, model: Model, http_client: AwsHttpClient, - handler: tokio::runtime::Handle, + handle: tokio::runtime::Handle, client: OnceCell, state: gpui::Entity, request_limiter: RateLimiter, @@ -443,7 +443,7 @@ impl BedrockModel { } } - let config = self.handler.block_on(config_builder.load()); + let config = self.handle.block_on(config_builder.load()); anyhow::Ok(BedrockClient::new(&config)) }) .context("initializing Bedrock client")?; From 5d985fa1d8684aa85e1bbde944c4f1b42591fedd Mon Sep 17 00:00:00 2001 From: Agus Zubiaga Date: Tue, 22 Jul 2025 19:14:34 -0300 Subject: [PATCH 0140/1052] Improve MCP server responses (#34927) Release Notes: - N/A --- crates/agent_servers/src/claude/mcp_server.rs | 26 ++++++++----------- crates/agent_servers/src/claude/tools.rs | 10 ------- 2 files changed, 11 insertions(+), 25 deletions(-) diff --git a/crates/agent_servers/src/claude/mcp_server.rs b/crates/agent_servers/src/claude/mcp_server.rs index 468027c4c3..2405603550 100644 --- a/crates/agent_servers/src/claude/mcp_server.rs +++ b/crates/agent_servers/src/claude/mcp_server.rs @@ -19,7 +19,7 @@ use util::debug_panic; use crate::claude::{ McpServerConfig, - tools::{ClaudeTool, EditToolParams, EditToolResponse, ReadToolParams, ReadToolResponse}, + tools::{ClaudeTool, EditToolParams, ReadToolParams}, }; pub struct ClaudeMcpServer { @@ -179,11 +179,9 @@ impl ClaudeMcpServer { let input = serde_json::from_value(request.arguments.context("Arguments required")?)?; - let result = Self::handle_read_tool_call(input, delegate, cx).await?; + let content = Self::handle_read_tool_call(input, delegate, cx).await?; Ok(CallToolResponse { - content: vec![ToolResponseContent::Text { - text: serde_json::to_string(&result)?, - }], + content, is_error: None, meta: None, }) @@ -191,11 +189,9 @@ impl ClaudeMcpServer { let input = serde_json::from_value(request.arguments.context("Arguments required")?)?; - let result = Self::handle_edit_tool_call(input, delegate, cx).await?; + Self::handle_edit_tool_call(input, delegate, cx).await?; Ok(CallToolResponse { - content: vec![ToolResponseContent::Text { - text: serde_json::to_string(&result)?, - }], + content: vec![], is_error: None, meta: None, }) @@ -209,7 +205,7 @@ impl ClaudeMcpServer { params: ReadToolParams, delegate: AcpClientDelegate, cx: &AsyncApp, - ) -> Task> { + ) -> Task>> { cx.foreground_executor().spawn(async move { let response = delegate .read_text_file(ReadTextFileParams { @@ -219,9 +215,9 @@ impl ClaudeMcpServer { }) .await?; - Ok(ReadToolResponse { - content: response.content, - }) + Ok(vec![ToolResponseContent::Text { + text: response.content, + }]) }) } @@ -229,7 +225,7 @@ impl ClaudeMcpServer { params: EditToolParams, delegate: AcpClientDelegate, cx: &AsyncApp, - ) -> Task> { + ) -> Task> { cx.foreground_executor().spawn(async move { let response = delegate .read_text_file_reusing_snapshot(ReadTextFileParams { @@ -251,7 +247,7 @@ impl ClaudeMcpServer { }) .await?; - Ok(EditToolResponse) + Ok(()) }) } diff --git a/crates/agent_servers/src/claude/tools.rs b/crates/agent_servers/src/claude/tools.rs index 9c82139a07..75a26ee230 100644 --- a/crates/agent_servers/src/claude/tools.rs +++ b/crates/agent_servers/src/claude/tools.rs @@ -434,10 +434,6 @@ pub struct EditToolParams { pub new_text: String, } -#[derive(Serialize)] -#[serde(rename_all = "camelCase")] -pub struct EditToolResponse; - #[derive(Deserialize, JsonSchema, Debug)] pub struct ReadToolParams { /// The absolute path to the file to read. @@ -450,12 +446,6 @@ pub struct ReadToolParams { pub limit: Option, } -#[derive(Serialize)] -#[serde(rename_all = "camelCase")] -pub struct ReadToolResponse { - pub content: String, -} - #[derive(Deserialize, JsonSchema, Debug)] pub struct WriteToolParams { /// Absolute path for new file From 056003860af3894327b8685caf705cc4f873ba85 Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Tue, 22 Jul 2025 18:57:07 -0400 Subject: [PATCH 0141/1052] collab: Remove `POST /billing/subscriptions` endpoint (#34928) This PR removes the `POST /billing/subscriptions` endpoint, as it has been moved to `cloud.zed.dev`. Release Notes: - N/A --- crates/collab/src/api/billing.rs | 119 +-------- crates/collab/src/stripe_billing.rs | 104 +------- .../collab/src/tests/stripe_billing_tests.rs | 249 +----------------- 3 files changed, 9 insertions(+), 463 deletions(-) diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs index 9aa6578b2a..d6e42ad2fb 100644 --- a/crates/collab/src/api/billing.rs +++ b/crates/collab/src/api/billing.rs @@ -25,7 +25,7 @@ use crate::llm::db::subscription_usage_meter::{self, CompletionMode}; use crate::rpc::{ResultExt as _, Server}; use crate::stripe_client::{ StripeCancellationDetailsReason, StripeClient, StripeCustomerId, StripeSubscription, - StripeSubscriptionId, UpdateCustomerParams, + StripeSubscriptionId, }; use crate::{AppState, Error, Result}; use crate::{db::UserId, llm::db::LlmDatabase}; @@ -40,7 +40,6 @@ use crate::{ pub fn router() -> Router { Router::new() - .route("/billing/subscriptions", post(create_billing_subscription)) .route( "/billing/subscriptions/manage", post(manage_billing_subscription), @@ -51,122 +50,6 @@ pub fn router() -> Router { ) } -#[derive(Debug, PartialEq, Clone, Copy, Deserialize)] -#[serde(rename_all = "snake_case")] -enum ProductCode { - ZedPro, - ZedProTrial, -} - -#[derive(Debug, Deserialize)] -struct CreateBillingSubscriptionBody { - github_user_id: i32, - product: ProductCode, -} - -#[derive(Debug, Serialize)] -struct CreateBillingSubscriptionResponse { - checkout_session_url: String, -} - -/// Initiates a Stripe Checkout session for creating a billing subscription. -async fn create_billing_subscription( - Extension(app): Extension>, - extract::Json(body): extract::Json, -) -> Result> { - let user = app - .db - .get_user_by_github_user_id(body.github_user_id) - .await? - .context("user not found")?; - - let Some(stripe_billing) = app.stripe_billing.clone() else { - log::error!("failed to retrieve Stripe billing object"); - Err(Error::http( - StatusCode::NOT_IMPLEMENTED, - "not supported".into(), - ))? - }; - - if let Some(existing_subscription) = app.db.get_active_billing_subscription(user.id).await? { - let is_checkout_allowed = body.product == ProductCode::ZedProTrial - && existing_subscription.kind == Some(SubscriptionKind::ZedFree); - - if !is_checkout_allowed { - return Err(Error::http( - StatusCode::CONFLICT, - "user already has an active subscription".into(), - )); - } - } - - let existing_billing_customer = app.db.get_billing_customer_by_user_id(user.id).await?; - if let Some(existing_billing_customer) = &existing_billing_customer { - if existing_billing_customer.has_overdue_invoices { - return Err(Error::http( - StatusCode::PAYMENT_REQUIRED, - "user has overdue invoices".into(), - )); - } - } - - let customer_id = if let Some(existing_customer) = &existing_billing_customer { - let customer_id = StripeCustomerId(existing_customer.stripe_customer_id.clone().into()); - if let Some(email) = user.email_address.as_deref() { - stripe_billing - .client() - .update_customer(&customer_id, UpdateCustomerParams { email: Some(email) }) - .await - // Update of email address is best-effort - continue checkout even if it fails - .context("error updating stripe customer email address") - .log_err(); - } - customer_id - } else { - stripe_billing - .find_or_create_customer_by_email(user.email_address.as_deref()) - .await? - }; - - let success_url = format!( - "{}/account?checkout_complete=1", - app.config.zed_dot_dev_url() - ); - - let checkout_session_url = match body.product { - ProductCode::ZedPro => { - stripe_billing - .checkout_with_zed_pro(&customer_id, &user.github_login, &success_url) - .await? - } - ProductCode::ZedProTrial => { - if let Some(existing_billing_customer) = &existing_billing_customer { - if existing_billing_customer.trial_started_at.is_some() { - return Err(Error::http( - StatusCode::FORBIDDEN, - "user already used free trial".into(), - )); - } - } - - let feature_flags = app.db.get_user_flags(user.id).await?; - - stripe_billing - .checkout_with_zed_pro_trial( - &customer_id, - &user.github_login, - feature_flags, - &success_url, - ) - .await? - } - }; - - Ok(Json(CreateBillingSubscriptionResponse { - checkout_session_url, - })) -} - #[derive(Debug, PartialEq, Deserialize)] #[serde(rename_all = "snake_case")] enum ManageSubscriptionIntent { diff --git a/crates/collab/src/stripe_billing.rs b/crates/collab/src/stripe_billing.rs index 50accf9557..850b716a9f 100644 --- a/crates/collab/src/stripe_billing.rs +++ b/crates/collab/src/stripe_billing.rs @@ -1,6 +1,6 @@ use std::sync::Arc; -use anyhow::{Context as _, anyhow}; +use anyhow::anyhow; use chrono::Utc; use collections::HashMap; use stripe::SubscriptionStatus; @@ -9,18 +9,13 @@ use uuid::Uuid; use crate::Result; use crate::db::billing_subscription::SubscriptionKind; -use crate::llm::AGENT_EXTENDED_TRIAL_FEATURE_FLAG; use crate::stripe_client::{ - RealStripeClient, StripeAutomaticTax, StripeBillingAddressCollection, - StripeCheckoutSessionMode, StripeCheckoutSessionPaymentMethodCollection, StripeClient, - StripeCreateCheckoutSessionLineItems, StripeCreateCheckoutSessionParams, - StripeCreateCheckoutSessionSubscriptionData, StripeCreateMeterEventParams, + RealStripeClient, StripeAutomaticTax, StripeClient, StripeCreateMeterEventParams, StripeCreateMeterEventPayload, StripeCreateSubscriptionItems, StripeCreateSubscriptionParams, - StripeCustomerId, StripeCustomerUpdate, StripeCustomerUpdateAddress, StripeCustomerUpdateName, - StripePrice, StripePriceId, StripeSubscription, StripeSubscriptionId, + StripeCustomerId, StripePrice, StripePriceId, StripeSubscription, StripeSubscriptionId, StripeSubscriptionTrialSettings, StripeSubscriptionTrialSettingsEndBehavior, - StripeSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod, StripeTaxIdCollection, - UpdateSubscriptionItems, UpdateSubscriptionParams, + StripeSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod, UpdateSubscriptionItems, + UpdateSubscriptionParams, }; pub struct StripeBilling { @@ -214,95 +209,6 @@ impl StripeBilling { Ok(()) } - pub async fn checkout_with_zed_pro( - &self, - customer_id: &StripeCustomerId, - github_login: &str, - success_url: &str, - ) -> Result { - let zed_pro_price_id = self.zed_pro_price_id().await?; - - let mut params = StripeCreateCheckoutSessionParams::default(); - params.mode = Some(StripeCheckoutSessionMode::Subscription); - params.customer = Some(customer_id); - params.client_reference_id = Some(github_login); - params.line_items = Some(vec![StripeCreateCheckoutSessionLineItems { - price: Some(zed_pro_price_id.to_string()), - quantity: Some(1), - }]); - params.success_url = Some(success_url); - params.billing_address_collection = Some(StripeBillingAddressCollection::Required); - params.customer_update = Some(StripeCustomerUpdate { - address: Some(StripeCustomerUpdateAddress::Auto), - name: Some(StripeCustomerUpdateName::Auto), - shipping: None, - }); - params.tax_id_collection = Some(StripeTaxIdCollection { enabled: true }); - - let session = self.client.create_checkout_session(params).await?; - Ok(session.url.context("no checkout session URL")?) - } - - pub async fn checkout_with_zed_pro_trial( - &self, - customer_id: &StripeCustomerId, - github_login: &str, - feature_flags: Vec, - success_url: &str, - ) -> Result { - let zed_pro_price_id = self.zed_pro_price_id().await?; - - let eligible_for_extended_trial = feature_flags - .iter() - .any(|flag| flag == AGENT_EXTENDED_TRIAL_FEATURE_FLAG); - - let trial_period_days = if eligible_for_extended_trial { 60 } else { 14 }; - - let mut subscription_metadata = std::collections::HashMap::new(); - if eligible_for_extended_trial { - subscription_metadata.insert( - "promo_feature_flag".to_string(), - AGENT_EXTENDED_TRIAL_FEATURE_FLAG.to_string(), - ); - } - - let mut params = StripeCreateCheckoutSessionParams::default(); - params.subscription_data = Some(StripeCreateCheckoutSessionSubscriptionData { - trial_period_days: Some(trial_period_days), - trial_settings: Some(StripeSubscriptionTrialSettings { - end_behavior: StripeSubscriptionTrialSettingsEndBehavior { - missing_payment_method: - StripeSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod::Cancel, - }, - }), - metadata: if !subscription_metadata.is_empty() { - Some(subscription_metadata) - } else { - None - }, - }); - params.mode = Some(StripeCheckoutSessionMode::Subscription); - params.payment_method_collection = - Some(StripeCheckoutSessionPaymentMethodCollection::IfRequired); - params.customer = Some(customer_id); - params.client_reference_id = Some(github_login); - params.line_items = Some(vec![StripeCreateCheckoutSessionLineItems { - price: Some(zed_pro_price_id.to_string()), - quantity: Some(1), - }]); - params.success_url = Some(success_url); - params.billing_address_collection = Some(StripeBillingAddressCollection::Required); - params.customer_update = Some(StripeCustomerUpdate { - address: Some(StripeCustomerUpdateAddress::Auto), - name: Some(StripeCustomerUpdateName::Auto), - shipping: None, - }); - params.tax_id_collection = Some(StripeTaxIdCollection { enabled: true }); - - let session = self.client.create_checkout_session(params).await?; - Ok(session.url.context("no checkout session URL")?) - } - pub async fn subscribe_to_zed_free( &self, customer_id: StripeCustomerId, diff --git a/crates/collab/src/tests/stripe_billing_tests.rs b/crates/collab/src/tests/stripe_billing_tests.rs index c19eb0a234..5c5bcd5832 100644 --- a/crates/collab/src/tests/stripe_billing_tests.rs +++ b/crates/collab/src/tests/stripe_billing_tests.rs @@ -3,17 +3,11 @@ use std::sync::Arc; use chrono::{Duration, Utc}; use pretty_assertions::assert_eq; -use crate::llm::AGENT_EXTENDED_TRIAL_FEATURE_FLAG; use crate::stripe_billing::StripeBilling; use crate::stripe_client::{ - FakeStripeClient, StripeBillingAddressCollection, StripeCheckoutSessionMode, - StripeCheckoutSessionPaymentMethodCollection, StripeCreateCheckoutSessionLineItems, - StripeCreateCheckoutSessionSubscriptionData, StripeCustomerId, StripeCustomerUpdate, - StripeCustomerUpdateAddress, StripeCustomerUpdateName, StripeMeter, StripeMeterId, StripePrice, - StripePriceId, StripePriceRecurring, StripeSubscription, StripeSubscriptionId, - StripeSubscriptionItem, StripeSubscriptionItemId, StripeSubscriptionTrialSettings, - StripeSubscriptionTrialSettingsEndBehavior, - StripeSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod, UpdateSubscriptionItems, + FakeStripeClient, StripeCustomerId, StripeMeter, StripeMeterId, StripePrice, StripePriceId, + StripePriceRecurring, StripeSubscription, StripeSubscriptionId, StripeSubscriptionItem, + StripeSubscriptionItemId, UpdateSubscriptionItems, }; fn make_stripe_billing() -> (StripeBilling, Arc) { @@ -364,240 +358,3 @@ async fn test_bill_model_request_usage() { ); assert_eq!(create_meter_event_calls[0].value, 73); } - -#[gpui::test] -async fn test_checkout_with_zed_pro() { - let (stripe_billing, stripe_client) = make_stripe_billing(); - - let customer_id = StripeCustomerId("cus_test".into()); - let github_login = "zeduser1"; - let success_url = "https://example.com/success"; - - // It returns an error when the Zed Pro price doesn't exist. - { - let result = stripe_billing - .checkout_with_zed_pro(&customer_id, github_login, success_url) - .await; - - assert!(result.is_err()); - assert_eq!( - result.err().unwrap().to_string(), - r#"no price ID found for "zed-pro""# - ); - } - - // Successful checkout. - { - let price = StripePrice { - id: StripePriceId("price_1".into()), - unit_amount: Some(2000), - lookup_key: Some("zed-pro".to_string()), - recurring: None, - }; - stripe_client - .prices - .lock() - .insert(price.id.clone(), price.clone()); - - stripe_billing.initialize().await.unwrap(); - - let checkout_url = stripe_billing - .checkout_with_zed_pro(&customer_id, github_login, success_url) - .await - .unwrap(); - - assert!(checkout_url.starts_with("https://checkout.stripe.com/c/pay")); - - let create_checkout_session_calls = stripe_client - .create_checkout_session_calls - .lock() - .drain(..) - .collect::>(); - assert_eq!(create_checkout_session_calls.len(), 1); - let call = create_checkout_session_calls.into_iter().next().unwrap(); - assert_eq!(call.customer, Some(customer_id)); - assert_eq!(call.client_reference_id.as_deref(), Some(github_login)); - assert_eq!(call.mode, Some(StripeCheckoutSessionMode::Subscription)); - assert_eq!( - call.line_items, - Some(vec![StripeCreateCheckoutSessionLineItems { - price: Some(price.id.to_string()), - quantity: Some(1) - }]) - ); - assert_eq!(call.payment_method_collection, None); - assert_eq!(call.subscription_data, None); - assert_eq!(call.success_url.as_deref(), Some(success_url)); - assert_eq!( - call.billing_address_collection, - Some(StripeBillingAddressCollection::Required) - ); - assert_eq!( - call.customer_update, - Some(StripeCustomerUpdate { - address: Some(StripeCustomerUpdateAddress::Auto), - name: Some(StripeCustomerUpdateName::Auto), - shipping: None, - }) - ); - } -} - -#[gpui::test] -async fn test_checkout_with_zed_pro_trial() { - let (stripe_billing, stripe_client) = make_stripe_billing(); - - let customer_id = StripeCustomerId("cus_test".into()); - let github_login = "zeduser1"; - let success_url = "https://example.com/success"; - - // It returns an error when the Zed Pro price doesn't exist. - { - let result = stripe_billing - .checkout_with_zed_pro_trial(&customer_id, github_login, Vec::new(), success_url) - .await; - - assert!(result.is_err()); - assert_eq!( - result.err().unwrap().to_string(), - r#"no price ID found for "zed-pro""# - ); - } - - let price = StripePrice { - id: StripePriceId("price_1".into()), - unit_amount: Some(2000), - lookup_key: Some("zed-pro".to_string()), - recurring: None, - }; - stripe_client - .prices - .lock() - .insert(price.id.clone(), price.clone()); - - stripe_billing.initialize().await.unwrap(); - - // Successful checkout. - { - let checkout_url = stripe_billing - .checkout_with_zed_pro_trial(&customer_id, github_login, Vec::new(), success_url) - .await - .unwrap(); - - assert!(checkout_url.starts_with("https://checkout.stripe.com/c/pay")); - - let create_checkout_session_calls = stripe_client - .create_checkout_session_calls - .lock() - .drain(..) - .collect::>(); - assert_eq!(create_checkout_session_calls.len(), 1); - let call = create_checkout_session_calls.into_iter().next().unwrap(); - assert_eq!(call.customer.as_ref(), Some(&customer_id)); - assert_eq!(call.client_reference_id.as_deref(), Some(github_login)); - assert_eq!(call.mode, Some(StripeCheckoutSessionMode::Subscription)); - assert_eq!( - call.line_items, - Some(vec![StripeCreateCheckoutSessionLineItems { - price: Some(price.id.to_string()), - quantity: Some(1) - }]) - ); - assert_eq!( - call.payment_method_collection, - Some(StripeCheckoutSessionPaymentMethodCollection::IfRequired) - ); - assert_eq!( - call.subscription_data, - Some(StripeCreateCheckoutSessionSubscriptionData { - trial_period_days: Some(14), - trial_settings: Some(StripeSubscriptionTrialSettings { - end_behavior: StripeSubscriptionTrialSettingsEndBehavior { - missing_payment_method: - StripeSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod::Cancel, - }, - }), - metadata: None, - }) - ); - assert_eq!(call.success_url.as_deref(), Some(success_url)); - assert_eq!( - call.billing_address_collection, - Some(StripeBillingAddressCollection::Required) - ); - assert_eq!( - call.customer_update, - Some(StripeCustomerUpdate { - address: Some(StripeCustomerUpdateAddress::Auto), - name: Some(StripeCustomerUpdateName::Auto), - shipping: None, - }) - ); - } - - // Successful checkout with extended trial. - { - let checkout_url = stripe_billing - .checkout_with_zed_pro_trial( - &customer_id, - github_login, - vec![AGENT_EXTENDED_TRIAL_FEATURE_FLAG.to_string()], - success_url, - ) - .await - .unwrap(); - - assert!(checkout_url.starts_with("https://checkout.stripe.com/c/pay")); - - let create_checkout_session_calls = stripe_client - .create_checkout_session_calls - .lock() - .drain(..) - .collect::>(); - assert_eq!(create_checkout_session_calls.len(), 1); - let call = create_checkout_session_calls.into_iter().next().unwrap(); - assert_eq!(call.customer, Some(customer_id)); - assert_eq!(call.client_reference_id.as_deref(), Some(github_login)); - assert_eq!(call.mode, Some(StripeCheckoutSessionMode::Subscription)); - assert_eq!( - call.line_items, - Some(vec![StripeCreateCheckoutSessionLineItems { - price: Some(price.id.to_string()), - quantity: Some(1) - }]) - ); - assert_eq!( - call.payment_method_collection, - Some(StripeCheckoutSessionPaymentMethodCollection::IfRequired) - ); - assert_eq!( - call.subscription_data, - Some(StripeCreateCheckoutSessionSubscriptionData { - trial_period_days: Some(60), - trial_settings: Some(StripeSubscriptionTrialSettings { - end_behavior: StripeSubscriptionTrialSettingsEndBehavior { - missing_payment_method: - StripeSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod::Cancel, - }, - }), - metadata: Some(std::collections::HashMap::from_iter([( - "promo_feature_flag".into(), - AGENT_EXTENDED_TRIAL_FEATURE_FLAG.into() - )])), - }) - ); - assert_eq!(call.success_url.as_deref(), Some(success_url)); - assert_eq!( - call.billing_address_collection, - Some(StripeBillingAddressCollection::Required) - ); - assert_eq!( - call.customer_update, - Some(StripeCustomerUpdate { - address: Some(StripeCustomerUpdateAddress::Auto), - name: Some(StripeCustomerUpdateName::Auto), - shipping: None, - }) - ); - } -} From e90cf0b9412b7f8fcb557d1edb2c3f586c7bd45b Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Wed, 23 Jul 2025 06:46:24 +0530 Subject: [PATCH 0142/1052] workspace: Fix last removed folder from workspace used to reopen on Zed startup (#34925) Closes #34924 Now, when `local_paths` are empty, we detach `session_id` from that workspace serialization item. This way, when we restore it using the default "last_session", we don't restore this workspace back. This is same as when we use `cmd-w` to close window, which also sets `session_id` to `None` before serialization. Release Notes: - Fixed an issue where last removed folder from workspace used to reopen on Zed startup. --- crates/workspace/src/persistence.rs | 8 +++ crates/workspace/src/workspace.rs | 87 ++++++++++++++++++----------- 2 files changed, 61 insertions(+), 34 deletions(-) diff --git a/crates/workspace/src/persistence.rs b/crates/workspace/src/persistence.rs index 406f37419d..3f8b098203 100644 --- a/crates/workspace/src/persistence.rs +++ b/crates/workspace/src/persistence.rs @@ -1336,6 +1336,14 @@ impl WorkspaceDb { } } + query! { + pub(crate) async fn set_session_id(workspace_id: WorkspaceId, session_id: Option) -> Result<()> { + UPDATE workspaces + SET session_id = ?2 + WHERE workspace_id = ?1 + } + } + pub async fn toolchain( &self, workspace_id: WorkspaceId, diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index f37abe59e2..2c223c476b 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -1016,6 +1016,15 @@ pub enum OpenVisible { OnlyDirectories, } +enum WorkspaceLocation { + // Valid local paths or SSH project to serialize + Location(SerializedWorkspaceLocation), + // No valid location found hence clear session id + DetachFromSession, + // No valid location found to serialize + None, +} + type PromptForNewPath = Box< dyn Fn( &mut Workspace, @@ -1135,7 +1144,6 @@ impl Workspace { this.update_window_title(window, cx); this.serialize_workspace(window, cx); // This event could be triggered by `AddFolderToProject` or `RemoveFromProject`. - // So we need to update the history. this.update_history(cx); } @@ -5218,48 +5226,58 @@ impl Workspace { } } - if let Some(location) = self.serialize_workspace_location(cx) { - let breakpoints = self.project.update(cx, |project, cx| { - project - .breakpoint_store() - .read(cx) - .all_source_breakpoints(cx) - }); + match self.serialize_workspace_location(cx) { + WorkspaceLocation::Location(location) => { + let breakpoints = self.project.update(cx, |project, cx| { + project + .breakpoint_store() + .read(cx) + .all_source_breakpoints(cx) + }); - let center_group = build_serialized_pane_group(&self.center.root, window, cx); - let docks = build_serialized_docks(self, window, cx); - let window_bounds = Some(SerializedWindowBounds(window.window_bounds())); - let serialized_workspace = SerializedWorkspace { - id: database_id, - location, - center_group, - window_bounds, - display: Default::default(), - docks, - centered_layout: self.centered_layout, - session_id: self.session_id.clone(), - breakpoints, - window_id: Some(window.window_handle().window_id().as_u64()), - }; + let center_group = build_serialized_pane_group(&self.center.root, window, cx); + let docks = build_serialized_docks(self, window, cx); + let window_bounds = Some(SerializedWindowBounds(window.window_bounds())); + let serialized_workspace = SerializedWorkspace { + id: database_id, + location, + center_group, + window_bounds, + display: Default::default(), + docks, + centered_layout: self.centered_layout, + session_id: self.session_id.clone(), + breakpoints, + window_id: Some(window.window_handle().window_id().as_u64()), + }; - return window.spawn(cx, async move |_| { - persistence::DB.save_workspace(serialized_workspace).await; - }); + window.spawn(cx, async move |_| { + persistence::DB.save_workspace(serialized_workspace).await; + }) + } + WorkspaceLocation::DetachFromSession => window.spawn(cx, async move |_| { + persistence::DB + .set_session_id(database_id, None) + .await + .log_err(); + }), + WorkspaceLocation::None => Task::ready(()), } - Task::ready(()) } - fn serialize_workspace_location(&self, cx: &App) -> Option { + fn serialize_workspace_location(&self, cx: &App) -> WorkspaceLocation { if let Some(ssh_project) = &self.serialized_ssh_project { - Some(SerializedWorkspaceLocation::Ssh(ssh_project.clone())) + WorkspaceLocation::Location(SerializedWorkspaceLocation::Ssh(ssh_project.clone())) } else if let Some(local_paths) = self.local_paths(cx) { if !local_paths.is_empty() { - Some(SerializedWorkspaceLocation::from_local_paths(local_paths)) + WorkspaceLocation::Location(SerializedWorkspaceLocation::from_local_paths( + local_paths, + )) } else { - None + WorkspaceLocation::DetachFromSession } } else { - None + WorkspaceLocation::None } } @@ -5267,8 +5285,9 @@ impl Workspace { let Some(id) = self.database_id() else { return; }; - let Some(location) = self.serialize_workspace_location(cx) else { - return; + let location = match self.serialize_workspace_location(cx) { + WorkspaceLocation::Location(location) => location, + _ => return, }; if let Some(manager) = HistoryManager::global(cx) { manager.update(cx, |this, cx| { From 11ac83f3d46b2f979a3a13918ea9912f73d21501 Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Wed, 23 Jul 2025 06:48:31 +0530 Subject: [PATCH 0143/1052] workspace: Fix closing remote workspace restores last local workspace on startup (#34931) Closes #7759 While opening a new SSH project if we are reusing an existing window, i.e. drop the existing workspace and create a new one, then before dropping it, we should remove `session_id` from that workspace's serialized entry. That way: 1. Upon closing (cmd-w) this remote workspace (which also clears `session_id` for this), and then quitting. No workspace with that `session_id` is found, and it starts fresh. 2. Upon directly quitting (cmd-q) this remote workspace, only this workspace exists in db (among two of them) with that `session_id`, and it restores correctly. Release Notes: - Fixed an issue while closing remote workspace restores last local workspace on startup. --- crates/workspace/src/workspace.rs | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index 2c223c476b..4c70c52d5a 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -7378,6 +7378,17 @@ async fn open_ssh_project_inner( return Err(project_path_errors.pop().context("no paths given")?); } + if let Some(detach_session_task) = window + .update(cx, |_workspace, window, cx| { + cx.spawn_in(window, async move |this, cx| { + this.update_in(cx, |this, window, cx| this.remove_from_session(window, cx)) + }) + }) + .ok() + { + detach_session_task.await.ok(); + } + cx.update_window(window.into(), |_, window, cx| { window.replace_root(cx, |window, cx| { telemetry::event!("SSH Project Opened"); From 3e27fa1d92d084a3374691a83bd3ab5766b14ad8 Mon Sep 17 00:00:00 2001 From: Jason Lee Date: Wed, 23 Jul 2025 10:10:40 +0800 Subject: [PATCH 0144/1052] gpui: Allow Animation to be cloned (#34933) Release Notes: - N/A --- Let `Animation` able to clone, then we can define one to share for multiple places. For example: image --- crates/gpui/src/elements/animation.rs | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/crates/gpui/src/elements/animation.rs b/crates/gpui/src/elements/animation.rs index bcdfa3562c..11dd19e260 100644 --- a/crates/gpui/src/elements/animation.rs +++ b/crates/gpui/src/elements/animation.rs @@ -1,4 +1,7 @@ -use std::time::{Duration, Instant}; +use std::{ + rc::Rc, + time::{Duration, Instant}, +}; use crate::{ AnyElement, App, Element, ElementId, GlobalElementId, InspectorElementId, IntoElement, Window, @@ -8,6 +11,7 @@ pub use easing::*; use smallvec::SmallVec; /// An animation that can be applied to an element. +#[derive(Clone)] pub struct Animation { /// The amount of time for which this animation should run pub duration: Duration, @@ -15,7 +19,7 @@ pub struct Animation { pub oneshot: bool, /// A function that takes a delta between 0 and 1 and returns a new delta /// between 0 and 1 based on the given easing function. - pub easing: Box f32>, + pub easing: Rc f32>, } impl Animation { @@ -25,7 +29,7 @@ impl Animation { Self { duration, oneshot: true, - easing: Box::new(linear), + easing: Rc::new(linear), } } @@ -39,7 +43,7 @@ impl Animation { /// The easing function will take a time delta between 0 and 1 and return a new delta /// between 0 and 1 pub fn with_easing(mut self, easing: impl Fn(f32) -> f32 + 'static) -> Self { - self.easing = Box::new(easing); + self.easing = Rc::new(easing); self } } From 500ceaabcde9d78b3a1a0d14674523e497dbc6e4 Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Tue, 22 Jul 2025 22:39:32 -0400 Subject: [PATCH 0145/1052] Add an `editor: diff clipboard with selection` action (#33283) https://github.com/user-attachments/assets/d472fbdd-7736-4bd7-8a90-8cca356b2815 This PR adds `editor: diff clipboard with selection` - good for spotting the differences in eerily-similar code, which is when refactoring code, as you need to see what needs to be passed in in order to maintain previous behavior of both snippets. 1. Copy some text from anywhere 2. Highlight some text in Zed 3. Run `editor: diff clipboard with selection` Like JetBrains' IDEs and VS Code with the `PartialDiff` package, if the selection is empty, we take the entire buffer as the selection. Caveats: - We do not know the language of the text in the clipboard. I went ahead and just assumed that in most cases, it will be the same language as the selected text, which does mean we will highlight the old text incorrectly if they are copying from a different language, but I think in most cases, it will be the same, and the alternative of always having no syntax highlighting is worse. PyCharm seems to do the same thing. Release Notes: - Added an `editor: diff clipboard with selection` action --------- Co-authored-by: Junkui Zhang <364772080@qq.com> Co-authored-by: Ben Kunkle --- crates/editor/src/actions.rs | 9 + crates/editor/src/editor.rs | 36 ++ crates/editor/src/element.rs | 1 + .../src/{diff_view.rs => file_diff_view.rs} | 106 ++-- crates/git_ui/src/git_ui.rs | 15 +- crates/git_ui/src/text_diff_view.rs | 554 ++++++++++++++++++ crates/gpui/src/app/entity_map.rs | 2 +- crates/zed/src/zed/open_listener.rs | 4 +- 8 files changed, 671 insertions(+), 56 deletions(-) rename crates/git_ui/src/{diff_view.rs => file_diff_view.rs} (89%) create mode 100644 crates/git_ui/src/text_diff_view.rs diff --git a/crates/editor/src/actions.rs b/crates/editor/src/actions.rs index 8557b57f46..f80a6afbbb 100644 --- a/crates/editor/src/actions.rs +++ b/crates/editor/src/actions.rs @@ -259,6 +259,13 @@ pub struct SpawnNearestTask { pub reveal: task::RevealStrategy, } +#[derive(Clone, PartialEq, Action)] +#[action(no_json, no_register)] +pub struct DiffClipboardWithSelectionData { + pub clipboard_text: String, + pub editor: Entity, +} + #[derive(Debug, PartialEq, Eq, Clone, Copy, Deserialize, Default)] pub enum UuidVersion { #[default] @@ -398,6 +405,8 @@ actions!( DeleteToNextSubwordEnd, /// Deletes to the start of the previous subword. DeleteToPreviousSubwordStart, + /// Diffs the text stored in the clipboard against the current selection. + DiffClipboardWithSelection, /// Displays names of all active cursors. DisplayCursorNames, /// Duplicates the current line below. diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index 1f985eeb7c..a31f789fb0 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -213,6 +213,7 @@ use workspace::{ notifications::{DetachAndPromptErr, NotificationId, NotifyTaskExt}, searchable::SearchEvent, }; +use zed_actions; use crate::{ code_context_menus::CompletionsMenuSource, @@ -12154,6 +12155,41 @@ impl Editor { }); } + pub fn diff_clipboard_with_selection( + &mut self, + _: &DiffClipboardWithSelection, + window: &mut Window, + cx: &mut Context, + ) { + let selections = self.selections.all::(cx); + + if selections.is_empty() { + log::warn!("There should always be at least one selection in Zed. This is a bug."); + return; + }; + + let clipboard_text = match cx.read_from_clipboard() { + Some(item) => match item.entries().first() { + Some(ClipboardEntry::String(text)) => Some(text.text().to_string()), + _ => None, + }, + None => None, + }; + + let Some(clipboard_text) = clipboard_text else { + log::warn!("Clipboard doesn't contain text."); + return; + }; + + window.dispatch_action( + Box::new(DiffClipboardWithSelectionData { + clipboard_text, + editor: cx.entity(), + }), + cx, + ); + } + pub fn paste(&mut self, _: &Paste, window: &mut Window, cx: &mut Context) { self.hide_mouse_cursor(HideMouseCursorOrigin::TypingAction, cx); if let Some(item) = cx.read_from_clipboard() { diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index cbff544c7e..1b372a7d53 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -262,6 +262,7 @@ impl EditorElement { register_action(editor, window, Editor::kill_ring_yank); register_action(editor, window, Editor::copy); register_action(editor, window, Editor::copy_and_trim); + register_action(editor, window, Editor::diff_clipboard_with_selection); register_action(editor, window, Editor::paste); register_action(editor, window, Editor::undo); register_action(editor, window, Editor::redo); diff --git a/crates/git_ui/src/diff_view.rs b/crates/git_ui/src/file_diff_view.rs similarity index 89% rename from crates/git_ui/src/diff_view.rs rename to crates/git_ui/src/file_diff_view.rs index 9e03dd5f38..2f8a744ed8 100644 --- a/crates/git_ui/src/diff_view.rs +++ b/crates/git_ui/src/file_diff_view.rs @@ -1,4 +1,4 @@ -//! DiffView provides a UI for displaying differences between two buffers. +//! FileDiffView provides a UI for displaying differences between two buffers. use anyhow::Result; use buffer_diff::{BufferDiff, BufferDiffSnapshot}; @@ -25,7 +25,7 @@ use workspace::{ searchable::SearchableItemHandle, }; -pub struct DiffView { +pub struct FileDiffView { editor: Entity, old_buffer: Entity, new_buffer: Entity, @@ -35,7 +35,7 @@ pub struct DiffView { const RECALCULATE_DIFF_DEBOUNCE: Duration = Duration::from_millis(250); -impl DiffView { +impl FileDiffView { pub fn open( old_path: PathBuf, new_path: PathBuf, @@ -57,7 +57,7 @@ impl DiffView { workspace.update_in(cx, |workspace, window, cx| { let diff_view = cx.new(|cx| { - DiffView::new( + FileDiffView::new( old_buffer, new_buffer, buffer_diff, @@ -190,15 +190,15 @@ async fn build_buffer_diff( }) } -impl EventEmitter for DiffView {} +impl EventEmitter for FileDiffView {} -impl Focusable for DiffView { +impl Focusable for FileDiffView { fn focus_handle(&self, cx: &App) -> FocusHandle { self.editor.focus_handle(cx) } } -impl Item for DiffView { +impl Item for FileDiffView { type Event = EditorEvent; fn tab_icon(&self, _window: &Window, _cx: &App) -> Option { @@ -216,48 +216,37 @@ impl Item for DiffView { } fn tab_content_text(&self, _detail: usize, cx: &App) -> SharedString { - let old_filename = self - .old_buffer - .read(cx) - .file() - .and_then(|file| { - Some( - file.full_path(cx) - .file_name()? - .to_string_lossy() - .to_string(), - ) - }) - .unwrap_or_else(|| "untitled".into()); - let new_filename = self - .new_buffer - .read(cx) - .file() - .and_then(|file| { - Some( - file.full_path(cx) - .file_name()? - .to_string_lossy() - .to_string(), - ) - }) - .unwrap_or_else(|| "untitled".into()); + let title_text = |buffer: &Entity| { + buffer + .read(cx) + .file() + .and_then(|file| { + Some( + file.full_path(cx) + .file_name()? + .to_string_lossy() + .to_string(), + ) + }) + .unwrap_or_else(|| "untitled".into()) + }; + let old_filename = title_text(&self.old_buffer); + let new_filename = title_text(&self.new_buffer); + format!("{old_filename} ↔ {new_filename}").into() } fn tab_tooltip_text(&self, cx: &App) -> Option { - let old_path = self - .old_buffer - .read(cx) - .file() - .map(|file| file.full_path(cx).compact().to_string_lossy().to_string()) - .unwrap_or_else(|| "untitled".into()); - let new_path = self - .new_buffer - .read(cx) - .file() - .map(|file| file.full_path(cx).compact().to_string_lossy().to_string()) - .unwrap_or_else(|| "untitled".into()); + let path = |buffer: &Entity| { + buffer + .read(cx) + .file() + .map(|file| file.full_path(cx).compact().to_string_lossy().to_string()) + .unwrap_or_else(|| "untitled".into()) + }; + let old_path = path(&self.old_buffer); + let new_path = path(&self.new_buffer); + Some(format!("{old_path} ↔ {new_path}").into()) } @@ -363,7 +352,7 @@ impl Item for DiffView { } } -impl Render for DiffView { +impl Render for FileDiffView { fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement { self.editor.clone() } @@ -407,16 +396,16 @@ mod tests { ) .await; - let project = Project::test(fs.clone(), ["/test".as_ref()], cx).await; + let project = Project::test(fs.clone(), [path!("/test").as_ref()], cx).await; let (workspace, mut cx) = cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx)); let diff_view = workspace .update_in(cx, |workspace, window, cx| { - DiffView::open( - PathBuf::from(path!("/test/old_file.txt")), - PathBuf::from(path!("/test/new_file.txt")), + FileDiffView::open( + path!("/test/old_file.txt").into(), + path!("/test/new_file.txt").into(), workspace, window, cx, @@ -510,6 +499,21 @@ mod tests { ", ), ); + + diff_view.read_with(cx, |diff_view, cx| { + assert_eq!( + diff_view.tab_content_text(0, cx), + "old_file.txt ↔ new_file.txt" + ); + assert_eq!( + diff_view.tab_tooltip_text(cx).unwrap(), + format!( + "{} ↔ {}", + path!("test/old_file.txt"), + path!("test/new_file.txt") + ) + ); + }) } #[gpui::test] @@ -533,7 +537,7 @@ mod tests { let diff_view = workspace .update_in(cx, |workspace, window, cx| { - DiffView::open( + FileDiffView::open( PathBuf::from(path!("/test/old_file.txt")), PathBuf::from(path!("/test/new_file.txt")), workspace, diff --git a/crates/git_ui/src/git_ui.rs b/crates/git_ui/src/git_ui.rs index 02b9c243fb..2d7fba13c5 100644 --- a/crates/git_ui/src/git_ui.rs +++ b/crates/git_ui/src/git_ui.rs @@ -3,7 +3,7 @@ use std::any::Any; use ::settings::Settings; use command_palette_hooks::CommandPaletteFilter; use commit_modal::CommitModal; -use editor::Editor; +use editor::{Editor, actions::DiffClipboardWithSelectionData}; mod blame_ui; use git::{ repository::{Branch, Upstream, UpstreamTracking, UpstreamTrackingStatus}, @@ -15,6 +15,9 @@ use onboarding::GitOnboardingModal; use project_diff::ProjectDiff; use ui::prelude::*; use workspace::Workspace; +use zed_actions; + +use crate::text_diff_view::TextDiffView; mod askpass_modal; pub mod branch_picker; @@ -22,7 +25,7 @@ mod commit_modal; pub mod commit_tooltip; mod commit_view; mod conflict_view; -pub mod diff_view; +pub mod file_diff_view; pub mod git_panel; mod git_panel_settings; pub mod onboarding; @@ -30,6 +33,7 @@ pub mod picker_prompt; pub mod project_diff; pub(crate) mod remote_output; pub mod repository_selector; +pub mod text_diff_view; actions!( git, @@ -152,6 +156,13 @@ pub fn init(cx: &mut App) { workspace.register_action(|workspace, _: &git::OpenModifiedFiles, window, cx| { open_modified_files(workspace, window, cx); }); + workspace.register_action( + |workspace, action: &DiffClipboardWithSelectionData, window, cx| { + if let Some(task) = TextDiffView::open(action, workspace, window, cx) { + task.detach(); + }; + }, + ); }) .detach(); } diff --git a/crates/git_ui/src/text_diff_view.rs b/crates/git_ui/src/text_diff_view.rs new file mode 100644 index 0000000000..e7386cf7bd --- /dev/null +++ b/crates/git_ui/src/text_diff_view.rs @@ -0,0 +1,554 @@ +//! TextDiffView currently provides a UI for displaying differences between the clipboard and selected text. + +use anyhow::Result; +use buffer_diff::{BufferDiff, BufferDiffSnapshot}; +use editor::{Editor, EditorEvent, MultiBuffer, ToPoint, actions::DiffClipboardWithSelectionData}; +use futures::{FutureExt, select_biased}; +use gpui::{ + AnyElement, AnyView, App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, + FocusHandle, Focusable, IntoElement, Render, Task, Window, +}; +use language::{self, Buffer, Point}; +use project::Project; +use std::{ + any::{Any, TypeId}, + ops::Range, + pin::pin, + sync::Arc, + time::Duration, +}; +use ui::{Color, Icon, IconName, Label, LabelCommon as _, SharedString}; +use util::paths::PathExt; + +use workspace::{ + Item, ItemHandle as _, ItemNavHistory, ToolbarItemLocation, Workspace, + item::{BreadcrumbText, ItemEvent, SaveOptions, TabContentParams}, + searchable::SearchableItemHandle, +}; + +pub struct TextDiffView { + diff_editor: Entity, + title: SharedString, + path: Option, + buffer_changes_tx: watch::Sender<()>, + _recalculate_diff_task: Task>, +} + +const RECALCULATE_DIFF_DEBOUNCE: Duration = Duration::from_millis(250); + +impl TextDiffView { + pub fn open( + diff_data: &DiffClipboardWithSelectionData, + workspace: &Workspace, + window: &mut Window, + cx: &mut App, + ) -> Option>>> { + let source_editor = diff_data.editor.clone(); + + let source_editor_buffer_and_range = source_editor.update(cx, |editor, cx| { + let multibuffer = editor.buffer().read(cx); + let source_buffer = multibuffer.as_singleton()?.clone(); + let selections = editor.selections.all::(cx); + let buffer_snapshot = source_buffer.read(cx); + let first_selection = selections.first()?; + let selection_range = if first_selection.is_empty() { + Point::new(0, 0)..buffer_snapshot.max_point() + } else { + first_selection.start..first_selection.end + }; + + Some((source_buffer, selection_range)) + }); + + let Some((source_buffer, selected_range)) = source_editor_buffer_and_range else { + log::warn!("There should always be at least one selection in Zed. This is a bug."); + return None; + }; + + let clipboard_text = diff_data.clipboard_text.clone(); + + let workspace = workspace.weak_handle(); + + let diff_buffer = cx.new(|cx| { + let source_buffer_snapshot = source_buffer.read(cx).snapshot(); + let diff = BufferDiff::new(&source_buffer_snapshot.text, cx); + diff + }); + + let clipboard_buffer = + build_clipboard_buffer(clipboard_text, &source_buffer, selected_range.clone(), cx); + + let task = window.spawn(cx, async move |cx| { + let project = workspace.update(cx, |workspace, _| workspace.project().clone())?; + + update_diff_buffer(&diff_buffer, &source_buffer, &clipboard_buffer, cx).await?; + + workspace.update_in(cx, |workspace, window, cx| { + let diff_view = cx.new(|cx| { + TextDiffView::new( + clipboard_buffer, + source_editor, + source_buffer, + selected_range, + diff_buffer, + project, + window, + cx, + ) + }); + + let pane = workspace.active_pane(); + pane.update(cx, |pane, cx| { + pane.add_item(Box::new(diff_view.clone()), true, true, None, window, cx); + }); + + diff_view + }) + }); + + Some(task) + } + + pub fn new( + clipboard_buffer: Entity, + source_editor: Entity, + source_buffer: Entity, + source_range: Range, + diff_buffer: Entity, + project: Entity, + window: &mut Window, + cx: &mut Context, + ) -> Self { + let multibuffer = cx.new(|cx| { + let mut multibuffer = MultiBuffer::new(language::Capability::ReadWrite); + + multibuffer.push_excerpts( + source_buffer.clone(), + [editor::ExcerptRange::new(source_range)], + cx, + ); + + multibuffer.add_diff(diff_buffer.clone(), cx); + multibuffer + }); + let diff_editor = cx.new(|cx| { + let mut editor = Editor::for_multibuffer(multibuffer, Some(project), window, cx); + editor.start_temporary_diff_override(); + editor.disable_diagnostics(cx); + editor.set_expand_all_diff_hunks(cx); + editor.set_render_diff_hunk_controls( + Arc::new(|_, _, _, _, _, _, _, _| gpui::Empty.into_any_element()), + cx, + ); + editor + }); + + let (buffer_changes_tx, mut buffer_changes_rx) = watch::channel(()); + + cx.subscribe(&source_buffer, move |this, _, event, _| match event { + language::BufferEvent::Edited + | language::BufferEvent::LanguageChanged + | language::BufferEvent::Reparsed => { + this.buffer_changes_tx.send(()).ok(); + } + _ => {} + }) + .detach(); + + let editor = source_editor.read(cx); + let title = editor.buffer().read(cx).title(cx).to_string(); + let selection_location_text = selection_location_text(editor, cx); + let selection_location_title = selection_location_text + .as_ref() + .map(|text| format!("{} @ {}", title, text)) + .unwrap_or(title); + + let path = editor + .buffer() + .read(cx) + .as_singleton() + .and_then(|b| { + b.read(cx) + .file() + .map(|f| f.full_path(cx).compact().to_string_lossy().to_string()) + }) + .unwrap_or("untitled".into()); + + let selection_location_path = selection_location_text + .map(|text| format!("{} @ {}", path, text)) + .unwrap_or(path); + + Self { + diff_editor, + title: format!("Clipboard ↔ {selection_location_title}").into(), + path: Some(format!("Clipboard ↔ {selection_location_path}").into()), + buffer_changes_tx, + _recalculate_diff_task: cx.spawn(async move |_, cx| { + while let Ok(_) = buffer_changes_rx.recv().await { + loop { + let mut timer = cx + .background_executor() + .timer(RECALCULATE_DIFF_DEBOUNCE) + .fuse(); + let mut recv = pin!(buffer_changes_rx.recv().fuse()); + select_biased! { + _ = timer => break, + _ = recv => continue, + } + } + + log::trace!("start recalculating"); + update_diff_buffer(&diff_buffer, &source_buffer, &clipboard_buffer, cx).await?; + log::trace!("finish recalculating"); + } + Ok(()) + }), + } + } +} + +fn build_clipboard_buffer( + clipboard_text: String, + source_buffer: &Entity, + selected_range: Range, + cx: &mut App, +) -> Entity { + let source_buffer_snapshot = source_buffer.read(cx).snapshot(); + cx.new(|cx| { + let mut buffer = language::Buffer::local(source_buffer_snapshot.text(), cx); + let language = source_buffer.read(cx).language().cloned(); + buffer.set_language(language, cx); + + let range_start = source_buffer_snapshot.point_to_offset(selected_range.start); + let range_end = source_buffer_snapshot.point_to_offset(selected_range.end); + buffer.edit([(range_start..range_end, clipboard_text)], None, cx); + + buffer + }) +} + +async fn update_diff_buffer( + diff: &Entity, + source_buffer: &Entity, + clipboard_buffer: &Entity, + cx: &mut AsyncApp, +) -> Result<()> { + let source_buffer_snapshot = source_buffer.read_with(cx, |buffer, _| buffer.snapshot())?; + + let base_buffer_snapshot = clipboard_buffer.read_with(cx, |buffer, _| buffer.snapshot())?; + let base_text = base_buffer_snapshot.text().to_string(); + + let diff_snapshot = cx + .update(|cx| { + BufferDiffSnapshot::new_with_base_buffer( + source_buffer_snapshot.text.clone(), + Some(Arc::new(base_text)), + base_buffer_snapshot, + cx, + ) + })? + .await; + + diff.update(cx, |diff, cx| { + diff.set_snapshot(diff_snapshot, &source_buffer_snapshot.text, cx); + })?; + Ok(()) +} + +impl EventEmitter for TextDiffView {} + +impl Focusable for TextDiffView { + fn focus_handle(&self, cx: &App) -> FocusHandle { + self.diff_editor.focus_handle(cx) + } +} + +impl Item for TextDiffView { + type Event = EditorEvent; + + fn tab_icon(&self, _window: &Window, _cx: &App) -> Option { + Some(Icon::new(IconName::Diff).color(Color::Muted)) + } + + fn tab_content(&self, params: TabContentParams, _window: &Window, cx: &App) -> AnyElement { + Label::new(self.tab_content_text(params.detail.unwrap_or_default(), cx)) + .color(if params.selected { + Color::Default + } else { + Color::Muted + }) + .into_any_element() + } + + fn tab_content_text(&self, _detail: usize, _: &App) -> SharedString { + self.title.clone() + } + + fn tab_tooltip_text(&self, _: &App) -> Option { + self.path.clone() + } + + fn to_item_events(event: &EditorEvent, f: impl FnMut(ItemEvent)) { + Editor::to_item_events(event, f) + } + + fn telemetry_event_text(&self) -> Option<&'static str> { + Some("Diff View Opened") + } + + fn deactivated(&mut self, window: &mut Window, cx: &mut Context) { + self.diff_editor + .update(cx, |editor, cx| editor.deactivated(window, cx)); + } + + fn is_singleton(&self, _: &App) -> bool { + false + } + + fn act_as_type<'a>( + &'a self, + type_id: TypeId, + self_handle: &'a Entity, + _: &'a App, + ) -> Option { + if type_id == TypeId::of::() { + Some(self_handle.to_any()) + } else if type_id == TypeId::of::() { + Some(self.diff_editor.to_any()) + } else { + None + } + } + + fn as_searchable(&self, _: &Entity) -> Option> { + Some(Box::new(self.diff_editor.clone())) + } + + fn for_each_project_item( + &self, + cx: &App, + f: &mut dyn FnMut(gpui::EntityId, &dyn project::ProjectItem), + ) { + self.diff_editor.for_each_project_item(cx, f) + } + + fn set_nav_history( + &mut self, + nav_history: ItemNavHistory, + _: &mut Window, + cx: &mut Context, + ) { + self.diff_editor.update(cx, |editor, _| { + editor.set_nav_history(Some(nav_history)); + }); + } + + fn navigate( + &mut self, + data: Box, + window: &mut Window, + cx: &mut Context, + ) -> bool { + self.diff_editor + .update(cx, |editor, cx| editor.navigate(data, window, cx)) + } + + fn breadcrumb_location(&self, _: &App) -> ToolbarItemLocation { + ToolbarItemLocation::PrimaryLeft + } + + fn breadcrumbs(&self, theme: &theme::Theme, cx: &App) -> Option> { + self.diff_editor.breadcrumbs(theme, cx) + } + + fn added_to_workspace( + &mut self, + workspace: &mut Workspace, + window: &mut Window, + cx: &mut Context, + ) { + self.diff_editor.update(cx, |editor, cx| { + editor.added_to_workspace(workspace, window, cx) + }); + } + + fn can_save(&self, cx: &App) -> bool { + // The editor handles the new buffer, so delegate to it + self.diff_editor.read(cx).can_save(cx) + } + + fn save( + &mut self, + options: SaveOptions, + project: Entity, + window: &mut Window, + cx: &mut Context, + ) -> Task> { + // Delegate saving to the editor, which manages the new buffer + self.diff_editor + .update(cx, |editor, cx| editor.save(options, project, window, cx)) + } +} + +pub fn selection_location_text(editor: &Editor, cx: &App) -> Option { + let buffer = editor.buffer().read(cx); + let buffer_snapshot = buffer.snapshot(cx); + let first_selection = editor.selections.disjoint.first()?; + + let (start_row, start_column, end_row, end_column) = + if first_selection.start == first_selection.end { + let max_point = buffer_snapshot.max_point(); + (0, 0, max_point.row, max_point.column) + } else { + let selection_start = first_selection.start.to_point(&buffer_snapshot); + let selection_end = first_selection.end.to_point(&buffer_snapshot); + + ( + selection_start.row, + selection_start.column, + selection_end.row, + selection_end.column, + ) + }; + + let range_text = if start_row == end_row { + format!("L{}:{}-{}", start_row + 1, start_column + 1, end_column + 1) + } else { + format!( + "L{}:{}-L{}:{}", + start_row + 1, + start_column + 1, + end_row + 1, + end_column + 1 + ) + }; + + Some(range_text) +} + +impl Render for TextDiffView { + fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement { + self.diff_editor.clone() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + use editor::{actions, test::editor_test_context::assert_state_with_diff}; + use gpui::{TestAppContext, VisualContext}; + use project::{FakeFs, Project}; + use serde_json::json; + use settings::{Settings, SettingsStore}; + use unindent::unindent; + use util::path; + + fn init_test(cx: &mut TestAppContext) { + cx.update(|cx| { + let settings_store = SettingsStore::test(cx); + cx.set_global(settings_store); + language::init(cx); + Project::init_settings(cx); + workspace::init_settings(cx); + editor::init_settings(cx); + theme::ThemeSettings::register(cx) + }); + } + + #[gpui::test] + async fn test_diffing_clipboard_against_specific_selection(cx: &mut TestAppContext) { + base_test(true, cx).await; + } + + #[gpui::test] + async fn test_diffing_clipboard_against_empty_selection_uses_full_buffer( + cx: &mut TestAppContext, + ) { + base_test(false, cx).await; + } + + async fn base_test(select_all_text: bool, cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree( + path!("/test"), + json!({ + "a": { + "b": { + "text.txt": "new line 1\nline 2\nnew line 3\nline 4" + } + } + }), + ) + .await; + + let project = Project::test(fs, [path!("/test").as_ref()], cx).await; + + let (workspace, mut cx) = + cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx)); + + let buffer = project + .update(cx, |project, cx| { + project.open_local_buffer(path!("/test/a/b/text.txt"), cx) + }) + .await + .unwrap(); + + let editor = cx.new_window_entity(|window, cx| { + let mut editor = Editor::for_buffer(buffer, None, window, cx); + editor.set_text("new line 1\nline 2\nnew line 3\nline 4\n", window, cx); + + if select_all_text { + editor.select_all(&actions::SelectAll, window, cx); + } + + editor + }); + + let diff_view = workspace + .update_in(cx, |workspace, window, cx| { + TextDiffView::open( + &DiffClipboardWithSelectionData { + clipboard_text: "old line 1\nline 2\nold line 3\nline 4\n".to_string(), + editor, + }, + workspace, + window, + cx, + ) + }) + .unwrap() + .await + .unwrap(); + + cx.executor().run_until_parked(); + + assert_state_with_diff( + &diff_view.read_with(cx, |diff_view, _| diff_view.diff_editor.clone()), + &mut cx, + &unindent( + " + - old line 1 + + ˇnew line 1 + line 2 + - old line 3 + + new line 3 + line 4 + ", + ), + ); + + diff_view.read_with(cx, |diff_view, cx| { + assert_eq!( + diff_view.tab_content_text(0, cx), + "Clipboard ↔ text.txt @ L1:1-L5:1" + ); + assert_eq!( + diff_view.tab_tooltip_text(cx).unwrap(), + format!("Clipboard ↔ {}", path!("test/a/b/text.txt @ L1:1-L5:1")) + ); + }); + } +} diff --git a/crates/gpui/src/app/entity_map.rs b/crates/gpui/src/app/entity_map.rs index d4e5b2570e..fccb417caa 100644 --- a/crates/gpui/src/app/entity_map.rs +++ b/crates/gpui/src/app/entity_map.rs @@ -370,7 +370,7 @@ impl std::fmt::Debug for AnyEntity { } } -/// A strong, well typed reference to a struct which is managed +/// A strong, well-typed reference to a struct which is managed /// by GPUI #[derive(Deref, DerefMut)] pub struct Entity { diff --git a/crates/zed/src/zed/open_listener.rs b/crates/zed/src/zed/open_listener.rs index b6feb0073e..2fd9b0a68c 100644 --- a/crates/zed/src/zed/open_listener.rs +++ b/crates/zed/src/zed/open_listener.rs @@ -12,7 +12,7 @@ use futures::channel::mpsc::{UnboundedReceiver, UnboundedSender}; use futures::channel::{mpsc, oneshot}; use futures::future::join_all; use futures::{FutureExt, SinkExt, StreamExt}; -use git_ui::diff_view::DiffView; +use git_ui::file_diff_view::FileDiffView; use gpui::{App, AsyncApp, Global, WindowHandle}; use language::Point; use recent_projects::{SshSettings, open_ssh_project}; @@ -262,7 +262,7 @@ pub async fn open_paths_with_positions( let old_path = Path::new(&diff_pair[0]).canonicalize()?; let new_path = Path::new(&diff_pair[1]).canonicalize()?; if let Ok(diff_view) = workspace.update(cx, |workspace, window, cx| { - DiffView::open(old_path, new_path, workspace, window, cx) + FileDiffView::open(old_path, new_path, workspace, window, cx) }) { if let Some(diff_view) = diff_view.await.log_err() { items.push(Some(Ok(Box::new(diff_view)))) From 6122f460953c2f162a1ea91213b72db914b39456 Mon Sep 17 00:00:00 2001 From: maan2003 <49202620+maan2003@users.noreply.github.com> Date: Wed, 23 Jul 2025 11:48:45 +0530 Subject: [PATCH 0146/1052] project: Fix search filter patterns on remote projects (#34748) we were join(",") and split(",") to serialize the patterns. This doesn't work when pattern includes a "," example: *.{ts,tsx} (very common pattern used by agent) help needed: how will this work on version mismatch? Release Notes: - Fixed search filter patterns on remote projects. --- crates/project/src/search.rs | 49 +++++++++++++++++++++++---------- crates/proto/proto/buffer.proto | 6 ++-- 2 files changed, 39 insertions(+), 16 deletions(-) diff --git a/crates/project/src/search.rs b/crates/project/src/search.rs index 44732b23cd..4f024837c8 100644 --- a/crates/project/src/search.rs +++ b/crates/project/src/search.rs @@ -193,6 +193,30 @@ impl SearchQuery { } pub fn from_proto(message: proto::SearchQuery) -> Result { + let files_to_include = if message.files_to_include.is_empty() { + message + .files_to_include_legacy + .split(',') + .map(str::trim) + .filter(|&glob_str| !glob_str.is_empty()) + .map(|s| s.to_string()) + .collect() + } else { + message.files_to_include + }; + + let files_to_exclude = if message.files_to_exclude.is_empty() { + message + .files_to_exclude_legacy + .split(',') + .map(str::trim) + .filter(|&glob_str| !glob_str.is_empty()) + .map(|s| s.to_string()) + .collect() + } else { + message.files_to_exclude + }; + if message.regex { Self::regex( message.query, @@ -200,8 +224,8 @@ impl SearchQuery { message.case_sensitive, message.include_ignored, false, - deserialize_path_matches(&message.files_to_include)?, - deserialize_path_matches(&message.files_to_exclude)?, + PathMatcher::new(files_to_include)?, + PathMatcher::new(files_to_exclude)?, message.match_full_paths, None, // search opened only don't need search remote ) @@ -211,8 +235,8 @@ impl SearchQuery { message.whole_word, message.case_sensitive, message.include_ignored, - deserialize_path_matches(&message.files_to_include)?, - deserialize_path_matches(&message.files_to_exclude)?, + PathMatcher::new(files_to_include)?, + PathMatcher::new(files_to_exclude)?, false, None, // search opened only don't need search remote ) @@ -236,15 +260,20 @@ impl SearchQuery { } pub fn to_proto(&self) -> proto::SearchQuery { + let files_to_include = self.files_to_include().sources().to_vec(); + let files_to_exclude = self.files_to_exclude().sources().to_vec(); proto::SearchQuery { query: self.as_str().to_string(), regex: self.is_regex(), whole_word: self.whole_word(), case_sensitive: self.case_sensitive(), include_ignored: self.include_ignored(), - files_to_include: self.files_to_include().sources().join(","), - files_to_exclude: self.files_to_exclude().sources().join(","), + files_to_include: files_to_include.clone(), + files_to_exclude: files_to_exclude.clone(), match_full_paths: self.match_full_paths(), + // Populate legacy fields for backwards compatibility + files_to_include_legacy: files_to_include.join(","), + files_to_exclude_legacy: files_to_exclude.join(","), } } @@ -520,14 +549,6 @@ impl SearchQuery { } } -pub fn deserialize_path_matches(glob_set: &str) -> anyhow::Result { - let globs = glob_set - .split(',') - .map(str::trim) - .filter(|&glob_str| !glob_str.is_empty()); - Ok(PathMatcher::new(globs)?) -} - #[cfg(test)] mod tests { use super::*; diff --git a/crates/proto/proto/buffer.proto b/crates/proto/proto/buffer.proto index 09a05a50cd..f4dacf2fdc 100644 --- a/crates/proto/proto/buffer.proto +++ b/crates/proto/proto/buffer.proto @@ -288,10 +288,12 @@ message SearchQuery { bool regex = 3; bool whole_word = 4; bool case_sensitive = 5; - string files_to_include = 6; - string files_to_exclude = 7; + repeated string files_to_include = 10; + repeated string files_to_exclude = 11; bool match_full_paths = 9; bool include_ignored = 8; + string files_to_include_legacy = 6; + string files_to_exclude_legacy = 7; } message FindSearchCandidates { From 7db110f48d23344e1fc2fa9f30f6b1fe3878bc73 Mon Sep 17 00:00:00 2001 From: tidely <43219534+tidely@users.noreply.github.com> Date: Wed, 23 Jul 2025 10:57:57 +0300 Subject: [PATCH 0147/1052] sum_tree: Utilize `size_hint` in `TreeSet::extend` (#34936) Collect the iterator instead of manually looping over it to utilize possible size hints. Zed usually passes in owned `Vec`'s, meaning we get to reuse memory as well. Release Notes: - N/A --- crates/sum_tree/src/tree_map.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/crates/sum_tree/src/tree_map.rs b/crates/sum_tree/src/tree_map.rs index 0397f16182..54e8ae8343 100644 --- a/crates/sum_tree/src/tree_map.rs +++ b/crates/sum_tree/src/tree_map.rs @@ -71,10 +71,10 @@ impl TreeMap { } pub fn extend(&mut self, iter: impl IntoIterator) { - let mut edits = Vec::new(); - for (key, value) in iter { - edits.push(Edit::Insert(MapEntry { key, value })); - } + let edits: Vec<_> = iter + .into_iter() + .map(|(key, value)| Edit::Insert(MapEntry { key, value })) + .collect(); self.0.edit(edits, &()); } From 6cd3726a5adb67c067158514db4719fde2e8b58b Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Wed, 23 Jul 2025 10:28:06 +0200 Subject: [PATCH 0148/1052] Revert "chore: Bump taffy to 0.8.3" (#34938) Reverts zed-industries/zed#34876 From our Slack: image https://github.com/user-attachments/assets/828964be-9b6e-4496-9361-9e3a2e9aa208 Release Notes: - N/A --- Cargo.lock | 9 +++++---- crates/gpui/Cargo.toml | 2 +- crates/gpui/src/taffy.rs | 26 +++++++++++++------------- 3 files changed, 19 insertions(+), 18 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 08d29cdc80..c64995b01b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7401,9 +7401,9 @@ dependencies = [ [[package]] name = "grid" -version = "0.17.0" +version = "0.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "71b01d27060ad58be4663b9e4ac9e2d4806918e8876af8912afbddd1a91d5eaa" +checksum = "be136d9dacc2a13cc70bb6c8f902b414fb2641f8db1314637c6b7933411a8f82" [[package]] name = "group" @@ -15958,12 +15958,13 @@ dependencies = [ [[package]] name = "taffy" -version = "0.8.3" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7aaef0ac998e6527d6d0d5582f7e43953bb17221ac75bb8eb2fcc2db3396db1c" +checksum = "e8b61630cba2afd2c851821add2e1bb1b7851a2436e839ab73b56558b009035e" dependencies = [ "arrayvec", "grid", + "num-traits", "serde", "slotmap", ] diff --git a/crates/gpui/Cargo.toml b/crates/gpui/Cargo.toml index 68c0ea89c7..878794647a 100644 --- a/crates/gpui/Cargo.toml +++ b/crates/gpui/Cargo.toml @@ -121,7 +121,7 @@ smallvec.workspace = true smol.workspace = true strum.workspace = true sum_tree.workspace = true -taffy = "=0.8.3" +taffy = "=0.5.1" thiserror.workspace = true util.workspace = true uuid.workspace = true diff --git a/crates/gpui/src/taffy.rs b/crates/gpui/src/taffy.rs index f7fa54256d..6228a60490 100644 --- a/crates/gpui/src/taffy.rs +++ b/crates/gpui/src/taffy.rs @@ -283,7 +283,7 @@ impl ToTaffy for Length { fn to_taffy(&self, rem_size: Pixels) -> taffy::prelude::LengthPercentageAuto { match self { Length::Definite(length) => length.to_taffy(rem_size), - Length::Auto => taffy::prelude::LengthPercentageAuto::auto(), + Length::Auto => taffy::prelude::LengthPercentageAuto::Auto, } } } @@ -292,7 +292,7 @@ impl ToTaffy for Length { fn to_taffy(&self, rem_size: Pixels) -> taffy::prelude::Dimension { match self { Length::Definite(length) => length.to_taffy(rem_size), - Length::Auto => taffy::prelude::Dimension::auto(), + Length::Auto => taffy::prelude::Dimension::Auto, } } } @@ -302,14 +302,14 @@ impl ToTaffy for DefiniteLength { match self { DefiniteLength::Absolute(length) => match length { AbsoluteLength::Pixels(pixels) => { - taffy::style::LengthPercentage::length(pixels.into()) + taffy::style::LengthPercentage::Length(pixels.into()) } AbsoluteLength::Rems(rems) => { - taffy::style::LengthPercentage::length((*rems * rem_size).into()) + taffy::style::LengthPercentage::Length((*rems * rem_size).into()) } }, DefiniteLength::Fraction(fraction) => { - taffy::style::LengthPercentage::percent(*fraction) + taffy::style::LengthPercentage::Percent(*fraction) } } } @@ -320,14 +320,14 @@ impl ToTaffy for DefiniteLength { match self { DefiniteLength::Absolute(length) => match length { AbsoluteLength::Pixels(pixels) => { - taffy::style::LengthPercentageAuto::length(pixels.into()) + taffy::style::LengthPercentageAuto::Length(pixels.into()) } AbsoluteLength::Rems(rems) => { - taffy::style::LengthPercentageAuto::length((*rems * rem_size).into()) + taffy::style::LengthPercentageAuto::Length((*rems * rem_size).into()) } }, DefiniteLength::Fraction(fraction) => { - taffy::style::LengthPercentageAuto::percent(*fraction) + taffy::style::LengthPercentageAuto::Percent(*fraction) } } } @@ -337,12 +337,12 @@ impl ToTaffy for DefiniteLength { fn to_taffy(&self, rem_size: Pixels) -> taffy::style::Dimension { match self { DefiniteLength::Absolute(length) => match length { - AbsoluteLength::Pixels(pixels) => taffy::style::Dimension::length(pixels.into()), + AbsoluteLength::Pixels(pixels) => taffy::style::Dimension::Length(pixels.into()), AbsoluteLength::Rems(rems) => { - taffy::style::Dimension::length((*rems * rem_size).into()) + taffy::style::Dimension::Length((*rems * rem_size).into()) } }, - DefiniteLength::Fraction(fraction) => taffy::style::Dimension::percent(*fraction), + DefiniteLength::Fraction(fraction) => taffy::style::Dimension::Percent(*fraction), } } } @@ -350,9 +350,9 @@ impl ToTaffy for DefiniteLength { impl ToTaffy for AbsoluteLength { fn to_taffy(&self, rem_size: Pixels) -> taffy::style::LengthPercentage { match self { - AbsoluteLength::Pixels(pixels) => taffy::style::LengthPercentage::length(pixels.into()), + AbsoluteLength::Pixels(pixels) => taffy::style::LengthPercentage::Length(pixels.into()), AbsoluteLength::Rems(rems) => { - taffy::style::LengthPercentage::length((*rems * rem_size).into()) + taffy::style::LengthPercentage::Length((*rems * rem_size).into()) } } } From c2c2264a60abf65e8a5e14859d6b588e307142c2 Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Wed, 23 Jul 2025 12:17:23 +0200 Subject: [PATCH 0149/1052] gpui: Add tree example (#34942) This commit adds an example with deep children hierarchy. The depth of a tree can be tweaked with GPUI_TREE_DEPTH env variable. With depth=100 image With this example, I can trigger a stack overflow at depth=633 (and higher). Release Notes: - N/A --- crates/gpui/Cargo.toml | 4 ++++ crates/gpui/examples/tree.rs | 46 ++++++++++++++++++++++++++++++++++++ 2 files changed, 50 insertions(+) create mode 100644 crates/gpui/examples/tree.rs diff --git a/crates/gpui/Cargo.toml b/crates/gpui/Cargo.toml index 878794647a..b446ea8bd8 100644 --- a/crates/gpui/Cargo.toml +++ b/crates/gpui/Cargo.toml @@ -295,6 +295,10 @@ path = "examples/text.rs" name = "text_wrapper" path = "examples/text_wrapper.rs" +[[example]] +name = "tree" +path = "examples/tree.rs" + [[example]] name = "uniform_list" path = "examples/uniform_list.rs" diff --git a/crates/gpui/examples/tree.rs b/crates/gpui/examples/tree.rs new file mode 100644 index 0000000000..1bd4592003 --- /dev/null +++ b/crates/gpui/examples/tree.rs @@ -0,0 +1,46 @@ +//! Renders a div with deep children hierarchy. This example is useful to exemplify that Zed can +//! handle deep hierarchies (even though it cannot just yet!). +use std::sync::LazyLock; + +use gpui::{ + App, Application, Bounds, Context, Window, WindowBounds, WindowOptions, div, prelude::*, px, + size, +}; + +struct Tree {} + +static DEPTH: LazyLock = LazyLock::new(|| { + std::env::var("GPUI_TREE_DEPTH") + .ok() + .and_then(|depth| depth.parse().ok()) + .unwrap_or_else(|| 50) +}); + +impl Render for Tree { + fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement { + let mut depth = *DEPTH; + static COLORS: [gpui::Hsla; 4] = [gpui::red(), gpui::blue(), gpui::green(), gpui::yellow()]; + let mut colors = COLORS.iter().cycle().copied(); + let mut next_div = || div().p_0p5().bg(colors.next().unwrap()); + let mut innermost_node = next_div(); + while depth > 0 { + innermost_node = next_div().child(innermost_node); + depth -= 1; + } + innermost_node + } +} + +fn main() { + Application::new().run(|cx: &mut App| { + let bounds = Bounds::centered(None, size(px(300.0), px(300.0)), cx); + cx.open_window( + WindowOptions { + window_bounds: Some(WindowBounds::Windowed(bounds)), + ..Default::default() + }, + |_, cx| cx.new(|_| Tree {}), + ) + .unwrap(); + }); +} From 2bc6e18ac913f363e7f75fd12efccc02dc3c05d9 Mon Sep 17 00:00:00 2001 From: Finn Evers Date: Wed, 23 Jul 2025 12:20:09 +0200 Subject: [PATCH 0150/1052] Ensure `disable_ai` is properly respected (#34941) Quick follow up to #34896 which ensures that the Agent Panel cannot be caught by actions like `workspace: toggle left dock` when `disable_ai` is set to true. Also removes a method that was introduced but unused in the workspace because `first_enabled_panel_idx` already covers all cases this method could be useful for. Release Notes: - N/A --- crates/agent_ui/src/agent_panel.rs | 9 +++------ crates/workspace/src/dock.rs | 6 ------ 2 files changed, 3 insertions(+), 12 deletions(-) diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 7e9360a0cb..95ce289608 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -1,5 +1,5 @@ use std::cell::RefCell; -use std::ops::Range; +use std::ops::{Not, Range}; use std::path::Path; use std::rc::Rc; use std::sync::Arc; @@ -1666,10 +1666,7 @@ impl Panel for AgentPanel { } fn icon(&self, _window: &Window, cx: &App) -> Option { - (self.enabled(cx) - && AgentSettings::get_global(cx).button - && !DisableAiSettings::get_global(cx).disable_ai) - .then_some(IconName::ZedAssistant) + (self.enabled(cx) && AgentSettings::get_global(cx).button).then_some(IconName::ZedAssistant) } fn icon_tooltip(&self, _window: &Window, _cx: &App) -> Option<&'static str> { @@ -1685,7 +1682,7 @@ impl Panel for AgentPanel { } fn enabled(&self, cx: &App) -> bool { - AgentSettings::get_global(cx).enabled + DisableAiSettings::get_global(cx).disable_ai.not() && AgentSettings::get_global(cx).enabled } fn is_zoomed(&self, _window: &Window, _cx: &App) -> bool { diff --git a/crates/workspace/src/dock.rs b/crates/workspace/src/dock.rs index 3f047e2f11..7165de23ec 100644 --- a/crates/workspace/src/dock.rs +++ b/crates/workspace/src/dock.rs @@ -374,12 +374,6 @@ impl Dock { }) } - pub fn first_enabled_panel_idx_excluding(&self, exclude_name: &str, cx: &App) -> Option { - self.panel_entries.iter().position(|entry| { - entry.panel.persistent_name() != exclude_name && entry.panel.enabled(cx) - }) - } - fn active_panel_entry(&self) -> Option<&PanelEntry> { self.active_panel_index .and_then(|index| self.panel_entries.get(index)) From 326ab5fa3fda2e0c128f533772060d48397dc5cc Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Wed, 23 Jul 2025 10:04:53 -0400 Subject: [PATCH 0151/1052] Improve collab channel organization keybinds (#34821) Change channel reorganization (move up/down) from `cmd-up/down` (mac) / `ctrl-up/down` (linux) to `alt-up/down` (both) to match moving lines in the editor. Also fix an issue where if you selected channels using down/up in the filter field, the movement shortcuts would not work (`editing` vs `not_editing`). Release Notes: - N/A --- assets/keymaps/default-linux.json | 11 ++++++++--- assets/keymaps/default-macos.json | 12 +++++++++--- 2 files changed, 17 insertions(+), 6 deletions(-) diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index 4918e654fc..b097be90fd 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -975,9 +975,14 @@ "context": "CollabPanel && not_editing", "bindings": { "ctrl-backspace": "collab_panel::Remove", - "space": "menu::Confirm", - "ctrl-up": "collab_panel::MoveChannelUp", - "ctrl-down": "collab_panel::MoveChannelDown" + "space": "menu::Confirm" + } + }, + { + "context": "CollabPanel", + "bindings": { + "alt-up": "collab_panel::MoveChannelUp", + "alt-down": "collab_panel::MoveChannelDown" } }, { diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index 60f29b1da1..e33786f1b2 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -1037,9 +1037,15 @@ "use_key_equivalents": true, "bindings": { "ctrl-backspace": "collab_panel::Remove", - "space": "menu::Confirm", - "cmd-up": "collab_panel::MoveChannelUp", - "cmd-down": "collab_panel::MoveChannelDown" + "space": "menu::Confirm" + } + }, + { + "context": "CollabPanel", + "use_key_equivalents": true, + "bindings": { + "alt-up": "collab_panel::MoveChannelUp", + "alt-down": "collab_panel::MoveChannelDown" } }, { From 14171e0721235a5bbcc4ed568d2db5bdd4ff821a Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Wed, 23 Jul 2025 10:30:08 -0400 Subject: [PATCH 0152/1052] collab: Add `POST /users/:id/update_plan` endpoint (#34953) This PR adds a new `POST /users/:id/update_plan` endpoint to Collab to allow Cloud to push down plan updates to users. Release Notes: - N/A --- crates/collab/src/api.rs | 79 ++++++++++++++++++++++++++++++++ crates/collab/src/api/billing.rs | 2 +- crates/collab/src/rpc.rs | 30 ++++++++---- 3 files changed, 101 insertions(+), 10 deletions(-) diff --git a/crates/collab/src/api.rs b/crates/collab/src/api.rs index 8f1433a26f..3b0f5396a7 100644 --- a/crates/collab/src/api.rs +++ b/crates/collab/src/api.rs @@ -11,7 +11,9 @@ use crate::{ db::{User, UserId}, rpc, }; +use ::rpc::proto; use anyhow::Context as _; +use axum::extract; use axum::{ Extension, Json, Router, body::Body, @@ -23,6 +25,7 @@ use axum::{ routing::{get, post}, }; use axum_extra::response::ErasedJson; +use chrono::{DateTime, Utc}; use serde::{Deserialize, Serialize}; use std::sync::{Arc, OnceLock}; use tower::ServiceBuilder; @@ -101,6 +104,7 @@ pub fn routes(rpc_server: Arc) -> Router<(), Body> { .route("/users/look_up", get(look_up_user)) .route("/users/:id/access_tokens", post(create_access_token)) .route("/users/:id/refresh_llm_tokens", post(refresh_llm_tokens)) + .route("/users/:id/update_plan", post(update_plan)) .route("/rpc_server_snapshot", get(get_rpc_server_snapshot)) .merge(billing::router()) .merge(contributors::router()) @@ -347,3 +351,78 @@ async fn refresh_llm_tokens( Ok(Json(RefreshLlmTokensResponse {})) } + +#[derive(Debug, Serialize, Deserialize)] +struct UpdatePlanBody { + pub plan: zed_llm_client::Plan, + pub subscription_period: SubscriptionPeriod, + pub usage: zed_llm_client::CurrentUsage, + pub trial_started_at: Option>, + pub is_usage_based_billing_enabled: bool, + pub is_account_too_young: bool, + pub has_overdue_invoices: bool, +} + +#[derive(Debug, PartialEq, Clone, Copy, Serialize, Deserialize)] +struct SubscriptionPeriod { + pub started_at: DateTime, + pub ended_at: DateTime, +} + +#[derive(Serialize)] +struct UpdatePlanResponse {} + +async fn update_plan( + Path(user_id): Path, + Extension(rpc_server): Extension>, + extract::Json(body): extract::Json, +) -> Result> { + let plan = match body.plan { + zed_llm_client::Plan::ZedFree => proto::Plan::Free, + zed_llm_client::Plan::ZedPro => proto::Plan::ZedPro, + zed_llm_client::Plan::ZedProTrial => proto::Plan::ZedProTrial, + }; + + let update_user_plan = proto::UpdateUserPlan { + plan: plan.into(), + trial_started_at: body + .trial_started_at + .map(|trial_started_at| trial_started_at.timestamp() as u64), + is_usage_based_billing_enabled: Some(body.is_usage_based_billing_enabled), + usage: Some(proto::SubscriptionUsage { + model_requests_usage_amount: body.usage.model_requests.used, + model_requests_usage_limit: Some(usage_limit_to_proto(body.usage.model_requests.limit)), + edit_predictions_usage_amount: body.usage.edit_predictions.used, + edit_predictions_usage_limit: Some(usage_limit_to_proto( + body.usage.edit_predictions.limit, + )), + }), + subscription_period: Some(proto::SubscriptionPeriod { + started_at: body.subscription_period.started_at.timestamp() as u64, + ended_at: body.subscription_period.ended_at.timestamp() as u64, + }), + account_too_young: Some(body.is_account_too_young), + has_overdue_invoices: Some(body.has_overdue_invoices), + }; + + rpc_server + .update_plan_for_user(user_id, update_user_plan) + .await?; + + Ok(Json(UpdatePlanResponse {})) +} + +fn usage_limit_to_proto(limit: zed_llm_client::UsageLimit) -> proto::UsageLimit { + proto::UsageLimit { + variant: Some(match limit { + zed_llm_client::UsageLimit::Limited(limit) => { + proto::usage_limit::Variant::Limited(proto::usage_limit::Limited { + limit: limit as u32, + }) + } + zed_llm_client::UsageLimit::Unlimited => { + proto::usage_limit::Variant::Unlimited(proto::usage_limit::Unlimited {}) + } + }), + } +} diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs index d6e42ad2fb..bd7b99b3eb 100644 --- a/crates/collab/src/api/billing.rs +++ b/crates/collab/src/api/billing.rs @@ -785,7 +785,7 @@ async fn handle_customer_subscription_event( // When the user's subscription changes, push down any changes to their plan. rpc_server - .update_plan_for_user(billing_customer.user_id) + .update_plan_for_user_legacy(billing_customer.user_id) .await .trace_err(); diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs index 924784109b..0735b08e89 100644 --- a/crates/collab/src/rpc.rs +++ b/crates/collab/src/rpc.rs @@ -1002,7 +1002,26 @@ impl Server { Ok(()) } - pub async fn update_plan_for_user(self: &Arc, user_id: UserId) -> Result<()> { + pub async fn update_plan_for_user( + self: &Arc, + user_id: UserId, + update_user_plan: proto::UpdateUserPlan, + ) -> Result<()> { + let pool = self.connection_pool.lock(); + for connection_id in pool.user_connection_ids(user_id) { + self.peer + .send(connection_id, update_user_plan.clone()) + .trace_err(); + } + + Ok(()) + } + + /// This is the legacy way of updating the user's plan, where we fetch the data to construct the `UpdateUserPlan` + /// message on the Collab server. + /// + /// The new way is to receive the data from Cloud via the `POST /users/:id/update_plan` endpoint. + pub async fn update_plan_for_user_legacy(self: &Arc, user_id: UserId) -> Result<()> { let user = self .app_state .db @@ -1018,14 +1037,7 @@ impl Server { ) .await?; - let pool = self.connection_pool.lock(); - for connection_id in pool.user_connection_ids(user_id) { - self.peer - .send(connection_id, update_user_plan.clone()) - .trace_err(); - } - - Ok(()) + self.update_plan_for_user(user_id, update_user_plan).await } pub async fn refresh_llm_tokens_for_user(self: &Arc, user_id: UserId) { From 1f4c9b9427437952839489a6399e5300dd579dfe Mon Sep 17 00:00:00 2001 From: claytonrcarter Date: Wed, 23 Jul 2025 11:08:52 -0400 Subject: [PATCH 0153/1052] language: Update block_comment and documentation comment (#34861) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit As suggested in https://github.com/zed-industries/zed/pull/34418, this proposes various changes to language configs to make block comments and doc-block-style comments more similar. In doing so, it introduces some breaking changes into the extension schema. This change is needed to support the changes I'm working on in #34418, to be able to support `rewrap` in block comments like `/* really long comment ... */`. As is, we can do this in C-style doc-block comments (eg `/** ... */`) because of the config in `documentation`, but we can't do this in regular block comments because we lack the info about what the line prefix and indentation should be. And while I was here, I did various other clean-ups, many of which feel nice but are optional. I would love special attention on the changes to the schema, version and related changes; I'm totally unfamiliar with that part of Zed. **Summary of changes** - break: changes type of `block_comment` to same type as `documentation_comment` (**this is the important change**) - break: rename `documentation` to `documentation_comment` (optional, but improves consistency w/ `line_comments` and `block_comment`) - break/refactor?: removes some whitespace in the declaration of `block_comment` delimiters (optional, may break things, need input; some langs had no spaces, others did) - refactor: change `tab_size` from `NonZeroU32` to just a `u32` (some block comments don't seem to need/want indent past the initial delimiter, so we need this be 0 sometimes) - refactor: moves the `documentation_comment` declarations to appear next to `block_comment`, rearranges the order of the fields in the TOML for `documentation_comment`, rename backing `struct` (all optional) **Future scope** I believe that this will also allow us to extend regular block comments on newline – as we do doc-block comments – but I haven't looked into this yet. (eg, in JS try pressing enter in both of these: `/* */` and `/** */`; the latter should extend w/ a `*` prefixed line, while the former does not.) Release Notes: - BREAKING CHANGE: update extension schema version from 1 to 2, change format of `block_comment` and rename `documentation_comment` /cc @smitbarmase --- Cargo.lock | 1 + crates/editor/src/editor.rs | 28 ++-- crates/editor/src/editor_tests.rs | 18 +- .../src/test/editor_lsp_test_context.rs | 10 +- crates/language/Cargo.toml | 1 + crates/language/src/buffer_tests.rs | 76 +++++++-- crates/language/src/language.rs | 157 +++++++++++++++--- crates/languages/src/c/config.toml | 2 +- crates/languages/src/cpp/config.toml | 2 +- crates/languages/src/css/config.toml | 2 +- crates/languages/src/go/config.toml | 2 +- crates/languages/src/javascript/config.toml | 6 +- crates/languages/src/markdown/config.toml | 2 +- crates/languages/src/rust/config.toml | 2 +- crates/languages/src/tsx/config.toml | 6 +- crates/languages/src/typescript/config.toml | 4 +- extensions/glsl/languages/glsl/config.toml | 2 +- extensions/html/languages/html/config.toml | 2 +- 18 files changed, 249 insertions(+), 74 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index c64995b01b..6c346e331e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -9018,6 +9018,7 @@ dependencies = [ "task", "text", "theme", + "toml 0.8.20", "tree-sitter", "tree-sitter-elixir", "tree-sitter-embedded-template", diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index a31f789fb0..d5448f30f3 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -109,10 +109,10 @@ use inline_completion::{EditPredictionProvider, InlineCompletionProviderHandle}; pub use items::MAX_TAB_TITLE_LEN; use itertools::Itertools; use language::{ - AutoindentMode, BracketMatch, BracketPair, Buffer, Capability, CharKind, CodeLabel, - CursorShape, DiagnosticEntry, DiffOptions, DocumentationConfig, EditPredictionsMode, - EditPreview, HighlightedText, IndentKind, IndentSize, Language, OffsetRangeExt, Point, - Selection, SelectionGoal, TextObject, TransactionId, TreeSitterOptions, WordsQuery, + AutoindentMode, BlockCommentConfig, BracketMatch, BracketPair, Buffer, Capability, CharKind, + CodeLabel, CursorShape, DiagnosticEntry, DiffOptions, EditPredictionsMode, EditPreview, + HighlightedText, IndentKind, IndentSize, Language, OffsetRangeExt, Point, Selection, + SelectionGoal, TextObject, TransactionId, TreeSitterOptions, WordsQuery, language_settings::{ self, InlayHintSettings, LspInsertMode, RewrapBehavior, WordsCompletionMode, all_language_settings, language_settings, @@ -4408,7 +4408,9 @@ impl Editor { }) .max_by_key(|(_, len)| *len)?; - if let Some((block_start, _)) = language.block_comment_delimiters() + if let Some(BlockCommentConfig { + start: block_start, .. + }) = language.block_comment() { let block_start_trimmed = block_start.trim_end(); if block_start_trimmed.starts_with(delimiter.trim_end()) { @@ -4445,13 +4447,12 @@ impl Editor { return None; } - let DocumentationConfig { + let BlockCommentConfig { start: start_tag, end: end_tag, prefix: delimiter, tab_size: len, - } = language.documentation()?; - + } = language.documentation_comment()?; let is_within_block_comment = buffer .language_scope_at(start_point) .is_some_and(|scope| scope.override_name() == Some("comment")); @@ -4521,7 +4522,7 @@ impl Editor { let cursor_is_at_start_of_end_tag = column == end_tag_offset; if cursor_is_at_start_of_end_tag { - indent_on_extra_newline.len = (*len).into(); + indent_on_extra_newline.len = *len; } } cursor_is_before_end_tag @@ -4534,7 +4535,7 @@ impl Editor { && cursor_is_before_end_tag_if_exists { if cursor_is_after_start_tag { - indent_on_newline.len = (*len).into(); + indent_on_newline.len = *len; } Some(delimiter.clone()) } else { @@ -14349,8 +14350,11 @@ impl Editor { (position..position, first_prefix.clone()) })); } - } else if let Some((full_comment_prefix, comment_suffix)) = - language.block_comment_delimiters() + } else if let Some(BlockCommentConfig { + start: full_comment_prefix, + end: comment_suffix, + .. + }) = language.block_comment() { let comment_prefix = full_comment_prefix.trim_end_matches(' '); let comment_prefix_whitespace = &full_comment_prefix[comment_prefix.len()..]; diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index fbb877796c..b9ca8c3755 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -2875,11 +2875,11 @@ async fn test_newline_documentation_comments(cx: &mut TestAppContext) { let language = Arc::new( Language::new( LanguageConfig { - documentation: Some(language::DocumentationConfig { + documentation_comment: Some(language::BlockCommentConfig { start: "/**".into(), end: "*/".into(), prefix: "* ".into(), - tab_size: NonZeroU32::new(1).unwrap(), + tab_size: 1, }), ..LanguageConfig::default() @@ -3089,7 +3089,12 @@ async fn test_newline_comments_with_block_comment(cx: &mut TestAppContext) { let lua_language = Arc::new(Language::new( LanguageConfig { line_comments: vec!["--".into()], - block_comment: Some(("--[[".into(), "]]".into())), + block_comment: Some(language::BlockCommentConfig { + start: "--[[".into(), + prefix: "".into(), + end: "]]".into(), + tab_size: 0, + }), ..LanguageConfig::default() }, None, @@ -13806,7 +13811,12 @@ async fn test_toggle_block_comment(cx: &mut TestAppContext) { Language::new( LanguageConfig { name: "HTML".into(), - block_comment: Some(("".into())), + block_comment: Some(BlockCommentConfig { + start: "".into(), + tab_size: 0, + }), ..Default::default() }, Some(tree_sitter_html::LANGUAGE.into()), diff --git a/crates/editor/src/test/editor_lsp_test_context.rs b/crates/editor/src/test/editor_lsp_test_context.rs index f7f34135f3..c59786b1eb 100644 --- a/crates/editor/src/test/editor_lsp_test_context.rs +++ b/crates/editor/src/test/editor_lsp_test_context.rs @@ -14,7 +14,8 @@ use futures::Future; use gpui::{Context, Entity, Focusable as _, VisualTestContext, Window}; use indoc::indoc; use language::{ - FakeLspAdapter, Language, LanguageConfig, LanguageMatcher, LanguageQueries, point_to_lsp, + BlockCommentConfig, FakeLspAdapter, Language, LanguageConfig, LanguageMatcher, LanguageQueries, + point_to_lsp, }; use lsp::{notification, request}; use multi_buffer::ToPointUtf16; @@ -269,7 +270,12 @@ impl EditorLspTestContext { path_suffixes: vec!["html".into()], ..Default::default() }, - block_comment: Some(("".into())), + block_comment: Some(BlockCommentConfig { + start: "".into(), + tab_size: 0, + }), completion_query_characters: ['-'].into_iter().collect(), ..Default::default() }, diff --git a/crates/language/Cargo.toml b/crates/language/Cargo.toml index 477b978517..4ab56d6647 100644 --- a/crates/language/Cargo.toml +++ b/crates/language/Cargo.toml @@ -92,6 +92,7 @@ tree-sitter-python.workspace = true tree-sitter-ruby.workspace = true tree-sitter-rust.workspace = true tree-sitter-typescript.workspace = true +toml.workspace = true unindent.workspace = true util = { workspace = true, features = ["test-support"] } zlog.workspace = true diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs index 6955cd0549..2e2df7e658 100644 --- a/crates/language/src/buffer_tests.rs +++ b/crates/language/src/buffer_tests.rs @@ -2273,7 +2273,12 @@ fn test_language_scope_at_with_javascript(cx: &mut App) { LanguageConfig { name: "JavaScript".into(), line_comments: vec!["// ".into()], - block_comment: Some(("/*".into(), "*/".into())), + block_comment: Some(BlockCommentConfig { + start: "/*".into(), + end: "*/".into(), + prefix: "* ".into(), + tab_size: 1, + }), brackets: BracketPairConfig { pairs: vec![ BracketPair { @@ -2300,7 +2305,12 @@ fn test_language_scope_at_with_javascript(cx: &mut App) { "element".into(), LanguageConfigOverride { line_comments: Override::Remove { remove: true }, - block_comment: Override::Set(("{/*".into(), "*/}".into())), + block_comment: Override::Set(BlockCommentConfig { + start: "{/*".into(), + prefix: "".into(), + end: "*/}".into(), + tab_size: 0, + }), ..Default::default() }, )] @@ -2338,9 +2348,15 @@ fn test_language_scope_at_with_javascript(cx: &mut App) { let config = snapshot.language_scope_at(0).unwrap(); assert_eq!(config.line_comment_prefixes(), &[Arc::from("// ")]); assert_eq!( - config.block_comment_delimiters(), - Some((&"/*".into(), &"*/".into())) + config.block_comment(), + Some(&BlockCommentConfig { + start: "/*".into(), + prefix: "* ".into(), + end: "*/".into(), + tab_size: 1, + }) ); + // Both bracket pairs are enabled assert_eq!( config.brackets().map(|e| e.1).collect::>(), @@ -2360,8 +2376,13 @@ fn test_language_scope_at_with_javascript(cx: &mut App) { .unwrap(); assert_eq!(string_config.line_comment_prefixes(), &[Arc::from("// ")]); assert_eq!( - string_config.block_comment_delimiters(), - Some((&"/*".into(), &"*/".into())) + string_config.block_comment(), + Some(&BlockCommentConfig { + start: "/*".into(), + prefix: "* ".into(), + end: "*/".into(), + tab_size: 1, + }) ); // Second bracket pair is disabled assert_eq!( @@ -2391,8 +2412,13 @@ fn test_language_scope_at_with_javascript(cx: &mut App) { .unwrap(); assert_eq!(tag_config.line_comment_prefixes(), &[Arc::from("// ")]); assert_eq!( - tag_config.block_comment_delimiters(), - Some((&"/*".into(), &"*/".into())) + tag_config.block_comment(), + Some(&BlockCommentConfig { + start: "/*".into(), + prefix: "* ".into(), + end: "*/".into(), + tab_size: 1, + }) ); assert_eq!( tag_config.brackets().map(|e| e.1).collect::>(), @@ -2408,8 +2434,13 @@ fn test_language_scope_at_with_javascript(cx: &mut App) { &[Arc::from("// ")] ); assert_eq!( - expression_in_element_config.block_comment_delimiters(), - Some((&"/*".into(), &"*/".into())) + expression_in_element_config.block_comment(), + Some(&BlockCommentConfig { + start: "/*".into(), + prefix: "* ".into(), + end: "*/".into(), + tab_size: 1, + }) ); assert_eq!( expression_in_element_config @@ -2528,13 +2559,18 @@ fn test_language_scope_at_with_combined_injections(cx: &mut App) { let html_config = snapshot.language_scope_at(Point::new(2, 4)).unwrap(); assert_eq!(html_config.line_comment_prefixes(), &[]); assert_eq!( - html_config.block_comment_delimiters(), - Some((&"".into())) + html_config.block_comment(), + Some(&BlockCommentConfig { + start: "".into(), + prefix: "".into(), + tab_size: 0, + }) ); let ruby_config = snapshot.language_scope_at(Point::new(3, 12)).unwrap(); assert_eq!(ruby_config.line_comment_prefixes(), &[Arc::from("# ")]); - assert_eq!(ruby_config.block_comment_delimiters(), None); + assert_eq!(ruby_config.block_comment(), None); buffer }); @@ -3490,7 +3526,12 @@ fn html_lang() -> Language { Language::new( LanguageConfig { name: LanguageName::new("HTML"), - block_comment: Some(("".into())), + block_comment: Some(BlockCommentConfig { + start: "".into(), + tab_size: 0, + }), ..Default::default() }, Some(tree_sitter_html::LANGUAGE.into()), @@ -3521,7 +3562,12 @@ fn erb_lang() -> Language { path_suffixes: vec!["erb".to_string()], ..Default::default() }, - block_comment: Some(("<%#".into(), "%>".into())), + block_comment: Some(BlockCommentConfig { + start: "<%#".into(), + prefix: "".into(), + end: "%>".into(), + tab_size: 0, + }), ..Default::default() }, Some(tree_sitter_embedded_template::LANGUAGE.into()), diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs index 1ad057ff41..1df33286ee 100644 --- a/crates/language/src/language.rs +++ b/crates/language/src/language.rs @@ -727,9 +727,12 @@ pub struct LanguageConfig { /// used for comment continuations on the next line, but only the first one is used for Editor::ToggleComments. #[serde(default)] pub line_comments: Vec>, - /// Starting and closing characters of a block comment. + /// Delimiters and configuration for recognizing and formatting block comments. #[serde(default)] - pub block_comment: Option<(Arc, Arc)>, + pub block_comment: Option, + /// Delimiters and configuration for recognizing and formatting documentation comments. + #[serde(default, alias = "documentation")] + pub documentation_comment: Option, /// A list of additional regex patterns that should be treated as prefixes /// for creating boundaries during rewrapping, ensuring content from one /// prefixed section doesn't merge with another (e.g., markdown list items). @@ -774,10 +777,6 @@ pub struct LanguageConfig { /// A list of preferred debuggers for this language. #[serde(default)] pub debuggers: IndexSet, - /// Whether to treat documentation comment of this language differently by - /// auto adding prefix on new line, adjusting the indenting , etc. - #[serde(default)] - pub documentation: Option, } #[derive(Clone, Debug, Deserialize, Default, JsonSchema)] @@ -837,17 +836,56 @@ pub struct JsxTagAutoCloseConfig { pub erroneous_close_tag_name_node_name: Option, } -/// The configuration for documentation block for this language. -#[derive(Clone, Deserialize, JsonSchema)] -pub struct DocumentationConfig { - /// A start tag of documentation block. +/// The configuration for block comments for this language. +#[derive(Clone, Debug, JsonSchema, PartialEq)] +pub struct BlockCommentConfig { + /// A start tag of block comment. pub start: Arc, - /// A end tag of documentation block. + /// A end tag of block comment. pub end: Arc, - /// A character to add as a prefix when a new line is added to a documentation block. + /// A character to add as a prefix when a new line is added to a block comment. pub prefix: Arc, /// A indent to add for prefix and end line upon new line. - pub tab_size: NonZeroU32, + pub tab_size: u32, +} + +impl<'de> Deserialize<'de> for BlockCommentConfig { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + #[derive(Deserialize)] + #[serde(untagged)] + enum BlockCommentConfigHelper { + New { + start: Arc, + end: Arc, + prefix: Arc, + tab_size: u32, + }, + Old([Arc; 2]), + } + + match BlockCommentConfigHelper::deserialize(deserializer)? { + BlockCommentConfigHelper::New { + start, + end, + prefix, + tab_size, + } => Ok(BlockCommentConfig { + start, + end, + prefix, + tab_size, + }), + BlockCommentConfigHelper::Old([start, end]) => Ok(BlockCommentConfig { + start, + end, + prefix: "".into(), + tab_size: 0, + }), + } + } } /// Represents a language for the given range. Some languages (e.g. HTML) @@ -864,7 +902,7 @@ pub struct LanguageConfigOverride { #[serde(default)] pub line_comments: Override>>, #[serde(default)] - pub block_comment: Override<(Arc, Arc)>, + pub block_comment: Override, #[serde(skip)] pub disabled_bracket_ixs: Vec, #[serde(default)] @@ -916,6 +954,7 @@ impl Default for LanguageConfig { autoclose_before: Default::default(), line_comments: Default::default(), block_comment: Default::default(), + documentation_comment: Default::default(), rewrap_prefixes: Default::default(), scope_opt_in_language_servers: Default::default(), overrides: Default::default(), @@ -929,7 +968,6 @@ impl Default for LanguageConfig { jsx_tag_auto_close: None, completion_query_characters: Default::default(), debuggers: Default::default(), - documentation: None, } } } @@ -1847,12 +1885,17 @@ impl LanguageScope { .map_or([].as_slice(), |e| e.as_slice()) } - pub fn block_comment_delimiters(&self) -> Option<(&Arc, &Arc)> { + /// Config for block comments for this language. + pub fn block_comment(&self) -> Option<&BlockCommentConfig> { Override::as_option( self.config_override().map(|o| &o.block_comment), self.language.config.block_comment.as_ref(), ) - .map(|e| (&e.0, &e.1)) + } + + /// Config for documentation-style block comments for this language. + pub fn documentation_comment(&self) -> Option<&BlockCommentConfig> { + self.language.config.documentation_comment.as_ref() } /// Returns additional regex patterns that act as prefix markers for creating @@ -1897,14 +1940,6 @@ impl LanguageScope { .unwrap_or(false) } - /// Returns config to documentation block for this language. - /// - /// Used for documentation styles that require a leading character on each line, - /// such as the asterisk in JSDoc, Javadoc, etc. - pub fn documentation(&self) -> Option<&DocumentationConfig> { - self.language.config.documentation.as_ref() - } - /// Returns a list of bracket pairs for a given language with an additional /// piece of information about whether the particular bracket pair is currently active for a given language. pub fn brackets(&self) -> impl Iterator { @@ -2299,6 +2334,7 @@ pub fn range_from_lsp(range: lsp::Range) -> Range> { mod tests { use super::*; use gpui::TestAppContext; + use pretty_assertions::assert_matches; #[gpui::test(iterations = 10)] async fn test_language_loading(cx: &mut TestAppContext) { @@ -2460,4 +2496,75 @@ mod tests { "LSP completion items with duplicate label and detail, should omit the detail" ); } + + #[test] + fn test_deserializing_comments_backwards_compat() { + // current version of `block_comment` and `documentation_comment` work + { + let config: LanguageConfig = ::toml::from_str( + r#" + name = "Foo" + block_comment = { start = "a", end = "b", prefix = "c", tab_size = 1 } + documentation_comment = { start = "d", end = "e", prefix = "f", tab_size = 2 } + "#, + ) + .unwrap(); + assert_matches!(config.block_comment, Some(BlockCommentConfig { .. })); + assert_matches!( + config.documentation_comment, + Some(BlockCommentConfig { .. }) + ); + + let block_config = config.block_comment.unwrap(); + assert_eq!(block_config.start.as_ref(), "a"); + assert_eq!(block_config.end.as_ref(), "b"); + assert_eq!(block_config.prefix.as_ref(), "c"); + assert_eq!(block_config.tab_size, 1); + + let doc_config = config.documentation_comment.unwrap(); + assert_eq!(doc_config.start.as_ref(), "d"); + assert_eq!(doc_config.end.as_ref(), "e"); + assert_eq!(doc_config.prefix.as_ref(), "f"); + assert_eq!(doc_config.tab_size, 2); + } + + // former `documentation` setting is read into `documentation_comment` + { + let config: LanguageConfig = ::toml::from_str( + r#" + name = "Foo" + documentation = { start = "a", end = "b", prefix = "c", tab_size = 1} + "#, + ) + .unwrap(); + assert_matches!( + config.documentation_comment, + Some(BlockCommentConfig { .. }) + ); + + let config = config.documentation_comment.unwrap(); + assert_eq!(config.start.as_ref(), "a"); + assert_eq!(config.end.as_ref(), "b"); + assert_eq!(config.prefix.as_ref(), "c"); + assert_eq!(config.tab_size, 1); + } + + // old block_comment format is read into BlockCommentConfig + { + let config: LanguageConfig = ::toml::from_str( + r#" + name = "Foo" + block_comment = ["a", "b"] + "#, + ) + .unwrap(); + assert_matches!(config.block_comment, Some(BlockCommentConfig { .. })); + + let config = config.block_comment.unwrap(); + assert_eq!(config.start.as_ref(), "a"); + assert_eq!(config.end.as_ref(), "b"); + assert_eq!(config.prefix.as_ref(), ""); + assert_eq!(config.tab_size, 0); + } + } } diff --git a/crates/languages/src/c/config.toml b/crates/languages/src/c/config.toml index 78213da5be..74290fd9e2 100644 --- a/crates/languages/src/c/config.toml +++ b/crates/languages/src/c/config.toml @@ -16,4 +16,4 @@ brackets = [ { start = "/*", end = " */", close = true, newline = false, not_in = ["string", "comment"] }, ] debuggers = ["CodeLLDB", "GDB"] -documentation = { start = "/*", end = "*/", prefix = "* ", tab_size = 1 } +documentation_comment = { start = "/*", prefix = "* ", end = "*/", tab_size = 1 } diff --git a/crates/languages/src/cpp/config.toml b/crates/languages/src/cpp/config.toml index 1e28381605..fab88266d7 100644 --- a/crates/languages/src/cpp/config.toml +++ b/crates/languages/src/cpp/config.toml @@ -16,4 +16,4 @@ brackets = [ { start = "/*", end = " */", close = true, newline = false, not_in = ["string", "comment"] }, ] debuggers = ["CodeLLDB", "GDB"] -documentation = { start = "/*", end = "*/", prefix = "* ", tab_size = 1 } +documentation_comment = { start = "/*", prefix = "* ", end = "*/", tab_size = 1 } diff --git a/crates/languages/src/css/config.toml b/crates/languages/src/css/config.toml index 0e0b7315e0..a2ca96e76d 100644 --- a/crates/languages/src/css/config.toml +++ b/crates/languages/src/css/config.toml @@ -10,5 +10,5 @@ brackets = [ { start = "'", end = "'", close = true, newline = false, not_in = ["string", "comment"] }, ] completion_query_characters = ["-"] -block_comment = ["/* ", " */"] +block_comment = { start = "/*", prefix = "* ", end = "*/", tab_size = 1 } prettier_parser_name = "css" diff --git a/crates/languages/src/go/config.toml b/crates/languages/src/go/config.toml index 84e35d8f0f..0a5122c038 100644 --- a/crates/languages/src/go/config.toml +++ b/crates/languages/src/go/config.toml @@ -15,4 +15,4 @@ brackets = [ tab_size = 4 hard_tabs = true debuggers = ["Delve"] -documentation = { start = "/*", end = "*/", prefix = "* ", tab_size = 1 } +documentation_comment = { start = "/*", prefix = "* ", end = "*/", tab_size = 1 } diff --git a/crates/languages/src/javascript/config.toml b/crates/languages/src/javascript/config.toml index ac87a9befd..0df57d985e 100644 --- a/crates/languages/src/javascript/config.toml +++ b/crates/languages/src/javascript/config.toml @@ -4,7 +4,8 @@ path_suffixes = ["js", "jsx", "mjs", "cjs"] # [/ ] is so we match "env node" or "/node" but not "ts-node" first_line_pattern = '^#!.*\b(?:[/ ]node|deno run.*--ext[= ]js)\b' line_comments = ["// "] -block_comment = ["/*", "*/"] +block_comment = { start = "/*", prefix = "* ", end = "*/", tab_size = 1 } +documentation_comment = { start = "/**", prefix = "* ", end = "*/", tab_size = 1 } autoclose_before = ";:.,=}])>" brackets = [ { start = "{", end = "}", close = true, newline = true }, @@ -21,7 +22,6 @@ tab_size = 2 scope_opt_in_language_servers = ["tailwindcss-language-server", "emmet-language-server"] prettier_parser_name = "babel" debuggers = ["JavaScript"] -documentation = { start = "/**", end = "*/", prefix = "* ", tab_size = 1 } [jsx_tag_auto_close] open_tag_node_name = "jsx_opening_element" @@ -31,7 +31,7 @@ tag_name_node_name = "identifier" [overrides.element] line_comments = { remove = true } -block_comment = ["{/* ", " */}"] +block_comment = { start = "{/* ", prefix = "", end = "*/}", tab_size = 0 } opt_into_language_servers = ["emmet-language-server"] [overrides.string] diff --git a/crates/languages/src/markdown/config.toml b/crates/languages/src/markdown/config.toml index 059e52de94..926dcd70d9 100644 --- a/crates/languages/src/markdown/config.toml +++ b/crates/languages/src/markdown/config.toml @@ -2,7 +2,7 @@ name = "Markdown" grammar = "markdown" path_suffixes = ["md", "mdx", "mdwn", "markdown", "MD"] completion_query_characters = ["-"] -block_comment = [""] +block_comment = { start = "", tab_size = 0 } autoclose_before = ";:.,=}])>" brackets = [ { start = "{", end = "}", close = true, newline = true }, diff --git a/crates/languages/src/rust/config.toml b/crates/languages/src/rust/config.toml index b55b6da4ab..fe8b4ffdcb 100644 --- a/crates/languages/src/rust/config.toml +++ b/crates/languages/src/rust/config.toml @@ -16,4 +16,4 @@ brackets = [ ] collapsed_placeholder = " /* ... */ " debuggers = ["CodeLLDB", "GDB"] -documentation = { start = "/*", end = "*/", prefix = "* ", tab_size = 1 } +documentation_comment = { start = "/*", prefix = "* ", end = "*/", tab_size = 1 } diff --git a/crates/languages/src/tsx/config.toml b/crates/languages/src/tsx/config.toml index 4176e62215..5849b9842f 100644 --- a/crates/languages/src/tsx/config.toml +++ b/crates/languages/src/tsx/config.toml @@ -2,7 +2,8 @@ name = "TSX" grammar = "tsx" path_suffixes = ["tsx"] line_comments = ["// "] -block_comment = ["/*", "*/"] +block_comment = { start = "/*", prefix = "* ", end = "*/", tab_size = 1 } +documentation_comment = { start = "/**", prefix = "* ", end = "*/", tab_size = 1 } autoclose_before = ";:.,=}])>" brackets = [ { start = "{", end = "}", close = true, newline = true }, @@ -19,7 +20,6 @@ scope_opt_in_language_servers = ["tailwindcss-language-server", "emmet-language- prettier_parser_name = "typescript" tab_size = 2 debuggers = ["JavaScript"] -documentation = { start = "/**", end = "*/", prefix = "* ", tab_size = 1 } [jsx_tag_auto_close] open_tag_node_name = "jsx_opening_element" @@ -30,7 +30,7 @@ tag_name_node_name_alternates = ["member_expression"] [overrides.element] line_comments = { remove = true } -block_comment = ["{/* ", " */}"] +block_comment = { start = "{/*", prefix = "", end = "*/}", tab_size = 0 } opt_into_language_servers = ["emmet-language-server"] [overrides.string] diff --git a/crates/languages/src/typescript/config.toml b/crates/languages/src/typescript/config.toml index db0f32aa0d..d7e3e4bd3d 100644 --- a/crates/languages/src/typescript/config.toml +++ b/crates/languages/src/typescript/config.toml @@ -3,7 +3,8 @@ grammar = "typescript" path_suffixes = ["ts", "cts", "mts"] first_line_pattern = '^#!.*\b(?:deno run|ts-node|bun|tsx|[/ ]node)\b' line_comments = ["// "] -block_comment = ["/*", "*/"] +block_comment = { start = "/*", prefix = "* ", end = "*/", tab_size = 1 } +documentation_comment = { start = "/**", prefix = "* ", end = "*/", tab_size = 1 } autoclose_before = ";:.,=}])>" brackets = [ { start = "{", end = "}", close = true, newline = true }, @@ -19,7 +20,6 @@ word_characters = ["#", "$"] prettier_parser_name = "typescript" tab_size = 2 debuggers = ["JavaScript"] -documentation = { start = "/**", end = "*/", prefix = "* ", tab_size = 1 } [overrides.string] completion_query_characters = ["."] diff --git a/extensions/glsl/languages/glsl/config.toml b/extensions/glsl/languages/glsl/config.toml index 0144e981cc..0c71419c91 100644 --- a/extensions/glsl/languages/glsl/config.toml +++ b/extensions/glsl/languages/glsl/config.toml @@ -12,7 +12,7 @@ path_suffixes = [ ] first_line_pattern = '^#version \d+' line_comments = ["// "] -block_comment = ["/* ", " */"] +block_comment = { start = "/* ", prefix = "* ", end = "*/", tab_size = 1 } brackets = [ { start = "{", end = "}", close = true, newline = true }, { start = "[", end = "]", close = true, newline = true }, diff --git a/extensions/html/languages/html/config.toml b/extensions/html/languages/html/config.toml index 6f52cc8f65..f74db2888e 100644 --- a/extensions/html/languages/html/config.toml +++ b/extensions/html/languages/html/config.toml @@ -2,7 +2,7 @@ name = "HTML" grammar = "html" path_suffixes = ["html", "htm", "shtml"] autoclose_before = ">})" -block_comment = [""] +block_comment = { start = "", tab_size = 0 } brackets = [ { start = "{", end = "}", close = true, newline = true }, { start = "[", end = "]", close = true, newline = true }, From 326fe05b331118cdb7d630f04c379dd0facb28ad Mon Sep 17 00:00:00 2001 From: Mikayla Maki Date: Wed, 23 Jul 2025 08:44:45 -0700 Subject: [PATCH 0154/1052] Resizable columns (#34794) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This PR adds resizable columns to the keymap editor and the ability to double-click on a resizable column to set a column back to its default size. The table uses a column's width to calculate what position it should be laid out at. So `column[i]` x position is calculated by the summation of `column[..i]`. When resizing `column[i]`, `column[i+1]`’s size is adjusted to keep all columns’ relative positions the same. If `column[i+1]` is at its minimum size, we keep seeking to the right to find a column with space left to take. An improvement to resizing behavior and double-clicking could be made by checking both column ranges `0..i-1` and `i+1..COLS`, since only one range of columns is checked for resize capacity. Release Notes: - N/A --------- Co-authored-by: Anthony Co-authored-by: Remco Smits --- Cargo.lock | 1 + crates/settings_ui/Cargo.toml | 1 + crates/settings_ui/src/keybindings.rs | 30 +- crates/settings_ui/src/ui_components/table.rs | 455 ++++++++++++++++-- crates/workspace/src/pane_group.rs | 11 + 5 files changed, 449 insertions(+), 49 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 6c346e331e..765ae00249 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -14779,6 +14779,7 @@ dependencies = [ "fs", "fuzzy", "gpui", + "itertools 0.14.0", "language", "log", "menu", diff --git a/crates/settings_ui/Cargo.toml b/crates/settings_ui/Cargo.toml index 651397dd51..02327045fd 100644 --- a/crates/settings_ui/Cargo.toml +++ b/crates/settings_ui/Cargo.toml @@ -23,6 +23,7 @@ feature_flags.workspace = true fs.workspace = true fuzzy.workspace = true gpui.workspace = true +itertools.workspace = true language.workspace = true log.workspace = true menu.workspace = true diff --git a/crates/settings_ui/src/keybindings.rs b/crates/settings_ui/src/keybindings.rs index 9e885f69f6..8fdacf7ae8 100644 --- a/crates/settings_ui/src/keybindings.rs +++ b/crates/settings_ui/src/keybindings.rs @@ -13,8 +13,8 @@ use gpui::{ Action, Animation, AnimationExt, AppContext as _, AsyncApp, Axis, ClickEvent, Context, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, FontWeight, Global, IsZero, KeyContext, Keystroke, Modifiers, ModifiersChangedEvent, MouseButton, Point, ScrollStrategy, - ScrollWheelEvent, StyledText, Subscription, Task, TextStyleRefinement, WeakEntity, actions, - anchored, deferred, div, + ScrollWheelEvent, Stateful, StyledText, Subscription, Task, TextStyleRefinement, WeakEntity, + actions, anchored, deferred, div, }; use language::{Language, LanguageConfig, ToOffset as _}; use notifications::status_toast::{StatusToast, ToastIcon}; @@ -36,7 +36,7 @@ use workspace::{ use crate::{ keybindings::persistence::KEYBINDING_EDITORS, - ui_components::table::{Table, TableInteractionState}, + ui_components::table::{ColumnWidths, ResizeBehavior, Table, TableInteractionState}, }; const NO_ACTION_ARGUMENTS_TEXT: SharedString = SharedString::new_static(""); @@ -284,6 +284,7 @@ struct KeymapEditor { context_menu: Option<(Entity, Point, Subscription)>, previous_edit: Option, humanized_action_names: HumanizedActionNameCache, + current_widths: Entity>, show_hover_menus: bool, /// In order for the JSON LSP to run in the actions arguments editor, we /// require a backing file In order to avoid issues (primarily log spam) @@ -400,6 +401,7 @@ impl KeymapEditor { show_hover_menus: true, action_args_temp_dir: None, action_args_temp_dir_worktree: None, + current_widths: cx.new(|cx| ColumnWidths::new(cx)), }; this.on_keymap_changed(window, cx); @@ -1433,6 +1435,18 @@ impl Render for KeymapEditor { DefiniteLength::Fraction(0.45), DefiniteLength::Fraction(0.08), ]) + .resizable_columns( + [ + ResizeBehavior::None, + ResizeBehavior::Resizable, + ResizeBehavior::Resizable, + ResizeBehavior::Resizable, + ResizeBehavior::Resizable, + ResizeBehavior::Resizable, // this column doesn't matter + ], + &self.current_widths, + cx, + ) .header(["", "Action", "Arguments", "Keystrokes", "Context", "Source"]) .uniform_list( "keymap-editor-table", @@ -1594,15 +1608,14 @@ impl Render for KeymapEditor { .collect() }), ) - .map_row( - cx.processor(|this, (row_index, row): (usize, Div), _window, cx| { + .map_row(cx.processor( + |this, (row_index, row): (usize, Stateful
), _window, cx| { let is_conflict = this.has_conflict(row_index); let is_selected = this.selected_index == Some(row_index); let row_id = row_group_id(row_index); let row = row - .id(row_id.clone()) .on_any_mouse_down(cx.listener( move |this, mouse_down_event: &gpui::MouseDownEvent, @@ -1636,11 +1649,12 @@ impl Render for KeymapEditor { }) .when(is_selected, |row| { row.border_color(cx.theme().colors().panel_focused_border) + .border_2() }); row.into_any_element() - }), - ), + }, + )), ) .on_scroll_wheel(cx.listener(|this, event: &ScrollWheelEvent, _, cx| { // This ensures that the menu is not dismissed in cases where scroll events diff --git a/crates/settings_ui/src/ui_components/table.rs b/crates/settings_ui/src/ui_components/table.rs index 6ea59cd2f4..70472918d2 100644 --- a/crates/settings_ui/src/ui_components/table.rs +++ b/crates/settings_ui/src/ui_components/table.rs @@ -2,19 +2,24 @@ use std::{ops::Range, rc::Rc, time::Duration}; use editor::{EditorSettings, ShowScrollbar, scroll::ScrollbarAutoHide}; use gpui::{ - AppContext, Axis, Context, Entity, FocusHandle, Length, ListHorizontalSizingBehavior, - ListSizingBehavior, MouseButton, Point, Task, UniformListScrollHandle, WeakEntity, - transparent_black, uniform_list, + AbsoluteLength, AppContext, Axis, Context, DefiniteLength, DragMoveEvent, Entity, FocusHandle, + Length, ListHorizontalSizingBehavior, ListSizingBehavior, MouseButton, Point, Stateful, Task, + UniformListScrollHandle, WeakEntity, transparent_black, uniform_list, }; + +use itertools::intersperse_with; use settings::Settings as _; use ui::{ ActiveTheme as _, AnyElement, App, Button, ButtonCommon as _, ButtonStyle, Color, Component, ComponentScope, Div, ElementId, FixedWidth as _, FluentBuilder as _, Indicator, - InteractiveElement as _, IntoElement, ParentElement, Pixels, RegisterComponent, RenderOnce, - Scrollbar, ScrollbarState, StatefulInteractiveElement as _, Styled, StyledExt as _, + InteractiveElement, IntoElement, ParentElement, Pixels, RegisterComponent, RenderOnce, + Scrollbar, ScrollbarState, StatefulInteractiveElement, Styled, StyledExt as _, StyledTypography, Window, div, example_group_with_title, h_flex, px, single_example, v_flex, }; +#[derive(Debug)] +struct DraggedColumn(usize); + struct UniformListData { render_item_fn: Box, &mut Window, &mut App) -> Vec<[AnyElement; COLS]>>, element_id: ElementId, @@ -191,6 +196,87 @@ impl TableInteractionState { } } + fn render_resize_handles( + &self, + column_widths: &[Length; COLS], + resizable_columns: &[ResizeBehavior; COLS], + initial_sizes: [DefiniteLength; COLS], + columns: Option>>, + window: &mut Window, + cx: &mut App, + ) -> AnyElement { + let spacers = column_widths + .iter() + .map(|width| base_cell_style(Some(*width)).into_any_element()); + + let mut column_ix = 0; + let resizable_columns_slice = *resizable_columns; + let mut resizable_columns = resizable_columns.into_iter(); + let dividers = intersperse_with(spacers, || { + window.with_id(column_ix, |window| { + let mut resize_divider = div() + // This is required because this is evaluated at a different time than the use_state call above + .id(column_ix) + .relative() + .top_0() + .w_0p5() + .h_full() + .bg(cx.theme().colors().border.opacity(0.5)); + + let mut resize_handle = div() + .id("column-resize-handle") + .absolute() + .left_neg_0p5() + .w(px(5.0)) + .h_full(); + + if resizable_columns + .next() + .is_some_and(ResizeBehavior::is_resizable) + { + let hovered = window.use_state(cx, |_window, _cx| false); + resize_divider = resize_divider.when(*hovered.read(cx), |div| { + div.bg(cx.theme().colors().border_focused) + }); + resize_handle = resize_handle + .on_hover(move |&was_hovered, _, cx| hovered.write(cx, was_hovered)) + .cursor_col_resize() + .when_some(columns.clone(), |this, columns| { + this.on_click(move |event, window, cx| { + if event.down.click_count >= 2 { + columns.update(cx, |columns, _| { + columns.on_double_click( + column_ix, + &initial_sizes, + &resizable_columns_slice, + window, + ); + }) + } + + cx.stop_propagation(); + }) + }) + .on_drag(DraggedColumn(column_ix), |_, _offset, _window, cx| { + cx.new(|_cx| gpui::Empty) + }) + } + + column_ix += 1; + resize_divider.child(resize_handle).into_any_element() + }) + }); + + div() + .id("resize-handles") + .h_flex() + .absolute() + .w_full() + .inset_0() + .children(dividers) + .into_any_element() + } + fn render_vertical_scrollbar_track( this: &Entity, parent: Div, @@ -369,6 +455,217 @@ impl TableInteractionState { } } +#[derive(Debug, Copy, Clone, PartialEq)] +pub enum ResizeBehavior { + None, + Resizable, + MinSize(f32), +} + +impl ResizeBehavior { + pub fn is_resizable(&self) -> bool { + *self != ResizeBehavior::None + } + + pub fn min_size(&self) -> Option { + match self { + ResizeBehavior::None => None, + ResizeBehavior::Resizable => Some(0.05), + ResizeBehavior::MinSize(min_size) => Some(*min_size), + } + } +} + +pub struct ColumnWidths { + widths: [DefiniteLength; COLS], + cached_bounds_width: Pixels, + initialized: bool, +} + +impl ColumnWidths { + pub fn new(_: &mut App) -> Self { + Self { + widths: [DefiniteLength::default(); COLS], + cached_bounds_width: Default::default(), + initialized: false, + } + } + + fn get_fraction(length: &DefiniteLength, bounds_width: Pixels, rem_size: Pixels) -> f32 { + match length { + DefiniteLength::Absolute(AbsoluteLength::Pixels(pixels)) => *pixels / bounds_width, + DefiniteLength::Absolute(AbsoluteLength::Rems(rems_width)) => { + rems_width.to_pixels(rem_size) / bounds_width + } + DefiniteLength::Fraction(fraction) => *fraction, + } + } + + fn on_double_click( + &mut self, + double_click_position: usize, + initial_sizes: &[DefiniteLength; COLS], + resize_behavior: &[ResizeBehavior; COLS], + window: &mut Window, + ) { + let bounds_width = self.cached_bounds_width; + let rem_size = window.rem_size(); + + let diff = + Self::get_fraction( + &initial_sizes[double_click_position], + bounds_width, + rem_size, + ) - Self::get_fraction(&self.widths[double_click_position], bounds_width, rem_size); + + let mut curr_column = double_click_position + 1; + let mut diff_left = diff; + + while diff != 0.0 && curr_column < COLS { + let Some(min_size) = resize_behavior[curr_column].min_size() else { + curr_column += 1; + continue; + }; + + let mut curr_width = + Self::get_fraction(&self.widths[curr_column], bounds_width, rem_size) - diff_left; + + diff_left = 0.0; + if min_size > curr_width { + diff_left += min_size - curr_width; + curr_width = min_size; + } + self.widths[curr_column] = DefiniteLength::Fraction(curr_width); + curr_column += 1; + } + + self.widths[double_click_position] = DefiniteLength::Fraction( + Self::get_fraction(&self.widths[double_click_position], bounds_width, rem_size) + + (diff - diff_left), + ); + } + + fn on_drag_move( + &mut self, + drag_event: &DragMoveEvent, + resize_behavior: &[ResizeBehavior; COLS], + window: &mut Window, + cx: &mut Context, + ) { + // - [ ] Fix bugs in resize + let drag_position = drag_event.event.position; + let bounds = drag_event.bounds; + + let mut col_position = 0.0; + let rem_size = window.rem_size(); + let bounds_width = bounds.right() - bounds.left(); + let col_idx = drag_event.drag(cx).0; + + for length in self.widths[0..=col_idx].iter() { + col_position += Self::get_fraction(length, bounds_width, rem_size); + } + + let mut total_length_ratio = col_position; + for length in self.widths[col_idx + 1..].iter() { + total_length_ratio += Self::get_fraction(length, bounds_width, rem_size); + } + + let drag_fraction = (drag_position.x - bounds.left()) / bounds_width; + let drag_fraction = drag_fraction * total_length_ratio; + let diff = drag_fraction - col_position; + + let is_dragging_right = diff > 0.0; + + let mut diff_left = diff; + let mut curr_column = col_idx + 1; + + if is_dragging_right { + while diff_left > 0.0 && curr_column < COLS { + let Some(min_size) = resize_behavior[curr_column - 1].min_size() else { + curr_column += 1; + continue; + }; + + let mut curr_width = + Self::get_fraction(&self.widths[curr_column], bounds_width, rem_size) + - diff_left; + + diff_left = 0.0; + if min_size > curr_width { + diff_left += min_size - curr_width; + curr_width = min_size; + } + self.widths[curr_column] = DefiniteLength::Fraction(curr_width); + curr_column += 1; + } + + self.widths[col_idx] = DefiniteLength::Fraction( + Self::get_fraction(&self.widths[col_idx], bounds_width, rem_size) + + (diff - diff_left), + ); + } else { + curr_column = col_idx; + // Resize behavior should be improved in the future by also seeking to the right column when there's not enough space + while diff_left < 0.0 { + let Some(min_size) = resize_behavior[curr_column.saturating_sub(1)].min_size() + else { + if curr_column == 0 { + break; + } + curr_column -= 1; + continue; + }; + + let mut curr_width = + Self::get_fraction(&self.widths[curr_column], bounds_width, rem_size) + + diff_left; + + diff_left = 0.0; + if curr_width < min_size { + diff_left = curr_width - min_size; + curr_width = min_size + } + + self.widths[curr_column] = DefiniteLength::Fraction(curr_width); + if curr_column == 0 { + break; + } + curr_column -= 1; + } + + self.widths[col_idx + 1] = DefiniteLength::Fraction( + Self::get_fraction(&self.widths[col_idx + 1], bounds_width, rem_size) + - (diff - diff_left), + ); + } + } +} + +pub struct TableWidths { + initial: [DefiniteLength; COLS], + current: Option>>, + resizable: [ResizeBehavior; COLS], +} + +impl TableWidths { + pub fn new(widths: [impl Into; COLS]) -> Self { + let widths = widths.map(Into::into); + + TableWidths { + initial: widths, + current: None, + resizable: [ResizeBehavior::None; COLS], + } + } + + fn lengths(&self, cx: &App) -> [Length; COLS] { + self.current + .as_ref() + .map(|entity| entity.read(cx).widths.map(Length::Definite)) + .unwrap_or(self.initial.map(Length::Definite)) + } +} + /// A table component #[derive(RegisterComponent, IntoElement)] pub struct Table { @@ -377,23 +674,23 @@ pub struct Table { headers: Option<[AnyElement; COLS]>, rows: TableContents, interaction_state: Option>, - column_widths: Option<[Length; COLS]>, - map_row: Option AnyElement>>, + col_widths: Option>, + map_row: Option), &mut Window, &mut App) -> AnyElement>>, empty_table_callback: Option AnyElement>>, } impl Table { /// number of headers provided. pub fn new() -> Self { - Table { + Self { striped: false, width: None, headers: None, rows: TableContents::Vec(Vec::new()), interaction_state: None, - column_widths: None, map_row: None, empty_table_callback: None, + col_widths: None, } } @@ -454,14 +751,38 @@ impl Table { self } - pub fn column_widths(mut self, widths: [impl Into; COLS]) -> Self { - self.column_widths = Some(widths.map(Into::into)); + pub fn column_widths(mut self, widths: [impl Into; COLS]) -> Self { + if self.col_widths.is_none() { + self.col_widths = Some(TableWidths::new(widths)); + } + self + } + + pub fn resizable_columns( + mut self, + resizable: [ResizeBehavior; COLS], + column_widths: &Entity>, + cx: &mut App, + ) -> Self { + if let Some(table_widths) = self.col_widths.as_mut() { + table_widths.resizable = resizable; + let column_widths = table_widths + .current + .get_or_insert_with(|| column_widths.clone()); + + column_widths.update(cx, |widths, _| { + if !widths.initialized { + widths.initialized = true; + widths.widths = table_widths.initial; + } + }) + } self } pub fn map_row( mut self, - callback: impl Fn((usize, Div), &mut Window, &mut App) -> AnyElement + 'static, + callback: impl Fn((usize, Stateful
), &mut Window, &mut App) -> AnyElement + 'static, ) -> Self { self.map_row = Some(Rc::new(callback)); self @@ -477,18 +798,21 @@ impl Table { } } -fn base_cell_style(width: Option, cx: &App) -> Div { +fn base_cell_style(width: Option) -> Div { div() .px_1p5() .when_some(width, |this, width| this.w(width)) .when(width.is_none(), |this| this.flex_1()) .justify_start() - .text_ui(cx) .whitespace_nowrap() .text_ellipsis() .overflow_hidden() } +fn base_cell_style_text(width: Option, cx: &App) -> Div { + base_cell_style(width).text_ui(cx) +} + pub fn render_row( row_index: usize, items: [impl IntoElement; COLS], @@ -507,33 +831,33 @@ pub fn render_row( .column_widths .map_or([None; COLS], |widths| widths.map(Some)); - let row = div().w_full().child( - h_flex() - .id("table_row") - .w_full() - .justify_between() - .px_1p5() - .py_1() - .when_some(bg, |row, bg| row.bg(bg)) - .when(!is_striped, |row| { - row.border_b_1() - .border_color(transparent_black()) - .when(!is_last, |row| row.border_color(cx.theme().colors().border)) - }) - .children( - items - .map(IntoElement::into_any_element) - .into_iter() - .zip(column_widths) - .map(|(cell, width)| base_cell_style(width, cx).child(cell)), - ), + let mut row = h_flex() + .h_full() + .id(("table_row", row_index)) + .w_full() + .justify_between() + .when_some(bg, |row, bg| row.bg(bg)) + .when(!is_striped, |row| { + row.border_b_1() + .border_color(transparent_black()) + .when(!is_last, |row| row.border_color(cx.theme().colors().border)) + }); + + row = row.children( + items + .map(IntoElement::into_any_element) + .into_iter() + .zip(column_widths) + .map(|(cell, width)| base_cell_style_text(width, cx).px_1p5().py_1().child(cell)), ); - if let Some(map_row) = table_context.map_row { + let row = if let Some(map_row) = table_context.map_row { map_row((row_index, row), window, cx) } else { row.into_any_element() - } + }; + + div().h_full().w_full().child(row).into_any_element() } pub fn render_header( @@ -557,7 +881,7 @@ pub fn render_header( headers .into_iter() .zip(column_widths) - .map(|(h, width)| base_cell_style(width, cx).child(h)), + .map(|(h, width)| base_cell_style_text(width, cx).child(h)), ) } @@ -566,15 +890,15 @@ pub struct TableRenderContext { pub striped: bool, pub total_row_count: usize, pub column_widths: Option<[Length; COLS]>, - pub map_row: Option AnyElement>>, + pub map_row: Option), &mut Window, &mut App) -> AnyElement>>, } impl TableRenderContext { - fn new(table: &Table) -> Self { + fn new(table: &Table, cx: &App) -> Self { Self { striped: table.striped, total_row_count: table.rows.len(), - column_widths: table.column_widths, + column_widths: table.col_widths.as_ref().map(|widths| widths.lengths(cx)), map_row: table.map_row.clone(), } } @@ -582,8 +906,13 @@ impl TableRenderContext { impl RenderOnce for Table { fn render(mut self, window: &mut Window, cx: &mut App) -> impl IntoElement { - let table_context = TableRenderContext::new(&self); + let table_context = TableRenderContext::new(&self, cx); let interaction_state = self.interaction_state.and_then(|state| state.upgrade()); + let current_widths = self + .col_widths + .as_ref() + .and_then(|widths| Some((widths.current.as_ref()?, widths.resizable))) + .map(|(curr, resize_behavior)| (curr.downgrade(), resize_behavior)); let scroll_track_size = px(16.); let h_scroll_offset = if interaction_state @@ -606,6 +935,31 @@ impl RenderOnce for Table { .when_some(self.headers.take(), |this, headers| { this.child(render_header(headers, table_context.clone(), cx)) }) + .when_some(current_widths, { + |this, (widths, resize_behavior)| { + this.on_drag_move::({ + let widths = widths.clone(); + move |e, window, cx| { + widths + .update(cx, |widths, cx| { + widths.on_drag_move(e, &resize_behavior, window, cx); + }) + .ok(); + } + }) + .on_children_prepainted(move |bounds, _, cx| { + widths + .update(cx, |widths, _| { + // This works because all children x axis bounds are the same + widths.cached_bounds_width = bounds[0].right() - bounds[0].left(); + }) + .ok(); + }) + } + }) + .on_drop::(|_, _, _| { + // Finish the resize operation + }) .child( div() .flex_grow() @@ -660,6 +1014,25 @@ impl RenderOnce for Table { ), ), }) + .when_some( + self.col_widths.as_ref().zip(interaction_state.as_ref()), + |parent, (table_widths, state)| { + parent.child(state.update(cx, |state, cx| { + let resizable_columns = table_widths.resizable; + let column_widths = table_widths.lengths(cx); + let columns = table_widths.current.clone(); + let initial_sizes = table_widths.initial; + state.render_resize_handles( + &column_widths, + &resizable_columns, + initial_sizes, + columns, + window, + cx, + ) + })) + }, + ) .when_some(interaction_state.as_ref(), |this, interaction_state| { this.map(|this| { TableInteractionState::render_vertical_scrollbar_track( diff --git a/crates/workspace/src/pane_group.rs b/crates/workspace/src/pane_group.rs index 4565cef347..5c87206e9e 100644 --- a/crates/workspace/src/pane_group.rs +++ b/crates/workspace/src/pane_group.rs @@ -943,6 +943,8 @@ mod element { pub struct PaneAxisElement { axis: Axis, basis: usize, + /// Equivalent to ColumnWidths (but in terms of flexes instead of percentages) + /// For example, flexes "1.33, 1, 1", instead of "40%, 30%, 30%" flexes: Arc>>, bounding_boxes: Arc>>>>, children: SmallVec<[AnyElement; 2]>, @@ -998,6 +1000,7 @@ mod element { let mut flexes = flexes.lock(); debug_assert!(flex_values_in_bounds(flexes.as_slice())); + // Math to convert a flex value to a pixel value let size = move |ix, flexes: &[f32]| { container_size.along(axis) * (flexes[ix] / flexes.len() as f32) }; @@ -1007,9 +1010,13 @@ mod element { return; } + // This is basically a "bucket" of pixel changes that need to be applied in response to this + // mouse event. Probably a small, fractional number like 0.5 or 1.5 pixels let mut proposed_current_pixel_change = (e.position - child_start).along(axis) - size(ix, flexes.as_slice()); + // This takes a pixel change, and computes the flex changes that correspond to this pixel change + // as well as the next one, for some reason let flex_changes = |pixel_dx, target_ix, next: isize, flexes: &[f32]| { let flex_change = pixel_dx / container_size.along(axis); let current_target_flex = flexes[target_ix] + flex_change; @@ -1017,6 +1024,9 @@ mod element { (current_target_flex, next_target_flex) }; + // Generate the list of flex successors, from the current index. + // If you're dragging column 3 forward, out of 6 columns, then this code will produce [4, 5, 6] + // If you're dragging column 3 backward, out of 6 columns, then this code will produce [2, 1, 0] let mut successors = iter::from_fn({ let forward = proposed_current_pixel_change > px(0.); let mut ix_offset = 0; @@ -1034,6 +1044,7 @@ mod element { } }); + // Now actually loop over these, and empty our bucket of pixel changes while proposed_current_pixel_change.abs() > px(0.) { let Some(current_ix) = successors.next() else { break; From 8713c556d660b7cdacda236bda373aa39bde589c Mon Sep 17 00:00:00 2001 From: Finn Evers Date: Wed, 23 Jul 2025 18:03:04 +0200 Subject: [PATCH 0155/1052] keymap_ui: Dim keybinds that are overridden by other keybinds (#34952) This change dims rows in the keymap editor for which the corresponding keybind is overridden by other keybinds coming from higher priority sources. Release Notes: - N/A --- assets/keymaps/default-linux.json | 5 +- assets/keymaps/default-macos.json | 5 +- crates/settings/src/keymap_file.rs | 30 +- crates/settings_ui/src/keybindings.rs | 909 ++++++++++++++++---------- 4 files changed, 602 insertions(+), 347 deletions(-) diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index b097be90fd..31adef8cd5 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -1137,7 +1137,10 @@ "alt-ctrl-f": "keymap_editor::ToggleKeystrokeSearch", "alt-c": "keymap_editor::ToggleConflictFilter", "enter": "keymap_editor::EditBinding", - "alt-enter": "keymap_editor::CreateBinding" + "alt-enter": "keymap_editor::CreateBinding", + "ctrl-c": "keymap_editor::CopyAction", + "ctrl-shift-c": "keymap_editor::CopyContext", + "ctrl-t": "keymap_editor::ShowMatchingKeybinds" } }, { diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index e33786f1b2..f942c6f8ae 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -1239,7 +1239,10 @@ "cmd-alt-f": "keymap_editor::ToggleKeystrokeSearch", "cmd-alt-c": "keymap_editor::ToggleConflictFilter", "enter": "keymap_editor::EditBinding", - "alt-enter": "keymap_editor::CreateBinding" + "alt-enter": "keymap_editor::CreateBinding", + "cmd-c": "keymap_editor::CopyAction", + "cmd-shift-c": "keymap_editor::CopyContext", + "cmd-t": "keymap_editor::ShowMatchingKeybinds" } }, { diff --git a/crates/settings/src/keymap_file.rs b/crates/settings/src/keymap_file.rs index 67e8f7e7b2..7802671fec 100644 --- a/crates/settings/src/keymap_file.rs +++ b/crates/settings/src/keymap_file.rs @@ -959,19 +959,21 @@ impl<'a> KeybindUpdateTarget<'a> { } } -#[derive(Clone, Copy, PartialEq, Eq)] +#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord)] pub enum KeybindSource { User, - Default, - Base, Vim, + Base, + #[default] + Default, + Unknown, } impl KeybindSource { - const BASE: KeyBindingMetaIndex = KeyBindingMetaIndex(0); - const DEFAULT: KeyBindingMetaIndex = KeyBindingMetaIndex(1); - const VIM: KeyBindingMetaIndex = KeyBindingMetaIndex(2); - const USER: KeyBindingMetaIndex = KeyBindingMetaIndex(3); + const BASE: KeyBindingMetaIndex = KeyBindingMetaIndex(KeybindSource::Base as u32); + const DEFAULT: KeyBindingMetaIndex = KeyBindingMetaIndex(KeybindSource::Default as u32); + const VIM: KeyBindingMetaIndex = KeyBindingMetaIndex(KeybindSource::Vim as u32); + const USER: KeyBindingMetaIndex = KeyBindingMetaIndex(KeybindSource::User as u32); pub fn name(&self) -> &'static str { match self { @@ -979,6 +981,7 @@ impl KeybindSource { KeybindSource::Default => "Default", KeybindSource::Base => "Base", KeybindSource::Vim => "Vim", + KeybindSource::Unknown => "Unknown", } } @@ -988,21 +991,18 @@ impl KeybindSource { KeybindSource::Default => Self::DEFAULT, KeybindSource::Base => Self::BASE, KeybindSource::Vim => Self::VIM, + KeybindSource::Unknown => KeyBindingMetaIndex(*self as u32), } } pub fn from_meta(index: KeyBindingMetaIndex) -> Self { - Self::try_from_meta(index).unwrap() - } - - pub fn try_from_meta(index: KeyBindingMetaIndex) -> Result { - Ok(match index { + match index { Self::USER => KeybindSource::User, Self::BASE => KeybindSource::Base, Self::DEFAULT => KeybindSource::Default, Self::VIM => KeybindSource::Vim, - _ => anyhow::bail!("Invalid keybind source {:?}", index), - }) + _ => KeybindSource::Unknown, + } } } @@ -1014,7 +1014,7 @@ impl From for KeybindSource { impl From for KeyBindingMetaIndex { fn from(source: KeybindSource) -> Self { - return source.meta(); + source.meta() } } diff --git a/crates/settings_ui/src/keybindings.rs b/crates/settings_ui/src/keybindings.rs index 8fdacf7ae8..a0cbdb9680 100644 --- a/crates/settings_ui/src/keybindings.rs +++ b/crates/settings_ui/src/keybindings.rs @@ -1,4 +1,5 @@ use std::{ + cmp::{self}, ops::{Not as _, Range}, sync::Arc, time::Duration, @@ -20,15 +21,13 @@ use language::{Language, LanguageConfig, ToOffset as _}; use notifications::status_toast::{StatusToast, ToastIcon}; use project::Project; use settings::{BaseKeymap, KeybindSource, KeymapFile, Settings as _, SettingsAssets}; - -use util::ResultExt; - use ui::{ ActiveTheme as _, App, Banner, BorrowAppContext, ContextMenu, IconButtonShape, Indicator, Modal, ModalFooter, ModalHeader, ParentElement as _, Render, Section, SharedString, Styled as _, Tooltip, Window, prelude::*, }; use ui_input::SingleLineInput; +use util::ResultExt; use workspace::{ Item, ModalView, SerializableItem, Workspace, notifications::NotifyTaskExt as _, register_serializable_item, @@ -68,6 +67,8 @@ actions!( ToggleKeystrokeSearch, /// Toggles exact matching for keystroke search ToggleExactKeystrokeMatching, + /// Shows matching keystrokes for the currently selected binding + ShowMatchingKeybinds ] ); @@ -192,76 +193,134 @@ struct KeybindConflict { } impl KeybindConflict { - fn from_iter<'a>(mut indices: impl Iterator) -> Option { - indices.next().map(|index| Self { - first_conflict_index: *index, + fn from_iter<'a>(mut indices: impl Iterator) -> Option { + indices.next().map(|origin| Self { + first_conflict_index: origin.index, remaining_conflict_amount: indices.count(), }) } } +#[derive(Clone, Copy, PartialEq)] +struct ConflictOrigin { + override_source: KeybindSource, + overridden_source: Option, + index: usize, +} + +impl ConflictOrigin { + fn new(source: KeybindSource, index: usize) -> Self { + Self { + override_source: source, + index, + overridden_source: None, + } + } + + fn with_overridden_source(self, source: KeybindSource) -> Self { + Self { + overridden_source: Some(source), + ..self + } + } + + fn get_conflict_with(&self, other: &Self) -> Option { + if self.override_source == KeybindSource::User + && other.override_source == KeybindSource::User + { + Some( + Self::new(KeybindSource::User, other.index) + .with_overridden_source(self.override_source), + ) + } else if self.override_source > other.override_source { + Some(other.with_overridden_source(self.override_source)) + } else { + None + } + } + + fn is_user_keybind_conflict(&self) -> bool { + self.override_source == KeybindSource::User + && self.overridden_source == Some(KeybindSource::User) + } +} + #[derive(Default)] struct ConflictState { - conflicts: Vec, - keybind_mapping: HashMap>, + conflicts: Vec>, + keybind_mapping: HashMap>, + has_user_conflicts: bool, } impl ConflictState { - fn new(key_bindings: &[ProcessedKeybinding]) -> Self { - let mut action_keybind_mapping: HashMap<_, Vec> = HashMap::default(); + fn new(key_bindings: &[ProcessedBinding]) -> Self { + let mut action_keybind_mapping: HashMap<_, Vec> = HashMap::default(); - key_bindings + let mut largest_index = 0; + for (index, binding) in key_bindings .iter() .enumerate() - .filter(|(_, binding)| { - binding.keystrokes().is_some() - && binding - .source - .as_ref() - .is_some_and(|source| matches!(source.0, KeybindSource::User)) - }) - .for_each(|(index, binding)| { - action_keybind_mapping - .entry(binding.get_action_mapping()) - .or_default() - .push(index); - }); + .flat_map(|(index, binding)| Some(index).zip(binding.keybind_information())) + { + action_keybind_mapping + .entry(binding.get_action_mapping()) + .or_default() + .push(ConflictOrigin::new(binding.source, index)); + largest_index = index; + } + + let mut conflicts = vec![None; largest_index + 1]; + let mut has_user_conflicts = false; + + for indices in action_keybind_mapping.values_mut() { + indices.sort_unstable_by_key(|origin| origin.override_source); + let Some((fst, snd)) = indices.get(0).zip(indices.get(1)) else { + continue; + }; + + for origin in indices.iter() { + conflicts[origin.index] = + origin.get_conflict_with(if origin == fst { &snd } else { &fst }) + } + + has_user_conflicts |= fst.override_source == KeybindSource::User + && snd.override_source == KeybindSource::User; + } Self { - conflicts: action_keybind_mapping - .values() - .filter(|indices| indices.len() > 1) - .flatten() - .copied() - .collect(), + conflicts, keybind_mapping: action_keybind_mapping, + has_user_conflicts, } } fn conflicting_indices_for_mapping( &self, action_mapping: &ActionMapping, - keybind_idx: usize, + keybind_idx: Option, ) -> Option { self.keybind_mapping .get(action_mapping) .and_then(|indices| { - KeybindConflict::from_iter(indices.iter().filter(|&idx| *idx != keybind_idx)) + KeybindConflict::from_iter( + indices + .iter() + .filter(|&conflict| Some(conflict.index) != keybind_idx), + ) }) } - fn will_conflict(&self, action_mapping: &ActionMapping) -> Option { - self.keybind_mapping - .get(action_mapping) - .and_then(|indices| KeybindConflict::from_iter(indices.iter())) + fn conflict_for_idx(&self, idx: usize) -> Option { + self.conflicts.get(idx).copied().flatten() } - fn has_conflict(&self, candidate_idx: &usize) -> bool { - self.conflicts.contains(candidate_idx) + fn has_user_conflict(&self, candidate_idx: usize) -> bool { + self.conflict_for_idx(candidate_idx) + .is_some_and(|conflict| conflict.is_user_keybind_conflict()) } - fn any_conflicts(&self) -> bool { - !self.conflicts.is_empty() + fn any_user_binding_conflicts(&self) -> bool { + self.has_user_conflicts } } @@ -269,7 +328,7 @@ struct KeymapEditor { workspace: WeakEntity, focus_handle: FocusHandle, _keymap_subscription: Subscription, - keybindings: Vec, + keybindings: Vec, keybinding_conflict_state: ConflictState, filter_state: FilterState, search_mode: SearchMode, @@ -426,24 +485,6 @@ impl KeymapEditor { } } - fn filter_on_selected_binding_keystrokes(&mut self, cx: &mut Context) { - let Some(selected_binding) = self.selected_binding() else { - return; - }; - - let keystrokes = selected_binding - .keystrokes() - .map(Vec::from) - .unwrap_or_default(); - - self.filter_state = FilterState::All; - self.search_mode = SearchMode::KeyStroke { exact_match: true }; - - self.keystroke_editor.update(cx, |editor, cx| { - editor.set_keystrokes(keystrokes, cx); - }); - } - fn on_query_changed(&mut self, cx: &mut Context) { let action_query = self.current_action_query(cx); let keystroke_query = self.current_keystroke_query(cx); @@ -505,7 +546,7 @@ impl KeymapEditor { FilterState::Conflicts => { matches.retain(|candidate| { this.keybinding_conflict_state - .has_conflict(&candidate.candidate_id) + .has_user_conflict(candidate.candidate_id) }); } FilterState::All => {} @@ -551,20 +592,11 @@ impl KeymapEditor { } if action_query.is_empty() { - // apply default sort - // sorts by source precedence, and alphabetically by action name within each source - matches.sort_by_key(|match_item| { - let keybind = &this.keybindings[match_item.candidate_id]; - let source = keybind.source.as_ref().map(|s| s.0); - use KeybindSource::*; - let source_precedence = match source { - Some(User) => 0, - Some(Vim) => 1, - Some(Base) => 2, - Some(Default) => 3, - None => 4, - }; - return (source_precedence, keybind.action_name); + matches.sort_by(|item1, item2| { + let binding1 = &this.keybindings[item1.candidate_id]; + let binding2 = &this.keybindings[item2.candidate_id]; + + binding1.cmp(binding2) }); } this.selected_index.take(); @@ -574,11 +606,11 @@ impl KeymapEditor { }) } - fn has_conflict(&self, row_index: usize) -> bool { - self.matches - .get(row_index) - .map(|candidate| candidate.candidate_id) - .is_some_and(|id| self.keybinding_conflict_state.has_conflict(&id)) + fn get_conflict(&self, row_index: usize) -> Option { + self.matches.get(row_index).and_then(|candidate| { + self.keybinding_conflict_state + .conflict_for_idx(candidate.candidate_id) + }) } fn process_bindings( @@ -586,7 +618,7 @@ impl KeymapEditor { zed_keybind_context_language: Arc, humanized_action_names: &HumanizedActionNameCache, cx: &mut App, - ) -> (Vec, Vec) { + ) -> (Vec, Vec) { let key_bindings_ptr = cx.key_bindings(); let lock = key_bindings_ptr.borrow(); let key_bindings = lock.bindings(); @@ -606,14 +638,12 @@ impl KeymapEditor { for key_binding in key_bindings { let source = key_binding .meta() - .map(settings::KeybindSource::try_from_meta) - .and_then(|source| source.log_err()); + .map(KeybindSource::from_meta) + .unwrap_or(KeybindSource::Unknown); let keystroke_text = ui::text_for_keystrokes(key_binding.keystrokes(), cx); - let ui_key_binding = Some( - ui::KeyBinding::new_from_gpui(key_binding.clone(), cx) - .vim_mode(source == Some(settings::KeybindSource::Vim)), - ); + let ui_key_binding = ui::KeyBinding::new_from_gpui(key_binding.clone(), cx) + .vim_mode(source == KeybindSource::Vim); let context = key_binding .predicate() @@ -625,48 +655,46 @@ impl KeymapEditor { }) .unwrap_or(KeybindContextString::Global); - let source = source.map(|source| (source, source.name().into())); - let action_name = key_binding.action().name(); unmapped_action_names.remove(&action_name); + let action_arguments = key_binding .action_input() .map(|arguments| SyntaxHighlightedText::new(arguments, json_language.clone())); - let action_docs = action_documentation.get(action_name).copied(); - - let index = processed_bindings.len(); - let humanized_action_name = humanized_action_names.get(action_name); - let string_match_candidate = StringMatchCandidate::new(index, &humanized_action_name); - processed_bindings.push(ProcessedKeybinding { - keystroke_text: keystroke_text.into(), - ui_key_binding, + let action_information = ActionInformation::new( action_name, action_arguments, - humanized_action_name, - action_docs, - has_schema: actions_with_schemas.contains(action_name), - context: Some(context), + &actions_with_schemas, + &action_documentation, + &humanized_action_names, + ); + + let index = processed_bindings.len(); + let string_match_candidate = + StringMatchCandidate::new(index, &action_information.humanized_name); + processed_bindings.push(ProcessedBinding::new_mapped( + keystroke_text, + ui_key_binding, + context, source, - }); + action_information, + )); string_match_candidates.push(string_match_candidate); } - let empty = SharedString::new_static(""); for action_name in unmapped_action_names.into_iter() { let index = processed_bindings.len(); - let humanized_action_name = humanized_action_names.get(action_name); - let string_match_candidate = StringMatchCandidate::new(index, &humanized_action_name); - processed_bindings.push(ProcessedKeybinding { - keystroke_text: empty.clone(), - ui_key_binding: None, + let action_information = ActionInformation::new( action_name, - action_arguments: None, - humanized_action_name, - action_docs: action_documentation.get(action_name).copied(), - has_schema: actions_with_schemas.contains(action_name), - context: None, - source: None, - }); + None, + &actions_with_schemas, + &action_documentation, + &humanized_action_names, + ); + let string_match_candidate = + StringMatchCandidate::new(index, &action_information.humanized_name); + + processed_bindings.push(ProcessedBinding::Unmapped(action_information)); string_match_candidates.push(string_match_candidate); } @@ -728,8 +756,9 @@ impl KeymapEditor { let scroll_position = this.matches.iter().enumerate().find_map(|(index, item)| { let binding = &this.keybindings[item.candidate_id]; - if binding.get_action_mapping() == action_mapping - && binding.action_name == action_name + if binding.get_action_mapping().is_some_and(|binding_mapping| { + binding_mapping == action_mapping + }) && binding.action().name == action_name { Some(index) } else { @@ -799,12 +828,12 @@ impl KeymapEditor { .map(|r#match| r#match.candidate_id) } - fn selected_keybind_and_index(&self) -> Option<(&ProcessedKeybinding, usize)> { + fn selected_keybind_and_index(&self) -> Option<(&ProcessedBinding, usize)> { self.selected_keybind_index() .map(|keybind_index| (&self.keybindings[keybind_index], keybind_index)) } - fn selected_binding(&self) -> Option<&ProcessedKeybinding> { + fn selected_binding(&self) -> Option<&ProcessedBinding> { self.selected_keybind_index() .and_then(|keybind_index| self.keybindings.get(keybind_index)) } @@ -832,15 +861,13 @@ impl KeymapEditor { window: &mut Window, cx: &mut Context, ) { - let weak = cx.weak_entity(); self.context_menu = self.selected_binding().map(|selected_binding| { let selected_binding_has_no_context = selected_binding - .context - .as_ref() + .context() .and_then(KeybindContextString::local) .is_none(); - let selected_binding_is_unbound = selected_binding.keystrokes().is_none(); + let selected_binding_is_unbound = selected_binding.is_unbound(); let context_menu = ContextMenu::build(window, cx, |menu, _window, _cx| { menu.context(self.focus_handle.clone()) @@ -863,14 +890,11 @@ impl KeymapEditor { Box::new(CopyContext), ) .separator() - .entry("Show Matching Keybindings", None, { - move |_, cx| { - weak.update(cx, |this, cx| { - this.filter_on_selected_binding_keystrokes(cx); - }) - .ok(); - } - }) + .action_disabled_when( + selected_binding_has_no_context, + "Show Matching Keybindings", + Box::new(ShowMatchingKeybinds), + ) }); let context_menu_handle = context_menu.focus_handle(cx); @@ -898,10 +922,98 @@ impl KeymapEditor { self.context_menu.is_some() } + fn create_row_button( + &self, + index: usize, + conflict: Option, + cx: &mut Context, + ) -> IconButton { + if self.filter_state != FilterState::Conflicts + && let Some(conflict) = conflict + { + if conflict.is_user_keybind_conflict() { + base_button_style(index, IconName::Warning) + .icon_color(Color::Warning) + .tooltip(|window, cx| { + Tooltip::with_meta( + "View conflicts", + Some(&ToggleConflictFilter), + "Use alt+click to show all conflicts", + window, + cx, + ) + }) + .on_click(cx.listener(move |this, click: &ClickEvent, window, cx| { + if click.modifiers().alt { + this.set_filter_state(FilterState::Conflicts, cx); + } else { + this.select_index(index, None, window, cx); + this.open_edit_keybinding_modal(false, window, cx); + cx.stop_propagation(); + } + })) + } else if self.search_mode.exact_match() { + base_button_style(index, IconName::Info) + .tooltip(|window, cx| { + Tooltip::with_meta( + "Edit this binding", + Some(&ShowMatchingKeybinds), + "This binding is overridden by other bindings.", + window, + cx, + ) + }) + .on_click(cx.listener(move |this, _: &ClickEvent, window, cx| { + this.select_index(index, None, window, cx); + this.open_edit_keybinding_modal(false, window, cx); + cx.stop_propagation(); + })) + } else { + base_button_style(index, IconName::Info) + .tooltip(|window, cx| { + Tooltip::with_meta( + "Show matching keybinds", + Some(&ShowMatchingKeybinds), + "This binding is overridden by other bindings.\nUse alt+click to edit this binding", + window, + cx, + ) + }) + .on_click(cx.listener(move |this, click: &ClickEvent, window, cx| { + if click.modifiers().alt { + this.select_index(index, None, window, cx); + this.open_edit_keybinding_modal(false, window, cx); + cx.stop_propagation(); + } else { + this.show_matching_keystrokes(&Default::default(), window, cx); + } + })) + } + } else { + base_button_style(index, IconName::Pencil) + .visible_on_hover(if self.selected_index == Some(index) { + "".into() + } else if self.show_hover_menus { + row_group_id(index) + } else { + "never-show".into() + }) + .when( + self.show_hover_menus && !self.context_menu_deployed(), + |this| this.tooltip(Tooltip::for_action_title("Edit Keybinding", &EditBinding)), + ) + .on_click(cx.listener(move |this, _, window, cx| { + this.select_index(index, None, window, cx); + this.open_edit_keybinding_modal(false, window, cx); + cx.stop_propagation(); + })) + } + } + fn render_no_matches_hint(&self, _window: &mut Window, _cx: &App) -> AnyElement { let hint = match (self.filter_state, &self.search_mode) { (FilterState::Conflicts, _) => { - if self.keybinding_conflict_state.any_conflicts() { + if self.keybinding_conflict_state.any_user_binding_conflicts() { "No conflicting keybinds found that match the provided query" } else { "No conflicting keybinds found" @@ -982,20 +1094,22 @@ impl KeymapEditor { let keybind = keybind.clone(); let keymap_editor = cx.entity(); + let keystroke = keybind.keystroke_text().cloned().unwrap_or_default(); let arguments = keybind - .action_arguments + .action() + .arguments .as_ref() .map(|arguments| arguments.text.clone()); let context = keybind - .context - .as_ref() + .context() .map(|context| context.local_str().unwrap_or("global")); - let source = keybind.source.as_ref().map(|source| source.1.clone()); + let action = keybind.action().name; + let source = keybind.keybind_source().map(|source| source.name()); telemetry::event!( "Edit Keybinding Modal Opened", - keystroke = keybind.keystroke_text, - action = keybind.action_name, + keystroke = keystroke, + action = action, source = source, context = context, arguments = arguments, @@ -1063,7 +1177,7 @@ impl KeymapEditor { ) { let context = self .selected_binding() - .and_then(|binding| binding.context.as_ref()) + .and_then(|binding| binding.context()) .and_then(KeybindContextString::local_str) .map(|context| context.to_string()); let Some(context) = context else { @@ -1082,7 +1196,7 @@ impl KeymapEditor { ) { let action = self .selected_binding() - .map(|binding| binding.action_name.to_string()); + .map(|binding| binding.action().name.to_string()); let Some(action) = action else { return; }; @@ -1142,6 +1256,29 @@ impl KeymapEditor { *exact_match = !(*exact_match); self.on_query_changed(cx); } + + fn show_matching_keystrokes( + &mut self, + _: &ShowMatchingKeybinds, + _: &mut Window, + cx: &mut Context, + ) { + let Some(selected_binding) = self.selected_binding() else { + return; + }; + + let keystrokes = selected_binding + .keystrokes() + .map(Vec::from) + .unwrap_or_default(); + + self.filter_state = FilterState::All; + self.search_mode = SearchMode::KeyStroke { exact_match: true }; + + self.keystroke_editor.update(cx, |editor, cx| { + editor.set_keystrokes(keystrokes, cx); + }); + } } struct HumanizedActionNameCache { @@ -1168,35 +1305,134 @@ impl HumanizedActionNameCache { } #[derive(Clone)] -struct ProcessedKeybinding { +struct KeybindInformation { keystroke_text: SharedString, - ui_key_binding: Option, - action_name: &'static str, - humanized_action_name: SharedString, - action_arguments: Option, - action_docs: Option<&'static str>, - has_schema: bool, - context: Option, - source: Option<(KeybindSource, SharedString)>, + ui_binding: ui::KeyBinding, + context: KeybindContextString, + source: KeybindSource, } -impl ProcessedKeybinding { +impl KeybindInformation { fn get_action_mapping(&self) -> ActionMapping { ActionMapping { - keystrokes: self.keystrokes().map(Vec::from).unwrap_or_default(), - context: self - .context - .as_ref() - .and_then(|context| context.local()) - .cloned(), + keystrokes: self.ui_binding.keystrokes.clone(), + context: self.context.local().cloned(), } } +} + +#[derive(Clone)] +struct ActionInformation { + name: &'static str, + humanized_name: SharedString, + arguments: Option, + documentation: Option<&'static str>, + has_schema: bool, +} + +impl ActionInformation { + fn new( + action_name: &'static str, + action_arguments: Option, + actions_with_schemas: &HashSet<&'static str>, + action_documentation: &HashMap<&'static str, &'static str>, + action_name_cache: &HumanizedActionNameCache, + ) -> Self { + Self { + humanized_name: action_name_cache.get(action_name), + has_schema: actions_with_schemas.contains(action_name), + arguments: action_arguments, + documentation: action_documentation.get(action_name).copied(), + name: action_name, + } + } +} + +#[derive(Clone)] +enum ProcessedBinding { + Mapped(KeybindInformation, ActionInformation), + Unmapped(ActionInformation), +} + +impl ProcessedBinding { + fn new_mapped( + keystroke_text: impl Into, + ui_key_binding: ui::KeyBinding, + context: KeybindContextString, + source: KeybindSource, + action_information: ActionInformation, + ) -> Self { + Self::Mapped( + KeybindInformation { + keystroke_text: keystroke_text.into(), + ui_binding: ui_key_binding, + context, + source, + }, + action_information, + ) + } + + fn is_unbound(&self) -> bool { + matches!(self, Self::Unmapped(_)) + } + + fn get_action_mapping(&self) -> Option { + self.keybind_information() + .map(|keybind| keybind.get_action_mapping()) + } fn keystrokes(&self) -> Option<&[Keystroke]> { - self.ui_key_binding - .as_ref() + self.ui_key_binding() .map(|binding| binding.keystrokes.as_slice()) } + + fn keybind_information(&self) -> Option<&KeybindInformation> { + match self { + Self::Mapped(keybind_information, _) => Some(keybind_information), + Self::Unmapped(_) => None, + } + } + + fn keybind_source(&self) -> Option { + self.keybind_information().map(|keybind| keybind.source) + } + + fn context(&self) -> Option<&KeybindContextString> { + self.keybind_information().map(|keybind| &keybind.context) + } + + fn ui_key_binding(&self) -> Option<&ui::KeyBinding> { + self.keybind_information() + .map(|keybind| &keybind.ui_binding) + } + + fn keystroke_text(&self) -> Option<&SharedString> { + self.keybind_information() + .map(|binding| &binding.keystroke_text) + } + + fn action(&self) -> &ActionInformation { + match self { + Self::Mapped(_, action) | Self::Unmapped(action) => action, + } + } + + fn cmp(&self, other: &Self) -> cmp::Ordering { + match (self, other) { + (Self::Mapped(keybind1, action1), Self::Mapped(keybind2, action2)) => { + match keybind1.source.cmp(&keybind2.source) { + cmp::Ordering::Equal => action1.humanized_name.cmp(&action2.humanized_name), + ordering => ordering, + } + } + (Self::Mapped(_, _), Self::Unmapped(_)) => cmp::Ordering::Less, + (Self::Unmapped(_), Self::Mapped(_, _)) => cmp::Ordering::Greater, + (Self::Unmapped(action1), Self::Unmapped(action2)) => { + action1.humanized_name.cmp(&action2.humanized_name) + } + } + } } #[derive(Clone, Debug, IntoElement, PartialEq, Eq, Hash)] @@ -1275,6 +1511,7 @@ impl Render for KeymapEditor { .on_action(cx.listener(Self::toggle_conflict_filter)) .on_action(cx.listener(Self::toggle_keystroke_search)) .on_action(cx.listener(Self::toggle_exact_keystroke_matching)) + .on_action(cx.listener(Self::show_matching_keystrokes)) .on_mouse_move(cx.listener(|this, _, _window, _cx| { this.show_hover_menus = true; })) @@ -1335,9 +1572,12 @@ impl Render for KeymapEditor { .child( IconButton::new("KeymapEditorConflictIcon", IconName::Warning) .shape(ui::IconButtonShape::Square) - .when(self.keybinding_conflict_state.any_conflicts(), |this| { - this.indicator(Indicator::dot().color(Color::Warning)) - }) + .when( + self.keybinding_conflict_state.any_user_binding_conflicts(), + |this| { + this.indicator(Indicator::dot().color(Color::Warning)) + }, + ) .tooltip({ let filter_state = self.filter_state; let focus_handle = focus_handle.clone(); @@ -1377,7 +1617,10 @@ impl Render for KeymapEditor { this.child( h_flex() .map(|this| { - if self.keybinding_conflict_state.any_conflicts() { + if self + .keybinding_conflict_state + .any_user_binding_conflicts() + { this.pr(rems_from_px(54.)) } else { this.pr_7() @@ -1457,73 +1700,21 @@ impl Render for KeymapEditor { .filter_map(|index| { let candidate_id = this.matches.get(index)?.candidate_id; let binding = &this.keybindings[candidate_id]; - let action_name = binding.action_name; + let action_name = binding.action().name; + let conflict = this.get_conflict(index); + let is_overridden = conflict.is_some_and(|conflict| { + !conflict.is_user_keybind_conflict() + }); - let icon = if this.filter_state != FilterState::Conflicts - && this.has_conflict(index) - { - base_button_style(index, IconName::Warning) - .icon_color(Color::Warning) - .tooltip(|window, cx| { - Tooltip::with_meta( - "View conflicts", - Some(&ToggleConflictFilter), - "Use alt+click to show all conflicts", - window, - cx, - ) - }) - .on_click(cx.listener( - move |this, click: &ClickEvent, window, cx| { - if click.modifiers().alt { - this.set_filter_state( - FilterState::Conflicts, - cx, - ); - } else { - this.select_index(index, None, window, cx); - this.open_edit_keybinding_modal( - false, window, cx, - ); - cx.stop_propagation(); - } - }, - )) - .into_any_element() - } else { - base_button_style(index, IconName::Pencil) - .visible_on_hover( - if this.selected_index == Some(index) { - "".into() - } else if this.show_hover_menus { - row_group_id(index) - } else { - "never-show".into() - }, - ) - .when( - this.show_hover_menus && !context_menu_deployed, - |this| { - this.tooltip(Tooltip::for_action_title( - "Edit Keybinding", - &EditBinding, - )) - }, - ) - .on_click(cx.listener(move |this, _, window, cx| { - this.select_index(index, None, window, cx); - this.open_edit_keybinding_modal(false, window, cx); - cx.stop_propagation(); - })) - .into_any_element() - }; + let icon = this.create_row_button(index, conflict, cx); let action = div() .id(("keymap action", index)) .child({ if action_name != gpui::NoAction.name() { binding - .humanized_action_name + .action() + .humanized_name .clone() .into_any_element() } else { @@ -1534,11 +1725,14 @@ impl Render for KeymapEditor { } }) .when( - !context_menu_deployed && this.show_hover_menus, + !context_menu_deployed + && this.show_hover_menus + && !is_overridden, |this| { this.tooltip({ - let action_name = binding.action_name; - let action_docs = binding.action_docs; + let action_name = binding.action().name; + let action_docs = + binding.action().documentation; move |_, cx| { let action_tooltip = Tooltip::new(action_name); @@ -1552,14 +1746,19 @@ impl Render for KeymapEditor { }, ) .into_any_element(); - let keystrokes = binding.ui_key_binding.clone().map_or( - binding.keystroke_text.clone().into_any_element(), + let keystrokes = binding.ui_key_binding().cloned().map_or( + binding + .keystroke_text() + .cloned() + .unwrap_or_default() + .into_any_element(), IntoElement::into_any_element, ); - let action_arguments = match binding.action_arguments.clone() { + let action_arguments = match binding.action().arguments.clone() + { Some(arguments) => arguments.into_any_element(), None => { - if binding.has_schema { + if binding.action().has_schema { muted_styled_text(NO_ACTION_ARGUMENTS_TEXT, cx) .into_any_element() } else { @@ -1567,7 +1766,7 @@ impl Render for KeymapEditor { } } }; - let context = binding.context.clone().map_or( + let context = binding.context().cloned().map_or( gpui::Empty.into_any_element(), |context| { let is_local = context.local().is_some(); @@ -1578,6 +1777,7 @@ impl Render for KeymapEditor { .when( is_local && !context_menu_deployed + && !is_overridden && this.show_hover_menus, |this| { this.tooltip(Tooltip::element({ @@ -1591,13 +1791,12 @@ impl Render for KeymapEditor { }, ); let source = binding - .source - .clone() - .map(|(_source, name)| name) + .keybind_source() + .map(|source| source.name()) .unwrap_or_default() .into_any_element(); Some([ - icon, + icon.into_any_element(), action, action_arguments, keystrokes, @@ -1610,51 +1809,90 @@ impl Render for KeymapEditor { ) .map_row(cx.processor( |this, (row_index, row): (usize, Stateful
), _window, cx| { - let is_conflict = this.has_conflict(row_index); + let conflict = this.get_conflict(row_index); let is_selected = this.selected_index == Some(row_index); let row_id = row_group_id(row_index); - let row = row - .on_any_mouse_down(cx.listener( - move |this, - mouse_down_event: &gpui::MouseDownEvent, - window, - cx| { - match mouse_down_event.button { - MouseButton::Right => { + div() + .id(("keymap-row-wrapper", row_index)) + .child( + row.id(row_id.clone()) + .on_any_mouse_down(cx.listener( + move |this, + mouse_down_event: &gpui::MouseDownEvent, + window, + cx| { + match mouse_down_event.button { + MouseButton::Right => { + this.select_index( + row_index, None, window, cx, + ); + this.create_context_menu( + mouse_down_event.position, + window, + cx, + ); + } + _ => {} + } + }, + )) + .on_click(cx.listener( + move |this, event: &ClickEvent, window, cx| { this.select_index(row_index, None, window, cx); - this.create_context_menu( - mouse_down_event.position, - window, - cx, - ); - } - _ => {} - } - }, - )) - .on_click(cx.listener( - move |this, event: &ClickEvent, window, cx| { - this.select_index(row_index, None, window, cx); - if event.up.click_count == 2 { - this.open_edit_keybinding_modal(false, window, cx); - } - }, - )) - .group(row_id) + if event.up.click_count == 2 { + this.open_edit_keybinding_modal( + false, window, cx, + ); + } + }, + )) + .group(row_id) + .when( + conflict.is_some_and(|conflict| { + !conflict.is_user_keybind_conflict() + }), + |row| { + const OVERRIDDEN_OPACITY: f32 = 0.5; + row.opacity(OVERRIDDEN_OPACITY) + }, + ) + .when_some( + conflict.filter(|conflict| { + !this.context_menu_deployed() && + !conflict.is_user_keybind_conflict() + }), + |row, conflict| { + let overriding_binding = this.keybindings.get(conflict.index); + let context = overriding_binding.and_then(|binding| { + match conflict.override_source { + KeybindSource::User => Some("your keymap"), + KeybindSource::Vim => Some("the vim keymap"), + KeybindSource::Base => Some("your base keymap"), + _ => { + log::error!("Unexpected override from the {} keymap", conflict.override_source.name()); + None + } + }.map(|source| format!("This keybinding is overridden by the '{}' binding from {}.", binding.action().humanized_name, source)) + }).unwrap_or_else(|| "This binding is overridden.".to_string()); + + row.tooltip(Tooltip::text(context))}, + ), + ) .border_2() - .when(is_conflict, |row| { - row.bg(cx.theme().status().error_background) - }) + .when( + conflict.is_some_and(|conflict| { + conflict.is_user_keybind_conflict() + }), + |row| row.bg(cx.theme().status().error_background), + ) .when(is_selected, |row| { row.border_color(cx.theme().colors().panel_focused_border) - .border_2() - }); - - row.into_any_element() - }, - )), + }) + .into_any_element() + }), + ), ) .on_scroll_wheel(cx.listener(|this, event: &ScrollWheelEvent, _, cx| { // This ensures that the menu is not dismissed in cases where scroll events @@ -1762,7 +2000,7 @@ impl InputError { struct KeybindingEditorModal { creating: bool, - editing_keybind: ProcessedKeybinding, + editing_keybind: ProcessedBinding, editing_keybind_idx: usize, keybind_editor: Entity, context_editor: Entity, @@ -1787,7 +2025,7 @@ impl Focusable for KeybindingEditorModal { impl KeybindingEditorModal { pub fn new( create: bool, - editing_keybind: ProcessedKeybinding, + editing_keybind: ProcessedBinding, editing_keybind_idx: usize, keymap_editor: Entity, action_args_temp_dir: Option<&std::path::Path>, @@ -1805,8 +2043,7 @@ impl KeybindingEditorModal { .label_size(LabelSize::Default); if let Some(context) = editing_keybind - .context - .as_ref() + .context() .and_then(KeybindContextString::local) { input.editor().update(cx, |editor, cx| { @@ -1840,14 +2077,15 @@ impl KeybindingEditorModal { input }); - let action_arguments_editor = editing_keybind.has_schema.then(|| { + let action_arguments_editor = editing_keybind.action().has_schema.then(|| { let arguments = editing_keybind - .action_arguments + .action() + .arguments .as_ref() .map(|args| args.text.clone()); cx.new(|cx| { ActionArgumentsEditor::new( - editing_keybind.action_name, + editing_keybind.action().name, arguments, action_args_temp_dir, workspace.clone(), @@ -1905,7 +2143,7 @@ impl KeybindingEditorModal { }) .transpose()?; - cx.build_action(&self.editing_keybind.action_name, value) + cx.build_action(&self.editing_keybind.action().name, value) .context("Failed to validate action arguments")?; Ok(action_arguments) } @@ -1956,17 +2194,14 @@ impl KeybindingEditorModal { context: new_context.map(SharedString::from), }; - let conflicting_indices = if self.creating { - self.keymap_editor - .read(cx) - .keybinding_conflict_state - .will_conflict(&action_mapping) - } else { - self.keymap_editor - .read(cx) - .keybinding_conflict_state - .conflicting_indices_for_mapping(&action_mapping, self.editing_keybind_idx) - }; + let conflicting_indices = self + .keymap_editor + .read(cx) + .keybinding_conflict_state + .conflicting_indices_for_mapping( + &action_mapping, + self.creating.not().then_some(self.editing_keybind_idx), + ); conflicting_indices.map(|KeybindConflict { first_conflict_index, @@ -1978,7 +2213,7 @@ impl KeybindingEditorModal { .read(cx) .keybindings .get(first_conflict_index) - .map(|keybind| keybind.action_name); + .map(|keybind| keybind.action().name); let warning_message = match conflicting_action_name { Some(name) => { @@ -2013,7 +2248,7 @@ impl KeybindingEditorModal { let status_toast = StatusToast::new( format!( "Saved edits to the {} action.", - &self.editing_keybind.humanized_action_name + &self.editing_keybind.action().humanized_name ), cx, move |this, _cx| { @@ -2030,7 +2265,7 @@ impl KeybindingEditorModal { .log_err(); cx.spawn(async move |this, cx| { - let action_name = existing_keybind.action_name; + let action_name = existing_keybind.action().name; if let Err(err) = save_keybinding_update( create, @@ -2127,13 +2362,18 @@ impl Render for KeybindingEditorModal { .border_b_1() .border_color(theme.border_variant) .child(Label::new( - self.editing_keybind.humanized_action_name.clone(), + self.editing_keybind.action().humanized_name.clone(), )) - .when_some(self.editing_keybind.action_docs, |this, docs| { - this.child( - Label::new(docs).size(LabelSize::Small).color(Color::Muted), - ) - }), + .when_some( + self.editing_keybind.action().documentation, + |this, docs| { + this.child( + Label::new(docs) + .size(LabelSize::Small) + .color(Color::Muted), + ) + }, + ), ), ) .section( @@ -2296,14 +2536,32 @@ impl ActionArgumentsEditor { ) })?; - let file_name = project::lsp_store::json_language_server_ext::normalized_action_file_name(action_name); + let file_name = + project::lsp_store::json_language_server_ext::normalized_action_file_name( + action_name, + ); - let (buffer, backup_temp_dir) = Self::create_temp_buffer(temp_dir, file_name.clone(), project.clone(), fs, cx).await.context("Failed to create temporary buffer for action arguments. Auto-complete will not work") - ?; + let (buffer, backup_temp_dir) = + Self::create_temp_buffer(temp_dir, file_name.clone(), project.clone(), fs, cx) + .await + .context(concat!( + "Failed to create temporary buffer for action arguments. ", + "Auto-complete will not work" + ))?; let editor = cx.new_window_entity(|window, cx| { let multi_buffer = cx.new(|cx| editor::MultiBuffer::singleton(buffer, cx)); - let mut editor = Editor::new(editor::EditorMode::Full { scale_ui_elements_with_buffer_font_size: true, show_active_line_background: false, sized_by_content: true },multi_buffer, project.upgrade(), window, cx); + let mut editor = Editor::new( + editor::EditorMode::Full { + scale_ui_elements_with_buffer_font_size: true, + show_active_line_background: false, + sized_by_content: true, + }, + multi_buffer, + project.upgrade(), + window, + cx, + ); editor.set_searchable(false); editor.disable_scrollbars_and_minimap(window, cx); editor.set_show_edit_predictions(Some(false), window, cx); @@ -2322,7 +2580,8 @@ impl ActionArgumentsEditor { })?; anyhow::Ok(()) - }.await; + } + .await; if result.is_err() { let json_language = load_json_language(workspace.clone(), cx).await; this.update(cx, |this, cx| { @@ -2334,10 +2593,12 @@ impl ActionArgumentsEditor { } }) // .context("Failed to load JSON language for editing keybinding action arguments input") - }).ok(); + }) + .ok(); this.update(cx, |this, _cx| { this.is_loading = false; - }).ok(); + }) + .ok(); } return result; }) @@ -2582,7 +2843,7 @@ async fn load_keybind_context_language( async fn save_keybinding_update( create: bool, - existing: ProcessedKeybinding, + existing: ProcessedBinding, action_mapping: &ActionMapping, new_args: Option<&str>, fs: &Arc, @@ -2593,37 +2854,31 @@ async fn save_keybinding_update( .context("Failed to load keymap file")?; let existing_keystrokes = existing.keystrokes().unwrap_or_default(); - let existing_context = existing - .context - .as_ref() - .and_then(KeybindContextString::local_str); + let existing_context = existing.context().and_then(KeybindContextString::local_str); let existing_args = existing - .action_arguments + .action() + .arguments .as_ref() .map(|args| args.text.as_ref()); let target = settings::KeybindUpdateTarget { context: existing_context, keystrokes: existing_keystrokes, - action_name: &existing.action_name, + action_name: &existing.action().name, action_arguments: existing_args, }; let source = settings::KeybindUpdateTarget { context: action_mapping.context.as_ref().map(|a| &***a), keystrokes: &action_mapping.keystrokes, - action_name: &existing.action_name, + action_name: &existing.action().name, action_arguments: new_args, }; let operation = if !create { settings::KeybindUpdateOperation::Replace { target, - target_keybind_source: existing - .source - .as_ref() - .map(|(source, _name)| *source) - .unwrap_or(KeybindSource::User), + target_keybind_source: existing.keybind_source().unwrap_or(KeybindSource::User), source, } } else { @@ -2655,7 +2910,7 @@ async fn save_keybinding_update( } async fn remove_keybinding( - existing: ProcessedKeybinding, + existing: ProcessedBinding, fs: &Arc, tab_size: usize, ) -> anyhow::Result<()> { @@ -2668,22 +2923,16 @@ async fn remove_keybinding( let operation = settings::KeybindUpdateOperation::Remove { target: settings::KeybindUpdateTarget { - context: existing - .context - .as_ref() - .and_then(KeybindContextString::local_str), + context: existing.context().and_then(KeybindContextString::local_str), keystrokes, - action_name: &existing.action_name, + action_name: &existing.action().name, action_arguments: existing - .action_arguments + .action() + .arguments .as_ref() .map(|arguments| arguments.text.as_ref()), }, - target_keybind_source: existing - .source - .as_ref() - .map(|(source, _name)| *source) - .unwrap_or(KeybindSource::User), + target_keybind_source: existing.keybind_source().unwrap_or(KeybindSource::User), }; let (new_keybinding, removed_keybinding, source) = operation.generate_telemetry(); From 986b446749e69873dd46bdb6b062464ec0169a71 Mon Sep 17 00:00:00 2001 From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com> Date: Wed, 23 Jul 2025 12:18:55 -0400 Subject: [PATCH 0156/1052] keymap ui: Resizable column follow up (#34955) I cherry picked a small fix that didn't get into the original column resizable branch PR because I turned on auto merge. Release Notes: - N/A --- crates/settings_ui/src/ui_components/table.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/crates/settings_ui/src/ui_components/table.rs b/crates/settings_ui/src/ui_components/table.rs index 70472918d2..35f2c77306 100644 --- a/crates/settings_ui/src/ui_components/table.rs +++ b/crates/settings_ui/src/ui_components/table.rs @@ -521,7 +521,7 @@ impl ColumnWidths { let mut curr_column = double_click_position + 1; let mut diff_left = diff; - while diff != 0.0 && curr_column < COLS { + while diff_left != 0.0 && curr_column < COLS { let Some(min_size) = resize_behavior[curr_column].min_size() else { curr_column += 1; continue; @@ -607,8 +607,7 @@ impl ColumnWidths { curr_column = col_idx; // Resize behavior should be improved in the future by also seeking to the right column when there's not enough space while diff_left < 0.0 { - let Some(min_size) = resize_behavior[curr_column.saturating_sub(1)].min_size() - else { + let Some(min_size) = resize_behavior[curr_column].min_size() else { if curr_column == 0 { break; } From 3b428e2ecc41185403c1e3e3a0d9de3ac2c15306 Mon Sep 17 00:00:00 2001 From: Michael Sloan Date: Wed, 23 Jul 2025 11:33:40 -0600 Subject: [PATCH 0157/1052] Remove `!menu` from `j k` binding in initial keymap examples (#34959) See https://github.com/zed-industries/zed/pull/34912#issuecomment-3108802582 Release Notes: - N/A --- assets/keymaps/initial.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/assets/keymaps/initial.json b/assets/keymaps/initial.json index ff6069a816..8e4fe59f44 100644 --- a/assets/keymaps/initial.json +++ b/assets/keymaps/initial.json @@ -13,7 +13,7 @@ } }, { - "context": "Editor && vim_mode == insert && !menu", + "context": "Editor && vim_mode == insert", "bindings": { // "j k": "vim::NormalBefore" } From fdcd86617a823b8d6cedfe84bdfd13fc4c2346c8 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Wed, 23 Jul 2025 14:33:53 -0300 Subject: [PATCH 0158/1052] ai onboarding: Add telemetry event capturing (#34960) Release Notes: - N/A Co-authored-by: Katie Geer Co-authored-by: Joseph T. Lyons --- Cargo.lock | 1 + crates/agent_ui/src/message_editor.rs | 4 +++ crates/ai_onboarding/Cargo.toml | 1 + crates/ai_onboarding/src/ai_onboarding.rs | 37 +++++++++++++++++++---- 4 files changed, 37 insertions(+), 6 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 765ae00249..8be4c9d7be 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -347,6 +347,7 @@ dependencies = [ "proto", "serde", "smallvec", + "telemetry", "ui", "workspace-hack", "zed_actions", diff --git a/crates/agent_ui/src/message_editor.rs b/crates/agent_ui/src/message_editor.rs index 7803753292..ab8ba762f4 100644 --- a/crates/agent_ui/src/message_editor.rs +++ b/crates/agent_ui/src/message_editor.rs @@ -910,6 +910,10 @@ impl MessageEditor { .on_click({ let focus_handle = focus_handle.clone(); move |_event, window, cx| { + telemetry::event!( + "Agent Message Sent", + agent = "zed", + ); focus_handle.dispatch_action( &Chat, window, cx, ); diff --git a/crates/ai_onboarding/Cargo.toml b/crates/ai_onboarding/Cargo.toml index e9208a7248..9031e14e29 100644 --- a/crates/ai_onboarding/Cargo.toml +++ b/crates/ai_onboarding/Cargo.toml @@ -22,6 +22,7 @@ language_model.workspace = true proto.workspace = true serde.workspace = true smallvec.workspace = true +telemetry.workspace = true ui.workspace = true workspace-hack.workspace = true zed_actions.workspace = true diff --git a/crates/ai_onboarding/src/ai_onboarding.rs b/crates/ai_onboarding/src/ai_onboarding.rs index e8ce22ff4e..9d32b1ee09 100644 --- a/crates/ai_onboarding/src/ai_onboarding.rs +++ b/crates/ai_onboarding/src/ai_onboarding.rs @@ -183,6 +183,7 @@ impl ZedAiOnboarding { .full_width() .style(ButtonStyle::Tinted(ui::TintColor::Accent)) .on_click(move |_, _window, cx| { + telemetry::event!("Upgrade To Pro Clicked", state = "young-account"); cx.open_url(&zed_urls::upgrade_to_zed_pro_url(cx)) }), ) @@ -210,6 +211,7 @@ impl ZedAiOnboarding { .full_width() .style(ButtonStyle::Tinted(ui::TintColor::Accent)) .on_click(move |_, _window, cx| { + telemetry::event!("Start Trial Clicked", state = "post-sign-in"); cx.open_url(&zed_urls::start_trial_url(cx)) }), ) @@ -234,7 +236,10 @@ impl ZedAiOnboarding { .icon(IconName::ArrowUpRight) .icon_color(Color::Muted) .icon_size(IconSize::XSmall) - .on_click(move |_, _window, cx| cx.open_url(&zed_urls::terms_of_service(cx))), + .on_click(move |_, _window, cx| { + telemetry::event!("Review Terms of Service Click"); + cx.open_url(&zed_urls::terms_of_service(cx)) + }), ) .child( Button::new("accept_terms", "Accept") @@ -242,7 +247,9 @@ impl ZedAiOnboarding { .style(ButtonStyle::Tinted(TintColor::Accent)) .on_click({ let callback = self.accept_terms_of_service.clone(); - move |_, window, cx| (callback)(window, cx) + move |_, window, cx| { + telemetry::event!("Accepted Terms of Service"); + (callback)(window, cx)} }), ) .into_any_element() @@ -267,7 +274,10 @@ impl ZedAiOnboarding { .style(ButtonStyle::Tinted(ui::TintColor::Accent)) .on_click({ let callback = self.sign_in.clone(); - move |_, window, cx| callback(window, cx) + move |_, window, cx| { + telemetry::event!("Start Trial Clicked", state = "pre-sign-in"); + callback(window, cx) + } }), ) .into_any_element() @@ -294,7 +304,13 @@ impl ZedAiOnboarding { IconButton::new("dismiss_onboarding", IconName::Close) .icon_size(IconSize::Small) .tooltip(Tooltip::text("Dismiss")) - .on_click(move |_, window, cx| callback(window, cx)), + .on_click(move |_, window, cx| { + telemetry::event!( + "Banner Dismissed", + source = "AI Onboarding", + ); + callback(window, cx) + }), ), ) }, @@ -331,7 +347,13 @@ impl ZedAiOnboarding { IconButton::new("dismiss_onboarding", IconName::Close) .icon_size(IconSize::Small) .tooltip(Tooltip::text("Dismiss")) - .on_click(move |_, window, cx| callback(window, cx)), + .on_click(move |_, window, cx| { + telemetry::event!( + "Banner Dismissed", + source = "AI Onboarding", + ); + callback(window, cx) + }), ), ) }, @@ -359,7 +381,10 @@ impl ZedAiOnboarding { .style(ButtonStyle::Outlined) .on_click({ let callback = self.continue_with_zed_ai.clone(); - move |_, window, cx| callback(window, cx) + move |_, window, cx| { + telemetry::event!("Banner Dismissed", source = "AI Onboarding"); + callback(window, cx) + } }), ) .into_any_element() From 56b64b1d3f60dcb15997310c85cd2454ce300d43 Mon Sep 17 00:00:00 2001 From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com> Date: Wed, 23 Jul 2025 13:45:49 -0400 Subject: [PATCH 0159/1052] keymap ui: Improve resize columns on double click (#34961) This PR splits the resize logic into separate left/right propagation methods and improve code organization around column width adjustments. It also allows resize to work for both the left and right sides as well, instead of only checking the right side for room Release Notes: - N/A *or* Added/Fixed/Improved ... --------- Co-authored-by: Ben Kunkle --- crates/settings_ui/src/ui_components/table.rs | 188 ++++++++++-------- 1 file changed, 107 insertions(+), 81 deletions(-) diff --git a/crates/settings_ui/src/ui_components/table.rs b/crates/settings_ui/src/ui_components/table.rs index 35f2c77306..69207f559b 100644 --- a/crates/settings_ui/src/ui_components/table.rs +++ b/crates/settings_ui/src/ui_components/table.rs @@ -510,39 +510,48 @@ impl ColumnWidths { ) { let bounds_width = self.cached_bounds_width; let rem_size = window.rem_size(); + let initial_sizes = + initial_sizes.map(|length| Self::get_fraction(&length, bounds_width, rem_size)); + let mut widths = self + .widths + .map(|length| Self::get_fraction(&length, bounds_width, rem_size)); - let diff = - Self::get_fraction( - &initial_sizes[double_click_position], - bounds_width, - rem_size, - ) - Self::get_fraction(&self.widths[double_click_position], bounds_width, rem_size); + let diff = initial_sizes[double_click_position] - widths[double_click_position]; - let mut curr_column = double_click_position + 1; - let mut diff_left = diff; + if diff > 0.0 { + let diff_remaining = self.propagate_resize_diff_right( + diff, + double_click_position, + &mut widths, + resize_behavior, + ); - while diff_left != 0.0 && curr_column < COLS { - let Some(min_size) = resize_behavior[curr_column].min_size() else { - curr_column += 1; - continue; - }; - - let mut curr_width = - Self::get_fraction(&self.widths[curr_column], bounds_width, rem_size) - diff_left; - - diff_left = 0.0; - if min_size > curr_width { - diff_left += min_size - curr_width; - curr_width = min_size; + if diff_remaining > 0.0 && double_click_position > 0 { + self.propagate_resize_diff_left( + -diff_remaining, + double_click_position - 1, + &mut widths, + resize_behavior, + ); } - self.widths[curr_column] = DefiniteLength::Fraction(curr_width); - curr_column += 1; - } + } else if double_click_position > 0 { + let diff_remaining = self.propagate_resize_diff_left( + diff, + double_click_position, + &mut widths, + resize_behavior, + ); - self.widths[double_click_position] = DefiniteLength::Fraction( - Self::get_fraction(&self.widths[double_click_position], bounds_width, rem_size) - + (diff - diff_left), - ); + if diff_remaining < 0.0 { + self.propagate_resize_diff_right( + -diff_remaining, + double_click_position, + &mut widths, + resize_behavior, + ); + } + } + self.widths = widths.map(DefiniteLength::Fraction); } fn on_drag_move( @@ -552,7 +561,6 @@ impl ColumnWidths { window: &mut Window, cx: &mut Context, ) { - // - [ ] Fix bugs in resize let drag_position = drag_event.event.position; let bounds = drag_event.bounds; @@ -561,13 +569,17 @@ impl ColumnWidths { let bounds_width = bounds.right() - bounds.left(); let col_idx = drag_event.drag(cx).0; - for length in self.widths[0..=col_idx].iter() { - col_position += Self::get_fraction(length, bounds_width, rem_size); + let mut widths = self + .widths + .map(|length| Self::get_fraction(&length, bounds_width, rem_size)); + + for length in widths[0..=col_idx].iter() { + col_position += length; } let mut total_length_ratio = col_position; - for length in self.widths[col_idx + 1..].iter() { - total_length_ratio += Self::get_fraction(length, bounds_width, rem_size); + for length in widths[col_idx + 1..].iter() { + total_length_ratio += length; } let drag_fraction = (drag_position.x - bounds.left()) / bounds_width; @@ -576,67 +588,81 @@ impl ColumnWidths { let is_dragging_right = diff > 0.0; - let mut diff_left = diff; + if is_dragging_right { + self.propagate_resize_diff_right(diff, col_idx, &mut widths, resize_behavior); + } else { + // Resize behavior should be improved in the future by also seeking to the right column when there's not enough space + self.propagate_resize_diff_left(diff, col_idx, &mut widths, resize_behavior); + } + self.widths = widths.map(DefiniteLength::Fraction); + } + + fn propagate_resize_diff_right( + &self, + diff: f32, + col_idx: usize, + widths: &mut [f32; COLS], + resize_behavior: &[ResizeBehavior; COLS], + ) -> f32 { + let mut diff_remaining = diff; let mut curr_column = col_idx + 1; - if is_dragging_right { - while diff_left > 0.0 && curr_column < COLS { - let Some(min_size) = resize_behavior[curr_column - 1].min_size() else { - curr_column += 1; - continue; - }; - - let mut curr_width = - Self::get_fraction(&self.widths[curr_column], bounds_width, rem_size) - - diff_left; - - diff_left = 0.0; - if min_size > curr_width { - diff_left += min_size - curr_width; - curr_width = min_size; - } - self.widths[curr_column] = DefiniteLength::Fraction(curr_width); + while diff_remaining > 0.0 && curr_column < COLS { + let Some(min_size) = resize_behavior[curr_column - 1].min_size() else { curr_column += 1; + continue; + }; + + let mut curr_width = widths[curr_column] - diff_remaining; + + diff_remaining = 0.0; + if min_size > curr_width { + diff_remaining += min_size - curr_width; + curr_width = min_size; } + widths[curr_column] = curr_width; + curr_column += 1; + } - self.widths[col_idx] = DefiniteLength::Fraction( - Self::get_fraction(&self.widths[col_idx], bounds_width, rem_size) - + (diff - diff_left), - ); - } else { - curr_column = col_idx; - // Resize behavior should be improved in the future by also seeking to the right column when there's not enough space - while diff_left < 0.0 { - let Some(min_size) = resize_behavior[curr_column].min_size() else { - if curr_column == 0 { - break; - } - curr_column -= 1; - continue; - }; + widths[col_idx] = widths[col_idx] + (diff - diff_remaining); + return diff_remaining; + } - let mut curr_width = - Self::get_fraction(&self.widths[curr_column], bounds_width, rem_size) - + diff_left; - - diff_left = 0.0; - if curr_width < min_size { - diff_left = curr_width - min_size; - curr_width = min_size - } - - self.widths[curr_column] = DefiniteLength::Fraction(curr_width); + fn propagate_resize_diff_left( + &mut self, + diff: f32, + mut curr_column: usize, + widths: &mut [f32; COLS], + resize_behavior: &[ResizeBehavior; COLS], + ) -> f32 { + let mut diff_remaining = diff; + let col_idx = curr_column; + while diff_remaining < 0.0 { + let Some(min_size) = resize_behavior[curr_column].min_size() else { if curr_column == 0 { break; } curr_column -= 1; + continue; + }; + + let mut curr_width = widths[curr_column] + diff_remaining; + + diff_remaining = 0.0; + if curr_width < min_size { + diff_remaining = curr_width - min_size; + curr_width = min_size } - self.widths[col_idx + 1] = DefiniteLength::Fraction( - Self::get_fraction(&self.widths[col_idx + 1], bounds_width, rem_size) - - (diff - diff_left), - ); + widths[curr_column] = curr_width; + if curr_column == 0 { + break; + } + curr_column -= 1; } + widths[col_idx + 1] = widths[col_idx + 1] - (diff - diff_remaining); + + return diff_remaining; } } From 5f0edd38f896a2f31971d1eb53eec944adc3a0e3 Mon Sep 17 00:00:00 2001 From: Julia Ryan Date: Wed, 23 Jul 2025 13:01:16 -0500 Subject: [PATCH 0160/1052] Add TestPanic feature flag (#34963) Now the `dev: panic` action can be run on all release channels if the user has the feature flag enabled. Release Notes: - N/A --- Cargo.lock | 1 + crates/feature_flags/src/feature_flags.rs | 5 +++++ crates/zed/Cargo.toml | 1 + crates/zed/src/zed.rs | 20 +++++++++----------- 4 files changed, 16 insertions(+), 11 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 8be4c9d7be..6ded3ce5eb 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -20211,6 +20211,7 @@ dependencies = [ "extension", "extension_host", "extensions_ui", + "feature_flags", "feedback", "file_finder", "fs", diff --git a/crates/feature_flags/src/feature_flags.rs b/crates/feature_flags/src/feature_flags.rs index da85133bb9..631bafc841 100644 --- a/crates/feature_flags/src/feature_flags.rs +++ b/crates/feature_flags/src/feature_flags.rs @@ -85,6 +85,11 @@ impl FeatureFlag for ThreadAutoCaptureFeatureFlag { false } } +pub struct PanicFeatureFlag; + +impl FeatureFlag for PanicFeatureFlag { + const NAME: &'static str = "panic"; +} pub struct JjUiFeatureFlag {} diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml index e565aba26b..1b56494145 100644 --- a/crates/zed/Cargo.toml +++ b/crates/zed/Cargo.toml @@ -56,6 +56,7 @@ env_logger.workspace = true extension.workspace = true extension_host.workspace = true extensions_ui.workspace = true +feature_flags.workspace = true feedback.workspace = true file_finder.workspace = true fs.workspace = true diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs index 24c7ab5ba2..57534c8cd5 100644 --- a/crates/zed/src/zed.rs +++ b/crates/zed/src/zed.rs @@ -19,6 +19,7 @@ use collections::VecDeque; use debugger_ui::debugger_panel::DebugPanel; use editor::ProposedChangesEditorToolbar; use editor::{Editor, MultiBuffer}; +use feature_flags::{FeatureFlagAppExt, PanicFeatureFlag}; use futures::future::Either; use futures::{StreamExt, channel::mpsc, select_biased}; use git_ui::git_panel::GitPanel; @@ -53,9 +54,12 @@ use settings::{ initial_local_debug_tasks_content, initial_project_settings_content, initial_tasks_content, update_settings_file, }; -use std::path::PathBuf; -use std::sync::atomic::{self, AtomicBool}; -use std::{borrow::Cow, path::Path, sync::Arc}; +use std::{ + borrow::Cow, + path::{Path, PathBuf}, + sync::Arc, + sync::atomic::{self, AtomicBool}, +}; use terminal_view::terminal_panel::{self, TerminalPanel}; use theme::{ActiveTheme, ThemeSettings}; use ui::{PopoverMenuHandle, prelude::*}; @@ -120,11 +124,9 @@ pub fn init(cx: &mut App) { cx.on_action(quit); cx.on_action(|_: &RestoreBanner, cx| title_bar::restore_banner(cx)); - - if ReleaseChannel::global(cx) == ReleaseChannel::Dev { - cx.on_action(test_panic); + if ReleaseChannel::global(cx) == ReleaseChannel::Dev || cx.has_flag::() { + cx.on_action(|_: &TestPanic, _| panic!("Ran the TestPanic action")); } - cx.on_action(|_: &OpenLog, cx| { with_active_or_new_workspace(cx, |workspace, window, cx| { open_log_file(workspace, window, cx); @@ -987,10 +989,6 @@ fn about( .detach(); } -fn test_panic(_: &TestPanic, _: &mut App) { - panic!("Ran the TestPanic action") -} - fn install_cli( _: &mut Workspace, _: &install_cli::Install, From a48247a313adbe084abc53455f3e34f92c78cf44 Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Wed, 23 Jul 2025 14:14:39 -0400 Subject: [PATCH 0161/1052] Bump Zed to v0.198 (#34964) Release Notes: -N/A --- Cargo.lock | 2 +- crates/zed/Cargo.toml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 6ded3ce5eb..851c658735 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -20170,7 +20170,7 @@ dependencies = [ [[package]] name = "zed" -version = "0.197.0" +version = "0.198.0" dependencies = [ "activity_indicator", "agent", diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml index 1b56494145..a864ece683 100644 --- a/crates/zed/Cargo.toml +++ b/crates/zed/Cargo.toml @@ -2,7 +2,7 @@ description = "The fast, collaborative code editor." edition.workspace = true name = "zed" -version = "0.197.0" +version = "0.198.0" publish.workspace = true license = "GPL-3.0-or-later" authors = ["Zed Team "] From 9863c8a44e2958d56313370f3c517b9c3ca0bfe0 Mon Sep 17 00:00:00 2001 From: Umesh Yadav <23421535+imumesh18@users.noreply.github.com> Date: Wed, 23 Jul 2025 23:58:05 +0530 Subject: [PATCH 0162/1052] agent_ui: Show keybindings for NewThread and NewTextThread in new thread button (#34967) I believe in this PR: #34829 we moved to context menu entry from action but the side effect of that was we also removed the Keybindings from showing it in the new thread button dropdown. This PR fixes that. cc @danilo-leal | Before | After | |--------|--------| | CleanShot 2025-07-23 at 23 36 28@2x | CleanShot 2025-07-23 at 23 37 17@2x | Release Notes: - N/A --- crates/agent_ui/src/agent_panel.rs | 167 +++++++++++++++-------------- 1 file changed, 89 insertions(+), 78 deletions(-) diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 95ce289608..6ae2f12b5e 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -1901,85 +1901,96 @@ impl AgentPanel { ) .anchor(Corner::TopRight) .with_handle(self.new_thread_menu_handle.clone()) - .menu(move |window, cx| { - let active_thread = active_thread.clone(); - Some(ContextMenu::build(window, cx, |mut menu, _window, cx| { - menu = menu - .when(cx.has_flag::(), |this| { - this.header("Zed Agent") - }) - .item( - ContextMenuEntry::new("New Thread") - .icon(IconName::NewThread) - .icon_color(Color::Muted) - .handler(move |window, cx| { - window.dispatch_action(NewThread::default().boxed_clone(), cx); - }), - ) - .item( - ContextMenuEntry::new("New Text Thread") - .icon(IconName::NewTextThread) - .icon_color(Color::Muted) - .handler(move |window, cx| { - window.dispatch_action(NewTextThread.boxed_clone(), cx); - }), - ) - .when_some(active_thread, |this, active_thread| { - let thread = active_thread.read(cx); + .menu({ + let focus_handle = focus_handle.clone(); + move |window, cx| { + let active_thread = active_thread.clone(); + Some(ContextMenu::build(window, cx, |mut menu, _window, cx| { + menu = menu + .context(focus_handle.clone()) + .when(cx.has_flag::(), |this| { + this.header("Zed Agent") + }) + .item( + ContextMenuEntry::new("New Thread") + .icon(IconName::NewThread) + .icon_color(Color::Muted) + .action(NewThread::default().boxed_clone()) + .handler(move |window, cx| { + window.dispatch_action( + NewThread::default().boxed_clone(), + cx, + ); + }), + ) + .item( + ContextMenuEntry::new("New Text Thread") + .icon(IconName::NewTextThread) + .icon_color(Color::Muted) + .action(NewTextThread.boxed_clone()) + .handler(move |window, cx| { + window.dispatch_action(NewTextThread.boxed_clone(), cx); + }), + ) + .when_some(active_thread, |this, active_thread| { + let thread = active_thread.read(cx); - if !thread.is_empty() { - let thread_id = thread.id().clone(); - this.item( - ContextMenuEntry::new("New From Summary") - .icon(IconName::NewFromSummary) - .icon_color(Color::Muted) - .handler(move |window, cx| { - window.dispatch_action( - Box::new(NewThread { - from_thread_id: Some(thread_id.clone()), - }), - cx, - ); - }), - ) - } else { - this - } - }) - .when(cx.has_flag::(), |this| { - this.separator() - .header("External Agents") - .item( - ContextMenuEntry::new("New Gemini Thread") - .icon(IconName::AiGemini) - .icon_color(Color::Muted) - .handler(move |window, cx| { - window.dispatch_action( - NewExternalAgentThread { - agent: Some(crate::ExternalAgent::Gemini), - } - .boxed_clone(), - cx, - ); - }), - ) - .item( - ContextMenuEntry::new("New Claude Code Thread") - .icon(IconName::AiClaude) - .icon_color(Color::Muted) - .handler(move |window, cx| { - window.dispatch_action( - NewExternalAgentThread { - agent: Some(crate::ExternalAgent::ClaudeCode), - } - .boxed_clone(), - cx, - ); - }), - ) - }); - menu - })) + if !thread.is_empty() { + let thread_id = thread.id().clone(); + this.item( + ContextMenuEntry::new("New From Summary") + .icon(IconName::NewFromSummary) + .icon_color(Color::Muted) + .handler(move |window, cx| { + window.dispatch_action( + Box::new(NewThread { + from_thread_id: Some(thread_id.clone()), + }), + cx, + ); + }), + ) + } else { + this + } + }) + .when(cx.has_flag::(), |this| { + this.separator() + .header("External Agents") + .item( + ContextMenuEntry::new("New Gemini Thread") + .icon(IconName::AiGemini) + .icon_color(Color::Muted) + .handler(move |window, cx| { + window.dispatch_action( + NewExternalAgentThread { + agent: Some(crate::ExternalAgent::Gemini), + } + .boxed_clone(), + cx, + ); + }), + ) + .item( + ContextMenuEntry::new("New Claude Code Thread") + .icon(IconName::AiClaude) + .icon_color(Color::Muted) + .handler(move |window, cx| { + window.dispatch_action( + NewExternalAgentThread { + agent: Some( + crate::ExternalAgent::ClaudeCode, + ), + } + .boxed_clone(), + cx, + ); + }), + ) + }); + menu + })) + } }); let agent_panel_menu = PopoverMenu::new("agent-options-menu") From be0d9eecb72678fb25eed2abc7e781f0d9e0bb2d Mon Sep 17 00:00:00 2001 From: Nicolas Rodriguez <55200060+NRodriguezcuellar@users.noreply.github.com> Date: Wed, 23 Jul 2025 20:52:44 +0200 Subject: [PATCH 0163/1052] Add collapse functionality to outline entries (#33490) partly Closes #23075 Release Notes: - Now provides collapse and enables functionality to outline entries - Add a new expand_outlines_with_depth setting to customize how deep the tree is expanded by when a file is opened part 2 is in #34164 **Visual examples** ![image](https://github.com/user-attachments/assets/5dcdb83b-6e3e-4bfd-8ef4-76ae2ce4d3e6) ![image](https://github.com/user-attachments/assets/7b786a5a-1a8c-4f34-aaa5-4a8d0afa9668) ![image](https://github.com/user-attachments/assets/1817be06-ac71-4480-8f17-0bd862e913c8) --- assets/settings/default.json | 5 +- crates/outline_panel/src/outline_panel.rs | 862 +++++++++++++++++- .../src/outline_panel_settings.rs | 8 + 3 files changed, 826 insertions(+), 49 deletions(-) diff --git a/assets/settings/default.json b/assets/settings/default.json index dab1684aef..3a7a48efc2 100644 --- a/assets/settings/default.json +++ b/assets/settings/default.json @@ -691,7 +691,10 @@ // 5. Never show the scrollbar: // "never" "show": null - } + }, + // Default depth to expand outline items in the current file. + // Set to 0 to collapse all items that have children, 1 or higher to collapse items at that depth or deeper. + "expand_outlines_with_depth": 100 }, "collaboration_panel": { // Whether to show the collaboration panel button in the status bar. diff --git a/crates/outline_panel/src/outline_panel.rs b/crates/outline_panel/src/outline_panel.rs index 12dcab9e87..50c6c2dcce 100644 --- a/crates/outline_panel/src/outline_panel.rs +++ b/crates/outline_panel/src/outline_panel.rs @@ -1,19 +1,5 @@ mod outline_panel_settings; -use std::{ - cmp, - collections::BTreeMap, - hash::Hash, - ops::Range, - path::{MAIN_SEPARATOR_STR, Path, PathBuf}, - sync::{ - Arc, OnceLock, - atomic::{self, AtomicBool}, - }, - time::Duration, - u32, -}; - use anyhow::Context as _; use collections::{BTreeSet, HashMap, HashSet, hash_map}; use db::kvp::KEY_VALUE_STORE; @@ -36,8 +22,21 @@ use gpui::{ uniform_list, }; use itertools::Itertools; -use language::{BufferId, BufferSnapshot, OffsetRangeExt, OutlineItem}; +use language::{Anchor, BufferId, BufferSnapshot, OffsetRangeExt, OutlineItem}; use menu::{Cancel, SelectFirst, SelectLast, SelectNext, SelectPrevious}; +use std::{ + cmp, + collections::BTreeMap, + hash::Hash, + ops::Range, + path::{MAIN_SEPARATOR_STR, Path, PathBuf}, + sync::{ + Arc, OnceLock, + atomic::{self, AtomicBool}, + }, + time::Duration, + u32, +}; use outline_panel_settings::{OutlinePanelDockPosition, OutlinePanelSettings, ShowIndentGuides}; use project::{File, Fs, GitEntry, GitTraversal, Project, ProjectItem}; @@ -132,6 +131,8 @@ pub struct OutlinePanel { hide_scrollbar_task: Option>, max_width_item_index: Option, preserve_selection_on_buffer_fold_toggles: HashSet, + pending_default_expansion_depth: Option, + outline_children_cache: HashMap, usize), bool>>, } #[derive(Debug)] @@ -318,12 +319,13 @@ struct CachedEntry { entry: PanelEntry, } -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +#[derive(Clone, Debug, PartialEq, Eq, Hash)] enum CollapsedEntry { Dir(WorktreeId, ProjectEntryId), File(WorktreeId, BufferId), ExternalFile(BufferId), Excerpt(BufferId, ExcerptId), + Outline(BufferId, ExcerptId, Range), } #[derive(Debug)] @@ -803,8 +805,56 @@ impl OutlinePanel { outline_panel.update_cached_entries(Some(UPDATE_DEBOUNCE), window, cx); } } else if &outline_panel_settings != new_settings { + let old_expansion_depth = outline_panel_settings.expand_outlines_with_depth; outline_panel_settings = *new_settings; - cx.notify(); + + if old_expansion_depth != new_settings.expand_outlines_with_depth { + let old_collapsed_entries = outline_panel.collapsed_entries.clone(); + outline_panel + .collapsed_entries + .retain(|entry| !matches!(entry, CollapsedEntry::Outline(..))); + + let new_depth = new_settings.expand_outlines_with_depth; + + for (buffer_id, excerpts) in &outline_panel.excerpts { + for (excerpt_id, excerpt) in excerpts { + if let ExcerptOutlines::Outlines(outlines) = &excerpt.outlines { + for outline in outlines { + if outline_panel + .outline_children_cache + .get(buffer_id) + .and_then(|children_map| { + let key = + (outline.range.clone(), outline.depth); + children_map.get(&key) + }) + .copied() + .unwrap_or(false) + && (new_depth == 0 || outline.depth >= new_depth) + { + outline_panel.collapsed_entries.insert( + CollapsedEntry::Outline( + *buffer_id, + *excerpt_id, + outline.range.clone(), + ), + ); + } + } + } + } + } + + if old_collapsed_entries != outline_panel.collapsed_entries { + outline_panel.update_cached_entries( + Some(UPDATE_DEBOUNCE), + window, + cx, + ); + } + } else { + cx.notify(); + } } }); @@ -841,6 +891,7 @@ impl OutlinePanel { updating_cached_entries: false, new_entries_for_fs_update: HashSet::default(), preserve_selection_on_buffer_fold_toggles: HashSet::default(), + pending_default_expansion_depth: None, fs_entries_update_task: Task::ready(()), cached_entries_update_task: Task::ready(()), reveal_selection_task: Task::ready(Ok(())), @@ -855,6 +906,7 @@ impl OutlinePanel { workspace_subscription, filter_update_subscription, ], + outline_children_cache: HashMap::default(), }; if let Some((item, editor)) = workspace_active_editor(workspace, cx) { outline_panel.replace_active_editor(item, editor, window, cx); @@ -1462,7 +1514,12 @@ impl OutlinePanel { PanelEntry::Outline(OutlineEntry::Excerpt(excerpt)) => { Some(CollapsedEntry::Excerpt(excerpt.buffer_id, excerpt.id)) } - PanelEntry::Search(_) | PanelEntry::Outline(..) => return, + PanelEntry::Outline(OutlineEntry::Outline(outline)) => Some(CollapsedEntry::Outline( + outline.buffer_id, + outline.excerpt_id, + outline.outline.range.clone(), + )), + PanelEntry::Search(_) => return, }; let Some(collapsed_entry) = entry_to_expand else { return; @@ -1565,7 +1622,14 @@ impl OutlinePanel { PanelEntry::Outline(OutlineEntry::Excerpt(excerpt)) => self .collapsed_entries .insert(CollapsedEntry::Excerpt(excerpt.buffer_id, excerpt.id)), - PanelEntry::Search(_) | PanelEntry::Outline(..) => false, + PanelEntry::Outline(OutlineEntry::Outline(outline)) => { + self.collapsed_entries.insert(CollapsedEntry::Outline( + outline.buffer_id, + outline.excerpt_id, + outline.outline.range.clone(), + )) + } + PanelEntry::Search(_) => false, }; if collapsed { @@ -1780,7 +1844,17 @@ impl OutlinePanel { self.collapsed_entries.insert(collapsed_entry); } } - PanelEntry::Search(_) | PanelEntry::Outline(..) => return, + PanelEntry::Outline(OutlineEntry::Outline(outline)) => { + let collapsed_entry = CollapsedEntry::Outline( + outline.buffer_id, + outline.excerpt_id, + outline.outline.range.clone(), + ); + if !self.collapsed_entries.remove(&collapsed_entry) { + self.collapsed_entries.insert(collapsed_entry); + } + } + _ => {} } active_editor.update(cx, |editor, cx| { @@ -2108,7 +2182,7 @@ impl OutlinePanel { PanelEntry::Outline(OutlineEntry::Excerpt(excerpt.clone())), item_id, depth, - Some(icon), + icon, is_active, label_element, window, @@ -2160,10 +2234,31 @@ impl OutlinePanel { _ => false, }; - let icon = if self.is_singleton_active(cx) { - None + let has_children = self + .outline_children_cache + .get(&outline.buffer_id) + .and_then(|children_map| { + let key = (outline.outline.range.clone(), outline.outline.depth); + children_map.get(&key) + }) + .copied() + .unwrap_or(false); + let is_expanded = !self.collapsed_entries.contains(&CollapsedEntry::Outline( + outline.buffer_id, + outline.excerpt_id, + outline.outline.range.clone(), + )); + + let icon = if has_children { + FileIcons::get_chevron_icon(is_expanded, cx) + .map(|icon_path| { + Icon::from_path(icon_path) + .color(entry_label_color(is_active)) + .into_any_element() + }) + .unwrap_or_else(empty_icon) } else { - Some(empty_icon()) + empty_icon() }; self.entry_element( @@ -2287,7 +2382,7 @@ impl OutlinePanel { PanelEntry::Fs(rendered_entry.clone()), item_id, depth, - Some(icon), + icon, is_active, label_element, window, @@ -2358,7 +2453,7 @@ impl OutlinePanel { PanelEntry::FoldedDirs(folded_dir.clone()), item_id, depth, - Some(icon), + icon, is_active, label_element, window, @@ -2449,7 +2544,7 @@ impl OutlinePanel { }), ElementId::from(SharedString::from(format!("search-{match_range:?}"))), depth, - None, + empty_icon(), is_active, entire_label, window, @@ -2462,7 +2557,7 @@ impl OutlinePanel { rendered_entry: PanelEntry, item_id: ElementId, depth: usize, - icon_element: Option, + icon_element: AnyElement, is_active: bool, label_element: gpui::AnyElement, window: &mut Window, @@ -2478,8 +2573,10 @@ impl OutlinePanel { if event.down.button == MouseButton::Right || event.down.first_mouse { return; } + let change_focus = event.down.click_count > 1; outline_panel.toggle_expanded(&clicked_entry, window, cx); + outline_panel.scroll_editor_to_entry( &clicked_entry, true, @@ -2495,10 +2592,11 @@ impl OutlinePanel { .indent_level(depth) .indent_step_size(px(settings.indent_size)) .toggle_state(is_active) - .when_some(icon_element, |list_item, icon_element| { - list_item.child(h_flex().child(icon_element)) - }) - .child(h_flex().h_6().child(label_element).ml_1()) + .child( + h_flex() + .child(h_flex().w(px(16.)).justify_center().child(icon_element)) + .child(h_flex().h_6().child(label_element).ml_1()), + ) .on_secondary_mouse_down(cx.listener( move |outline_panel, event: &MouseDownEvent, window, cx| { // Stop propagation to prevent the catch-all context menu for the project @@ -2940,7 +3038,12 @@ impl OutlinePanel { outline_panel.fs_entries_depth = new_depth_map; outline_panel.fs_children_count = new_children_count; outline_panel.update_non_fs_items(window, cx); - outline_panel.update_cached_entries(debounce, window, cx); + + // Only update cached entries if we don't have outlines to fetch + // If we do have outlines to fetch, let fetch_outdated_outlines handle the update + if outline_panel.excerpt_fetch_ranges(cx).is_empty() { + outline_panel.update_cached_entries(debounce, window, cx); + } cx.notify(); }) @@ -2956,6 +3059,12 @@ impl OutlinePanel { cx: &mut Context, ) { self.clear_previous(window, cx); + + let default_expansion_depth = + OutlinePanelSettings::get_global(cx).expand_outlines_with_depth; + // We'll apply the expansion depth after outlines are loaded + self.pending_default_expansion_depth = Some(default_expansion_depth); + let buffer_search_subscription = cx.subscribe_in( &new_active_editor, window, @@ -3004,6 +3113,7 @@ impl OutlinePanel { self.selected_entry = SelectedEntry::None; self.pinned = false; self.mode = ItemsDisplayMode::Outline; + self.pending_default_expansion_depth = None; } fn location_for_editor_selection( @@ -3259,25 +3369,74 @@ impl OutlinePanel { || buffer_language.as_ref() == buffer_snapshot.language_at(outline.range.start) }); - outlines + + let outlines_with_children = outlines + .windows(2) + .filter_map(|window| { + let current = &window[0]; + let next = &window[1]; + if next.depth > current.depth { + Some((current.range.clone(), current.depth)) + } else { + None + } + }) + .collect::>(); + + (outlines, outlines_with_children) }) .await; + + let (fetched_outlines, outlines_with_children) = fetched_outlines; + outline_panel .update_in(cx, |outline_panel, window, cx| { + let pending_default_depth = + outline_panel.pending_default_expansion_depth.take(); + + let debounce = + if first_update.fetch_and(false, atomic::Ordering::AcqRel) { + None + } else { + Some(UPDATE_DEBOUNCE) + }; + if let Some(excerpt) = outline_panel .excerpts .entry(buffer_id) .or_default() .get_mut(&excerpt_id) { - let debounce = if first_update - .fetch_and(false, atomic::Ordering::AcqRel) - { - None - } else { - Some(UPDATE_DEBOUNCE) - }; excerpt.outlines = ExcerptOutlines::Outlines(fetched_outlines); + + if let Some(default_depth) = pending_default_depth { + if let ExcerptOutlines::Outlines(outlines) = + &excerpt.outlines + { + outlines + .iter() + .filter(|outline| { + (default_depth == 0 + || outline.depth >= default_depth) + && outlines_with_children.contains(&( + outline.range.clone(), + outline.depth, + )) + }) + .for_each(|outline| { + outline_panel.collapsed_entries.insert( + CollapsedEntry::Outline( + buffer_id, + excerpt_id, + outline.range.clone(), + ), + ); + }); + } + } + + // Even if no outlines to check, we still need to update cached entries + // to show the outline entries that were just fetched outline_panel.update_cached_entries(debounce, window, cx); } }) @@ -4083,7 +4242,7 @@ impl OutlinePanel { } fn add_excerpt_entries( - &self, + &mut self, state: &mut GenerationState, buffer_id: BufferId, entries_to_add: &[ExcerptId], @@ -4094,6 +4253,8 @@ impl OutlinePanel { cx: &mut Context, ) { if let Some(excerpts) = self.excerpts.get(&buffer_id) { + let buffer_snapshot = self.buffer_snapshot_for_id(buffer_id, cx); + for &excerpt_id in entries_to_add { let Some(excerpt) = excerpts.get(&excerpt_id) else { continue; @@ -4123,15 +4284,84 @@ impl OutlinePanel { continue; } - for outline in excerpt.iter_outlines() { + let mut last_depth_at_level: Vec>> = vec![None; 10]; + + let all_outlines: Vec<_> = excerpt.iter_outlines().collect(); + + let mut outline_has_children = HashMap::default(); + let mut visible_outlines = Vec::new(); + let mut collapsed_state: Option<(usize, Range)> = None; + + for (i, &outline) in all_outlines.iter().enumerate() { + let has_children = all_outlines + .get(i + 1) + .map(|next| next.depth > outline.depth) + .unwrap_or(false); + + outline_has_children + .insert((outline.range.clone(), outline.depth), has_children); + + let mut should_include = true; + + if let Some((collapsed_depth, collapsed_range)) = &collapsed_state { + if outline.depth <= *collapsed_depth { + collapsed_state = None; + } else if let Some(buffer_snapshot) = buffer_snapshot.as_ref() { + let outline_start = outline.range.start; + if outline_start + .cmp(&collapsed_range.start, buffer_snapshot) + .is_ge() + && outline_start + .cmp(&collapsed_range.end, buffer_snapshot) + .is_lt() + { + should_include = false; // Skip - inside collapsed range + } else { + collapsed_state = None; + } + } + } + + // Check if this outline itself is collapsed + if should_include + && self.collapsed_entries.contains(&CollapsedEntry::Outline( + buffer_id, + excerpt_id, + outline.range.clone(), + )) + { + collapsed_state = Some((outline.depth, outline.range.clone())); + } + + if should_include { + visible_outlines.push(outline); + } + } + + self.outline_children_cache + .entry(buffer_id) + .or_default() + .extend(outline_has_children); + + for outline in visible_outlines { + let outline_entry = OutlineEntryOutline { + buffer_id, + excerpt_id, + outline: outline.clone(), + }; + + if outline.depth < last_depth_at_level.len() { + last_depth_at_level[outline.depth] = Some(outline.range.clone()); + // Clear deeper levels when we go back to a shallower depth + for d in (outline.depth + 1)..last_depth_at_level.len() { + last_depth_at_level[d] = None; + } + } + self.push_entry( state, track_matches, - PanelEntry::Outline(OutlineEntry::Outline(OutlineEntryOutline { - buffer_id, - excerpt_id, - outline: outline.clone(), - })), + PanelEntry::Outline(OutlineEntry::Outline(outline_entry)), outline_base_depth + outline.depth, cx, ); @@ -6908,4 +7138,540 @@ outline: struct OutlineEntryExcerpt multi_buffer_snapshot.text_for_range(line_start..line_end).collect::().trim().to_owned() }) } + + #[gpui::test] + async fn test_outline_keyboard_expand_collapse(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.background_executor.clone()); + fs.insert_tree( + "/test", + json!({ + "src": { + "lib.rs": indoc!(" + mod outer { + pub struct OuterStruct { + field: String, + } + impl OuterStruct { + pub fn new() -> Self { + Self { field: String::new() } + } + pub fn method(&self) { + println!(\"{}\", self.field); + } + } + mod inner { + pub fn inner_function() { + let x = 42; + println!(\"{}\", x); + } + pub struct InnerStruct { + value: i32, + } + } + } + fn main() { + let s = outer::OuterStruct::new(); + s.method(); + } + "), + } + }), + ) + .await; + + let project = Project::test(fs.clone(), ["/test".as_ref()], cx).await; + project.read_with(cx, |project, _| { + project.languages().add(Arc::new( + rust_lang() + .with_outline_query( + r#" + (struct_item + (visibility_modifier)? @context + "struct" @context + name: (_) @name) @item + (impl_item + "impl" @context + trait: (_)? @context + "for"? @context + type: (_) @context + body: (_)) @item + (function_item + (visibility_modifier)? @context + "fn" @context + name: (_) @name + parameters: (_) @context) @item + (mod_item + (visibility_modifier)? @context + "mod" @context + name: (_) @name) @item + (enum_item + (visibility_modifier)? @context + "enum" @context + name: (_) @name) @item + (field_declaration + (visibility_modifier)? @context + name: (_) @name + ":" @context + type: (_) @context) @item + "#, + ) + .unwrap(), + )) + }); + let workspace = add_outline_panel(&project, cx).await; + let cx = &mut VisualTestContext::from_window(*workspace, cx); + let outline_panel = outline_panel(&workspace, cx); + + outline_panel.update_in(cx, |outline_panel, window, cx| { + outline_panel.set_active(true, window, cx) + }); + + workspace + .update(cx, |workspace, window, cx| { + workspace.open_abs_path( + PathBuf::from("/test/src/lib.rs"), + OpenOptions { + visible: Some(OpenVisible::All), + ..Default::default() + }, + window, + cx, + ) + }) + .unwrap() + .await + .unwrap(); + + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(500)); + cx.run_until_parked(); + + // Force another update cycle to ensure outlines are fetched + outline_panel.update_in(cx, |panel, window, cx| { + panel.update_non_fs_items(window, cx); + panel.update_cached_entries(Some(UPDATE_DEBOUNCE), window, cx); + }); + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(500)); + cx.run_until_parked(); + + outline_panel.update(cx, |outline_panel, cx| { + assert_eq!( + display_entries( + &project, + &snapshot(&outline_panel, cx), + &outline_panel.cached_entries, + outline_panel.selected_entry(), + cx, + ), + indoc!( + " +outline: mod outer <==== selected + outline: pub struct OuterStruct + outline: field: String + outline: impl OuterStruct + outline: pub fn new() + outline: pub fn method(&self) + outline: mod inner + outline: pub fn inner_function() + outline: pub struct InnerStruct + outline: value: i32 +outline: fn main()" + ) + ); + }); + + let parent_outline = outline_panel + .read_with(cx, |panel, _cx| { + panel + .cached_entries + .iter() + .find_map(|entry| match &entry.entry { + PanelEntry::Outline(OutlineEntry::Outline(outline)) + if panel + .outline_children_cache + .get(&outline.buffer_id) + .and_then(|children_map| { + let key = + (outline.outline.range.clone(), outline.outline.depth); + children_map.get(&key) + }) + .copied() + .unwrap_or(false) => + { + Some(entry.entry.clone()) + } + _ => None, + }) + }) + .expect("Should find an outline with children"); + + outline_panel.update_in(cx, |panel, window, cx| { + panel.select_entry(parent_outline.clone(), true, window, cx); + panel.collapse_selected_entry(&CollapseSelectedEntry, window, cx); + }); + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100)); + cx.run_until_parked(); + + outline_panel.update(cx, |outline_panel, cx| { + assert_eq!( + display_entries( + &project, + &snapshot(&outline_panel, cx), + &outline_panel.cached_entries, + outline_panel.selected_entry(), + cx, + ), + indoc!( + " +outline: mod outer <==== selected +outline: fn main()" + ) + ); + }); + + outline_panel.update_in(cx, |panel, window, cx| { + panel.expand_selected_entry(&ExpandSelectedEntry, window, cx); + }); + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100)); + cx.run_until_parked(); + + outline_panel.update(cx, |outline_panel, cx| { + assert_eq!( + display_entries( + &project, + &snapshot(&outline_panel, cx), + &outline_panel.cached_entries, + outline_panel.selected_entry(), + cx, + ), + indoc!( + " +outline: mod outer <==== selected + outline: pub struct OuterStruct + outline: field: String + outline: impl OuterStruct + outline: pub fn new() + outline: pub fn method(&self) + outline: mod inner + outline: pub fn inner_function() + outline: pub struct InnerStruct + outline: value: i32 +outline: fn main()" + ) + ); + }); + + outline_panel.update_in(cx, |panel, window, cx| { + panel.collapsed_entries.clear(); + panel.update_cached_entries(None, window, cx); + }); + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100)); + cx.run_until_parked(); + + outline_panel.update_in(cx, |panel, window, cx| { + let outlines_with_children: Vec<_> = panel + .cached_entries + .iter() + .filter_map(|entry| match &entry.entry { + PanelEntry::Outline(OutlineEntry::Outline(outline)) + if panel + .outline_children_cache + .get(&outline.buffer_id) + .and_then(|children_map| { + let key = (outline.outline.range.clone(), outline.outline.depth); + children_map.get(&key) + }) + .copied() + .unwrap_or(false) => + { + Some(entry.entry.clone()) + } + _ => None, + }) + .collect(); + + for outline in outlines_with_children { + panel.select_entry(outline, false, window, cx); + panel.collapse_selected_entry(&CollapseSelectedEntry, window, cx); + } + }); + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100)); + cx.run_until_parked(); + + outline_panel.update(cx, |outline_panel, cx| { + assert_eq!( + display_entries( + &project, + &snapshot(&outline_panel, cx), + &outline_panel.cached_entries, + outline_panel.selected_entry(), + cx, + ), + indoc!( + " +outline: mod outer +outline: fn main()" + ) + ); + }); + + let collapsed_entries_count = + outline_panel.read_with(cx, |panel, _| panel.collapsed_entries.len()); + assert!( + collapsed_entries_count > 0, + "Should have collapsed entries tracked" + ); + } + + #[gpui::test] + async fn test_outline_click_toggle_behavior(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.background_executor.clone()); + fs.insert_tree( + "/test", + json!({ + "src": { + "main.rs": indoc!(" + struct Config { + name: String, + value: i32, + } + impl Config { + fn new(name: String) -> Self { + Self { name, value: 0 } + } + fn get_value(&self) -> i32 { + self.value + } + } + enum Status { + Active, + Inactive, + } + fn process_config(config: Config) -> Status { + if config.get_value() > 0 { + Status::Active + } else { + Status::Inactive + } + } + fn main() { + let config = Config::new(\"test\".to_string()); + let status = process_config(config); + } + "), + } + }), + ) + .await; + + let project = Project::test(fs.clone(), ["/test".as_ref()], cx).await; + project.read_with(cx, |project, _| { + project.languages().add(Arc::new( + rust_lang() + .with_outline_query( + r#" + (struct_item + (visibility_modifier)? @context + "struct" @context + name: (_) @name) @item + (impl_item + "impl" @context + trait: (_)? @context + "for"? @context + type: (_) @context + body: (_)) @item + (function_item + (visibility_modifier)? @context + "fn" @context + name: (_) @name + parameters: (_) @context) @item + (mod_item + (visibility_modifier)? @context + "mod" @context + name: (_) @name) @item + (enum_item + (visibility_modifier)? @context + "enum" @context + name: (_) @name) @item + (field_declaration + (visibility_modifier)? @context + name: (_) @name + ":" @context + type: (_) @context) @item + "#, + ) + .unwrap(), + )) + }); + + let workspace = add_outline_panel(&project, cx).await; + let cx = &mut VisualTestContext::from_window(*workspace, cx); + let outline_panel = outline_panel(&workspace, cx); + + outline_panel.update_in(cx, |outline_panel, window, cx| { + outline_panel.set_active(true, window, cx) + }); + + let _editor = workspace + .update(cx, |workspace, window, cx| { + workspace.open_abs_path( + PathBuf::from("/test/src/main.rs"), + OpenOptions { + visible: Some(OpenVisible::All), + ..Default::default() + }, + window, + cx, + ) + }) + .unwrap() + .await + .unwrap(); + + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100)); + cx.run_until_parked(); + + outline_panel.update(cx, |outline_panel, _cx| { + outline_panel.selected_entry = SelectedEntry::None; + }); + + // Check initial state - all entries should be expanded by default + outline_panel.update(cx, |outline_panel, cx| { + assert_eq!( + display_entries( + &project, + &snapshot(&outline_panel, cx), + &outline_panel.cached_entries, + outline_panel.selected_entry(), + cx, + ), + indoc!( + " +outline: struct Config + outline: name: String + outline: value: i32 +outline: impl Config + outline: fn new(name: String) + outline: fn get_value(&self) +outline: enum Status +outline: fn process_config(config: Config) +outline: fn main()" + ) + ); + }); + + outline_panel.update(cx, |outline_panel, _cx| { + outline_panel.selected_entry = SelectedEntry::None; + }); + + cx.update(|window, cx| { + outline_panel.update(cx, |outline_panel, cx| { + outline_panel.select_first(&SelectFirst, window, cx); + }); + }); + + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100)); + cx.run_until_parked(); + + outline_panel.update(cx, |outline_panel, cx| { + assert_eq!( + display_entries( + &project, + &snapshot(&outline_panel, cx), + &outline_panel.cached_entries, + outline_panel.selected_entry(), + cx, + ), + indoc!( + " +outline: struct Config <==== selected + outline: name: String + outline: value: i32 +outline: impl Config + outline: fn new(name: String) + outline: fn get_value(&self) +outline: enum Status +outline: fn process_config(config: Config) +outline: fn main()" + ) + ); + }); + + cx.update(|window, cx| { + outline_panel.update(cx, |outline_panel, cx| { + outline_panel.open_selected_entry(&OpenSelectedEntry, window, cx); + }); + }); + + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100)); + cx.run_until_parked(); + + outline_panel.update(cx, |outline_panel, cx| { + assert_eq!( + display_entries( + &project, + &snapshot(&outline_panel, cx), + &outline_panel.cached_entries, + outline_panel.selected_entry(), + cx, + ), + indoc!( + " +outline: struct Config <==== selected +outline: impl Config + outline: fn new(name: String) + outline: fn get_value(&self) +outline: enum Status +outline: fn process_config(config: Config) +outline: fn main()" + ) + ); + }); + + cx.update(|window, cx| { + outline_panel.update(cx, |outline_panel, cx| { + outline_panel.open_selected_entry(&OpenSelectedEntry, window, cx); + }); + }); + + cx.executor() + .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100)); + cx.run_until_parked(); + + outline_panel.update(cx, |outline_panel, cx| { + assert_eq!( + display_entries( + &project, + &snapshot(&outline_panel, cx), + &outline_panel.cached_entries, + outline_panel.selected_entry(), + cx, + ), + indoc!( + " +outline: struct Config <==== selected + outline: name: String + outline: value: i32 +outline: impl Config + outline: fn new(name: String) + outline: fn get_value(&self) +outline: enum Status +outline: fn process_config(config: Config) +outline: fn main()" + ) + ); + }); + } } diff --git a/crates/outline_panel/src/outline_panel_settings.rs b/crates/outline_panel/src/outline_panel_settings.rs index 6b70cb54fb..133d28b748 100644 --- a/crates/outline_panel/src/outline_panel_settings.rs +++ b/crates/outline_panel/src/outline_panel_settings.rs @@ -31,6 +31,7 @@ pub struct OutlinePanelSettings { pub auto_reveal_entries: bool, pub auto_fold_dirs: bool, pub scrollbar: ScrollbarSettings, + pub expand_outlines_with_depth: usize, } #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)] @@ -105,6 +106,13 @@ pub struct OutlinePanelSettingsContent { pub indent_guides: Option, /// Scrollbar-related settings pub scrollbar: Option, + /// Default depth to expand outline items in the current file. + /// The default depth to which outline entries are expanded on reveal. + /// - Set to 0 to collapse all items that have children + /// - Set to 1 or higher to collapse items at that depth or deeper + /// + /// Default: 100 + pub expand_outlines_with_depth: Option, } impl Settings for OutlinePanelSettings { From 50985b7d2306988c03f87a78e89376dc44f7faac Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Wed, 23 Jul 2025 16:30:21 -0400 Subject: [PATCH 0164/1052] Fix telemetry event type names (#34974) Release Notes: - N/A --- crates/ai_onboarding/src/ai_onboarding.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/ai_onboarding/src/ai_onboarding.rs b/crates/ai_onboarding/src/ai_onboarding.rs index 9d32b1ee09..f9a91503ae 100644 --- a/crates/ai_onboarding/src/ai_onboarding.rs +++ b/crates/ai_onboarding/src/ai_onboarding.rs @@ -237,7 +237,7 @@ impl ZedAiOnboarding { .icon_color(Color::Muted) .icon_size(IconSize::XSmall) .on_click(move |_, _window, cx| { - telemetry::event!("Review Terms of Service Click"); + telemetry::event!("Review Terms of Service Clicked"); cx.open_url(&zed_urls::terms_of_service(cx)) }), ) @@ -248,7 +248,7 @@ impl ZedAiOnboarding { .on_click({ let callback = self.accept_terms_of_service.clone(); move |_, window, cx| { - telemetry::event!("Accepted Terms of Service"); + telemetry::event!("Terms of Service Accepted"); (callback)(window, cx)} }), ) From edceb7284f895539fdd71533c1e59c31c4b7940e Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Wed, 23 Jul 2025 16:55:13 -0400 Subject: [PATCH 0165/1052] Redact secrets from environment in LSP Server Info (#34971) In "Server Info" view of LSP logs: - Redacts sensitive values from environment - Sorts environment by name | Before | After | | - | - | | Screenshot 2025-07-23 at 14 10 14 | image | Release Notes: - Improved display of environment variables in LSP Logs: Server Info view --- crates/lsp/src/lsp.rs | 33 ++++++++++++++++++++++++++++++--- 1 file changed, 30 insertions(+), 3 deletions(-) diff --git a/crates/lsp/src/lsp.rs b/crates/lsp/src/lsp.rs index 7dcfa61f47..a820aaf748 100644 --- a/crates/lsp/src/lsp.rs +++ b/crates/lsp/src/lsp.rs @@ -4,7 +4,7 @@ pub use lsp_types::request::*; pub use lsp_types::*; use anyhow::{Context as _, Result, anyhow}; -use collections::HashMap; +use collections::{BTreeMap, HashMap}; use futures::{ AsyncRead, AsyncWrite, Future, FutureExt, channel::oneshot::{self, Canceled}, @@ -40,7 +40,7 @@ use std::{ time::{Duration, Instant}, }; use std::{path::Path, process::Stdio}; -use util::{ConnectionResult, ResultExt, TryFutureExt}; +use util::{ConnectionResult, ResultExt, TryFutureExt, redact}; const JSON_RPC_VERSION: &str = "2.0"; const CONTENT_LEN_HEADER: &str = "Content-Length: "; @@ -62,7 +62,7 @@ pub enum IoKind { /// Represents a launchable language server. This can either be a standalone binary or the path /// to a runtime with arguments to instruct it to launch the actual language server file. -#[derive(Debug, Clone, Deserialize)] +#[derive(Clone, Deserialize)] pub struct LanguageServerBinary { pub path: PathBuf, pub arguments: Vec, @@ -1448,6 +1448,33 @@ impl fmt::Debug for LanguageServer { } } +impl fmt::Debug for LanguageServerBinary { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let mut debug = f.debug_struct("LanguageServerBinary"); + debug.field("path", &self.path); + debug.field("arguments", &self.arguments); + + if let Some(env) = &self.env { + let redacted_env: BTreeMap = env + .iter() + .map(|(key, value)| { + let redacted_value = if redact::should_redact(key) { + "REDACTED".to_string() + } else { + value.clone() + }; + (key.clone(), redacted_value) + }) + .collect(); + debug.field("env", &Some(redacted_env)); + } else { + debug.field("env", &self.env); + } + + debug.finish() + } +} + impl Drop for Subscription { fn drop(&mut self) { match self { From 8bf7dcb6131e6d40c59c03a0ddd6c53aacbe7516 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Wed, 23 Jul 2025 18:09:05 -0300 Subject: [PATCH 0166/1052] agent: Fix follow button disabled state (#34978) Release Notes: - N/A --- crates/agent_ui/src/message_editor.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/agent_ui/src/message_editor.rs b/crates/agent_ui/src/message_editor.rs index ab8ba762f4..62be5629f1 100644 --- a/crates/agent_ui/src/message_editor.rs +++ b/crates/agent_ui/src/message_editor.rs @@ -625,7 +625,7 @@ impl MessageEditor { .unwrap_or(false); IconButton::new("follow-agent", IconName::Crosshair) - .disabled(is_model_selected) + .disabled(!is_model_selected) .icon_size(IconSize::Small) .icon_color(Color::Muted) .toggle_state(following) From 7e9d6cc25c1829089918d514b85f3a419ca26dc7 Mon Sep 17 00:00:00 2001 From: Renato Lochetti Date: Wed, 23 Jul 2025 22:27:25 +0100 Subject: [PATCH 0167/1052] mistral: Add support for Mistral Devstral Medium (#34888) Mistral released their new DevstralMedium model to be used via API: https://mistral.ai/news/devstral-2507 Release Notes: - Add support for Mistral Devstral Medium --- crates/mistral/src/mistral.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/crates/mistral/src/mistral.rs b/crates/mistral/src/mistral.rs index a3a017be83..bf6ccf2883 100644 --- a/crates/mistral/src/mistral.rs +++ b/crates/mistral/src/mistral.rs @@ -58,6 +58,8 @@ pub enum Model { OpenMistralNemo, #[serde(rename = "open-codestral-mamba", alias = "open-codestral-mamba")] OpenCodestralMamba, + #[serde(rename = "devstral-medium-latest", alias = "devstral-medium-latest")] + DevstralMediumLatest, #[serde(rename = "devstral-small-latest", alias = "devstral-small-latest")] DevstralSmallLatest, #[serde(rename = "pixtral-12b-latest", alias = "pixtral-12b-latest")] @@ -91,6 +93,7 @@ impl Model { "mistral-small-latest" => Ok(Self::MistralSmallLatest), "open-mistral-nemo" => Ok(Self::OpenMistralNemo), "open-codestral-mamba" => Ok(Self::OpenCodestralMamba), + "devstral-medium-latest" => Ok(Self::DevstralMediumLatest), "devstral-small-latest" => Ok(Self::DevstralSmallLatest), "pixtral-12b-latest" => Ok(Self::Pixtral12BLatest), "pixtral-large-latest" => Ok(Self::PixtralLargeLatest), @@ -106,6 +109,7 @@ impl Model { Self::MistralSmallLatest => "mistral-small-latest", Self::OpenMistralNemo => "open-mistral-nemo", Self::OpenCodestralMamba => "open-codestral-mamba", + Self::DevstralMediumLatest => "devstral-medium-latest", Self::DevstralSmallLatest => "devstral-small-latest", Self::Pixtral12BLatest => "pixtral-12b-latest", Self::PixtralLargeLatest => "pixtral-large-latest", @@ -121,6 +125,7 @@ impl Model { Self::MistralSmallLatest => "mistral-small-latest", Self::OpenMistralNemo => "open-mistral-nemo", Self::OpenCodestralMamba => "open-codestral-mamba", + Self::DevstralMediumLatest => "devstral-medium-latest", Self::DevstralSmallLatest => "devstral-small-latest", Self::Pixtral12BLatest => "pixtral-12b-latest", Self::PixtralLargeLatest => "pixtral-large-latest", @@ -138,6 +143,7 @@ impl Model { Self::MistralSmallLatest => 32000, Self::OpenMistralNemo => 131000, Self::OpenCodestralMamba => 256000, + Self::DevstralMediumLatest => 128000, Self::DevstralSmallLatest => 262144, Self::Pixtral12BLatest => 128000, Self::PixtralLargeLatest => 128000, @@ -162,6 +168,7 @@ impl Model { | Self::MistralSmallLatest | Self::OpenMistralNemo | Self::OpenCodestralMamba + | Self::DevstralMediumLatest | Self::DevstralSmallLatest | Self::Pixtral12BLatest | Self::PixtralLargeLatest => true, @@ -179,6 +186,7 @@ impl Model { | Self::MistralLargeLatest | Self::OpenMistralNemo | Self::OpenCodestralMamba + | Self::DevstralMediumLatest | Self::DevstralSmallLatest => false, Self::Custom { supports_images, .. From b63d820be23762f10313bce17e9c98cbba7ab9dd Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Thu, 24 Jul 2025 03:46:29 +0530 Subject: [PATCH 0168/1052] editor: Fix move line up panic when selection is at end of line next to fold marker (#34982) Closes #34826 In move line up method, make use of `prev_line_boundary` which accounts for fold map, etc., for selection start row so that we don't incorrectly calculate row range to move up. Release Notes: - Fixed an issue where `editor: move line up` action sometimes crashed if the cursor was at the end of a line beside a fold marker. --- crates/editor/src/editor.rs | 10 +++++++++- crates/editor/src/editor_tests.rs | 27 +++++++++++++++++++++++++++ 2 files changed, 36 insertions(+), 1 deletion(-) diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index d5448f30f3..a695c8fd0c 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -22258,7 +22258,7 @@ fn consume_contiguous_rows( selections: &mut Peekable>>, ) -> (MultiBufferRow, MultiBufferRow) { contiguous_row_selections.push(selection.clone()); - let start_row = MultiBufferRow(selection.start.row); + let start_row = starting_row(selection, display_map); let mut end_row = ending_row(selection, display_map); while let Some(next_selection) = selections.peek() { @@ -22272,6 +22272,14 @@ fn consume_contiguous_rows( (start_row, end_row) } +fn starting_row(selection: &Selection, display_map: &DisplaySnapshot) -> MultiBufferRow { + if selection.start.column > 0 { + MultiBufferRow(display_map.prev_line_boundary(selection.start).0.row) + } else { + MultiBufferRow(selection.start.row) + } +} + fn ending_row(next_selection: &Selection, display_map: &DisplaySnapshot) -> MultiBufferRow { if next_selection.end.column > 0 || next_selection.is_empty() { MultiBufferRow(display_map.next_line_boundary(next_selection.end).0.row + 1) diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index b9ca8c3755..0d69c067ee 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -5069,6 +5069,33 @@ fn test_move_line_up_down(cx: &mut TestAppContext) { }); } +#[gpui::test] +fn test_move_line_up_selection_at_end_of_fold(cx: &mut TestAppContext) { + init_test(cx, |_| {}); + let editor = cx.add_window(|window, cx| { + let buffer = MultiBuffer::build_simple("\n\n\n\n\n\naaaa\nbbbb\ncccc", cx); + build_editor(buffer, window, cx) + }); + _ = editor.update(cx, |editor, window, cx| { + editor.fold_creases( + vec![Crease::simple( + Point::new(6, 4)..Point::new(7, 4), + FoldPlaceholder::test(), + )], + true, + window, + cx, + ); + editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| { + s.select_ranges([Point::new(7, 4)..Point::new(7, 4)]) + }); + assert_eq!(editor.display_text(cx), "\n\n\n\n\n\naaaa⋯\ncccc"); + editor.move_line_up(&MoveLineUp, window, cx); + let buffer_text = editor.buffer.read(cx).snapshot(cx).text(); + assert_eq!(buffer_text, "\n\n\n\n\naaaa\nbbbb\n\ncccc"); + }); +} + #[gpui::test] fn test_move_line_up_down_with_blocks(cx: &mut TestAppContext) { init_test(cx, |_| {}); From 3da23cc65bf8b900219b85002b5b38dca0d3b83e Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Thu, 24 Jul 2025 00:33:43 +0200 Subject: [PATCH 0169/1052] Re-land taffy 0.8.3 (#34939) Re #34938 - **chore: Bump taffy to 0.8.3** - **editor: Fix sticky multi-buffer header not extending to the full width** Release Notes: - N/A --- Cargo.lock | 9 ++++----- crates/editor/src/code_context_menus.rs | 2 +- crates/editor/src/element.rs | 1 + crates/gpui/Cargo.toml | 2 +- crates/gpui/src/taffy.rs | 26 ++++++++++++------------- 5 files changed, 20 insertions(+), 20 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 851c658735..8f791d395a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7402,9 +7402,9 @@ dependencies = [ [[package]] name = "grid" -version = "0.14.0" +version = "0.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be136d9dacc2a13cc70bb6c8f902b414fb2641f8db1314637c6b7933411a8f82" +checksum = "71b01d27060ad58be4663b9e4ac9e2d4806918e8876af8912afbddd1a91d5eaa" [[package]] name = "group" @@ -15961,13 +15961,12 @@ dependencies = [ [[package]] name = "taffy" -version = "0.5.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8b61630cba2afd2c851821add2e1bb1b7851a2436e839ab73b56558b009035e" +checksum = "7aaef0ac998e6527d6d0d5582f7e43953bb17221ac75bb8eb2fcc2db3396db1c" dependencies = [ "arrayvec", "grid", - "num-traits", "serde", "slotmap", ] diff --git a/crates/editor/src/code_context_menus.rs b/crates/editor/src/code_context_menus.rs index 9f842836ed..52446ceafc 100644 --- a/crates/editor/src/code_context_menus.rs +++ b/crates/editor/src/code_context_menus.rs @@ -844,7 +844,7 @@ impl CompletionsMenu { .with_sizing_behavior(ListSizingBehavior::Infer) .w(rems(34.)); - Popover::new().child(list).into_any_element() + Popover::new().child(div().child(list)).into_any_element() } fn render_aside( diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index 1b372a7d53..d2ee9d6b0a 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -4010,6 +4010,7 @@ impl EditorElement { let available_width = hitbox.bounds.size.width - right_margin; let mut header = v_flex() + .w_full() .relative() .child( div() diff --git a/crates/gpui/Cargo.toml b/crates/gpui/Cargo.toml index b446ea8bd8..29e81269e3 100644 --- a/crates/gpui/Cargo.toml +++ b/crates/gpui/Cargo.toml @@ -121,7 +121,7 @@ smallvec.workspace = true smol.workspace = true strum.workspace = true sum_tree.workspace = true -taffy = "=0.5.1" +taffy = "=0.8.3" thiserror.workspace = true util.workspace = true uuid.workspace = true diff --git a/crates/gpui/src/taffy.rs b/crates/gpui/src/taffy.rs index 6228a60490..f7fa54256d 100644 --- a/crates/gpui/src/taffy.rs +++ b/crates/gpui/src/taffy.rs @@ -283,7 +283,7 @@ impl ToTaffy for Length { fn to_taffy(&self, rem_size: Pixels) -> taffy::prelude::LengthPercentageAuto { match self { Length::Definite(length) => length.to_taffy(rem_size), - Length::Auto => taffy::prelude::LengthPercentageAuto::Auto, + Length::Auto => taffy::prelude::LengthPercentageAuto::auto(), } } } @@ -292,7 +292,7 @@ impl ToTaffy for Length { fn to_taffy(&self, rem_size: Pixels) -> taffy::prelude::Dimension { match self { Length::Definite(length) => length.to_taffy(rem_size), - Length::Auto => taffy::prelude::Dimension::Auto, + Length::Auto => taffy::prelude::Dimension::auto(), } } } @@ -302,14 +302,14 @@ impl ToTaffy for DefiniteLength { match self { DefiniteLength::Absolute(length) => match length { AbsoluteLength::Pixels(pixels) => { - taffy::style::LengthPercentage::Length(pixels.into()) + taffy::style::LengthPercentage::length(pixels.into()) } AbsoluteLength::Rems(rems) => { - taffy::style::LengthPercentage::Length((*rems * rem_size).into()) + taffy::style::LengthPercentage::length((*rems * rem_size).into()) } }, DefiniteLength::Fraction(fraction) => { - taffy::style::LengthPercentage::Percent(*fraction) + taffy::style::LengthPercentage::percent(*fraction) } } } @@ -320,14 +320,14 @@ impl ToTaffy for DefiniteLength { match self { DefiniteLength::Absolute(length) => match length { AbsoluteLength::Pixels(pixels) => { - taffy::style::LengthPercentageAuto::Length(pixels.into()) + taffy::style::LengthPercentageAuto::length(pixels.into()) } AbsoluteLength::Rems(rems) => { - taffy::style::LengthPercentageAuto::Length((*rems * rem_size).into()) + taffy::style::LengthPercentageAuto::length((*rems * rem_size).into()) } }, DefiniteLength::Fraction(fraction) => { - taffy::style::LengthPercentageAuto::Percent(*fraction) + taffy::style::LengthPercentageAuto::percent(*fraction) } } } @@ -337,12 +337,12 @@ impl ToTaffy for DefiniteLength { fn to_taffy(&self, rem_size: Pixels) -> taffy::style::Dimension { match self { DefiniteLength::Absolute(length) => match length { - AbsoluteLength::Pixels(pixels) => taffy::style::Dimension::Length(pixels.into()), + AbsoluteLength::Pixels(pixels) => taffy::style::Dimension::length(pixels.into()), AbsoluteLength::Rems(rems) => { - taffy::style::Dimension::Length((*rems * rem_size).into()) + taffy::style::Dimension::length((*rems * rem_size).into()) } }, - DefiniteLength::Fraction(fraction) => taffy::style::Dimension::Percent(*fraction), + DefiniteLength::Fraction(fraction) => taffy::style::Dimension::percent(*fraction), } } } @@ -350,9 +350,9 @@ impl ToTaffy for DefiniteLength { impl ToTaffy for AbsoluteLength { fn to_taffy(&self, rem_size: Pixels) -> taffy::style::LengthPercentage { match self { - AbsoluteLength::Pixels(pixels) => taffy::style::LengthPercentage::Length(pixels.into()), + AbsoluteLength::Pixels(pixels) => taffy::style::LengthPercentage::length(pixels.into()), AbsoluteLength::Rems(rems) => { - taffy::style::LengthPercentage::Length((*rems * rem_size).into()) + taffy::style::LengthPercentage::length((*rems * rem_size).into()) } } } From 4a87397d376331a4fd5189678a62269a427d714d Mon Sep 17 00:00:00 2001 From: Maksim Bondarenkov <119937608+ognevny@users.noreply.github.com> Date: Wed, 23 Jul 2025 22:53:13 +0000 Subject: [PATCH 0170/1052] livekit_client: Revert a change that broke MinGW builds (#34977) the change was made in https://github.com/zed-industries/zed/pull/34223 for unknown reason. it wasn't required actually, and the code can be safely left as before update: after this revert Zed compiles with MinGW as before Release Notes: - N/A --- crates/livekit_client/src/lib.rs | 35 +++++++++++++++++++++++++++----- 1 file changed, 30 insertions(+), 5 deletions(-) diff --git a/crates/livekit_client/src/lib.rs b/crates/livekit_client/src/lib.rs index f94181b8f8..149859fdc8 100644 --- a/crates/livekit_client/src/lib.rs +++ b/crates/livekit_client/src/lib.rs @@ -3,16 +3,41 @@ use collections::HashMap; mod remote_video_track_view; pub use remote_video_track_view::{RemoteVideoTrackView, RemoteVideoTrackViewEvent}; -#[cfg(not(any(test, feature = "test-support", target_os = "freebsd")))] +#[cfg(not(any( + test, + feature = "test-support", + all(target_os = "windows", target_env = "gnu"), + target_os = "freebsd" +)))] mod livekit_client; -#[cfg(not(any(test, feature = "test-support", target_os = "freebsd")))] +#[cfg(not(any( + test, + feature = "test-support", + all(target_os = "windows", target_env = "gnu"), + target_os = "freebsd" +)))] pub use livekit_client::*; -#[cfg(any(test, feature = "test-support", target_os = "freebsd"))] +#[cfg(any( + test, + feature = "test-support", + all(target_os = "windows", target_env = "gnu"), + target_os = "freebsd" +))] mod mock_client; -#[cfg(any(test, feature = "test-support", target_os = "freebsd"))] +#[cfg(any( + test, + feature = "test-support", + all(target_os = "windows", target_env = "gnu"), + target_os = "freebsd" +))] pub mod test; -#[cfg(any(test, feature = "test-support", target_os = "freebsd"))] +#[cfg(any( + test, + feature = "test-support", + all(target_os = "windows", target_env = "gnu"), + target_os = "freebsd" +))] pub use mock_client::*; #[derive(Debug, Clone)] From 3d4266bb8f23d6982eaa49e47c296c717287a662 Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Wed, 23 Jul 2025 19:30:00 -0400 Subject: [PATCH 0171/1052] collab: Remove `POST /billing/subscriptions/manage` endpoint (#34986) This PR removes the `POST /billing/subscriptions/manage` endpoint, as it has been moved to `cloud.zed.dev`. Release Notes: - N/A --- crates/collab/src/api/billing.rs | 272 +------------------------------ 1 file changed, 7 insertions(+), 265 deletions(-) diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs index bd7b99b3eb..9a27e22f87 100644 --- a/crates/collab/src/api/billing.rs +++ b/crates/collab/src/api/billing.rs @@ -5,16 +5,8 @@ use collections::{HashMap, HashSet}; use reqwest::StatusCode; use sea_orm::ActiveValue; use serde::{Deserialize, Serialize}; -use std::{str::FromStr, sync::Arc, time::Duration}; -use stripe::{ - BillingPortalSession, CancellationDetailsReason, CreateBillingPortalSession, - CreateBillingPortalSessionFlowData, CreateBillingPortalSessionFlowDataAfterCompletion, - CreateBillingPortalSessionFlowDataAfterCompletionRedirect, - CreateBillingPortalSessionFlowDataSubscriptionUpdateConfirm, - CreateBillingPortalSessionFlowDataSubscriptionUpdateConfirmItems, - CreateBillingPortalSessionFlowDataType, CustomerId, EventObject, EventType, ListEvents, - PaymentMethod, Subscription, SubscriptionId, SubscriptionStatus, -}; +use std::{sync::Arc, time::Duration}; +use stripe::{CancellationDetailsReason, EventObject, EventType, ListEvents, SubscriptionStatus}; use util::{ResultExt, maybe}; use zed_llm_client::LanguageModelProvider; @@ -31,7 +23,7 @@ use crate::{AppState, Error, Result}; use crate::{db::UserId, llm::db::LlmDatabase}; use crate::{ db::{ - BillingSubscriptionId, CreateBillingCustomerParams, CreateBillingSubscriptionParams, + CreateBillingCustomerParams, CreateBillingSubscriptionParams, CreateProcessedStripeEventParams, UpdateBillingCustomerParams, UpdateBillingSubscriptionParams, billing_customer, }, @@ -39,260 +31,10 @@ use crate::{ }; pub fn router() -> Router { - Router::new() - .route( - "/billing/subscriptions/manage", - post(manage_billing_subscription), - ) - .route( - "/billing/subscriptions/sync", - post(sync_billing_subscription), - ) -} - -#[derive(Debug, PartialEq, Deserialize)] -#[serde(rename_all = "snake_case")] -enum ManageSubscriptionIntent { - /// The user intends to manage their subscription. - /// - /// This will open the Stripe billing portal without putting the user in a specific flow. - ManageSubscription, - /// The user intends to update their payment method. - UpdatePaymentMethod, - /// The user intends to upgrade to Zed Pro. - UpgradeToPro, - /// The user intends to cancel their subscription. - Cancel, - /// The user intends to stop the cancellation of their subscription. - StopCancellation, -} - -#[derive(Debug, Deserialize)] -struct ManageBillingSubscriptionBody { - github_user_id: i32, - intent: ManageSubscriptionIntent, - /// The ID of the subscription to manage. - subscription_id: BillingSubscriptionId, - redirect_to: Option, -} - -#[derive(Debug, Serialize)] -struct ManageBillingSubscriptionResponse { - billing_portal_session_url: Option, -} - -/// Initiates a Stripe customer portal session for managing a billing subscription. -async fn manage_billing_subscription( - Extension(app): Extension>, - extract::Json(body): extract::Json, -) -> Result> { - let user = app - .db - .get_user_by_github_user_id(body.github_user_id) - .await? - .context("user not found")?; - - let Some(stripe_client) = app.real_stripe_client.clone() else { - log::error!("failed to retrieve Stripe client"); - Err(Error::http( - StatusCode::NOT_IMPLEMENTED, - "not supported".into(), - ))? - }; - - let Some(stripe_billing) = app.stripe_billing.clone() else { - log::error!("failed to retrieve Stripe billing object"); - Err(Error::http( - StatusCode::NOT_IMPLEMENTED, - "not supported".into(), - ))? - }; - - let customer = app - .db - .get_billing_customer_by_user_id(user.id) - .await? - .context("billing customer not found")?; - let customer_id = CustomerId::from_str(&customer.stripe_customer_id) - .context("failed to parse customer ID")?; - - let subscription = app - .db - .get_billing_subscription_by_id(body.subscription_id) - .await? - .context("subscription not found")?; - let subscription_id = SubscriptionId::from_str(&subscription.stripe_subscription_id) - .context("failed to parse subscription ID")?; - - if body.intent == ManageSubscriptionIntent::StopCancellation { - let updated_stripe_subscription = Subscription::update( - &stripe_client, - &subscription_id, - stripe::UpdateSubscription { - cancel_at_period_end: Some(false), - ..Default::default() - }, - ) - .await?; - - app.db - .update_billing_subscription( - subscription.id, - &UpdateBillingSubscriptionParams { - stripe_cancel_at: ActiveValue::set( - updated_stripe_subscription - .cancel_at - .and_then(|cancel_at| DateTime::from_timestamp(cancel_at, 0)) - .map(|time| time.naive_utc()), - ), - ..Default::default() - }, - ) - .await?; - - return Ok(Json(ManageBillingSubscriptionResponse { - billing_portal_session_url: None, - })); - } - - let flow = match body.intent { - ManageSubscriptionIntent::ManageSubscription => None, - ManageSubscriptionIntent::UpgradeToPro => { - let zed_pro_price_id: stripe::PriceId = - stripe_billing.zed_pro_price_id().await?.try_into()?; - let zed_free_price_id: stripe::PriceId = - stripe_billing.zed_free_price_id().await?.try_into()?; - - let stripe_subscription = - Subscription::retrieve(&stripe_client, &subscription_id, &[]).await?; - - let is_on_zed_pro_trial = stripe_subscription.status == SubscriptionStatus::Trialing - && stripe_subscription.items.data.iter().any(|item| { - item.price - .as_ref() - .map_or(false, |price| price.id == zed_pro_price_id) - }); - if is_on_zed_pro_trial { - let payment_methods = PaymentMethod::list( - &stripe_client, - &stripe::ListPaymentMethods { - customer: Some(stripe_subscription.customer.id()), - ..Default::default() - }, - ) - .await?; - - let has_payment_method = !payment_methods.data.is_empty(); - if !has_payment_method { - return Err(Error::http( - StatusCode::BAD_REQUEST, - "missing payment method".into(), - )); - } - - // If the user is already on a Zed Pro trial and wants to upgrade to Pro, we just need to end their trial early. - Subscription::update( - &stripe_client, - &stripe_subscription.id, - stripe::UpdateSubscription { - trial_end: Some(stripe::Scheduled::now()), - ..Default::default() - }, - ) - .await?; - - return Ok(Json(ManageBillingSubscriptionResponse { - billing_portal_session_url: None, - })); - } - - let subscription_item_to_update = stripe_subscription - .items - .data - .iter() - .find_map(|item| { - let price = item.price.as_ref()?; - - if price.id == zed_free_price_id { - Some(item.id.clone()) - } else { - None - } - }) - .context("No subscription item to update")?; - - Some(CreateBillingPortalSessionFlowData { - type_: CreateBillingPortalSessionFlowDataType::SubscriptionUpdateConfirm, - subscription_update_confirm: Some( - CreateBillingPortalSessionFlowDataSubscriptionUpdateConfirm { - subscription: subscription.stripe_subscription_id, - items: vec![ - CreateBillingPortalSessionFlowDataSubscriptionUpdateConfirmItems { - id: subscription_item_to_update.to_string(), - price: Some(zed_pro_price_id.to_string()), - quantity: Some(1), - }, - ], - discounts: None, - }, - ), - ..Default::default() - }) - } - ManageSubscriptionIntent::UpdatePaymentMethod => Some(CreateBillingPortalSessionFlowData { - type_: CreateBillingPortalSessionFlowDataType::PaymentMethodUpdate, - after_completion: Some(CreateBillingPortalSessionFlowDataAfterCompletion { - type_: stripe::CreateBillingPortalSessionFlowDataAfterCompletionType::Redirect, - redirect: Some(CreateBillingPortalSessionFlowDataAfterCompletionRedirect { - return_url: format!( - "{}{path}", - app.config.zed_dot_dev_url(), - path = body.redirect_to.unwrap_or_else(|| "/account".to_string()) - ), - }), - ..Default::default() - }), - ..Default::default() - }), - ManageSubscriptionIntent::Cancel => { - if subscription.kind == Some(SubscriptionKind::ZedFree) { - return Err(Error::http( - StatusCode::BAD_REQUEST, - "free subscription cannot be canceled".into(), - )); - } - - Some(CreateBillingPortalSessionFlowData { - type_: CreateBillingPortalSessionFlowDataType::SubscriptionCancel, - after_completion: Some(CreateBillingPortalSessionFlowDataAfterCompletion { - type_: stripe::CreateBillingPortalSessionFlowDataAfterCompletionType::Redirect, - redirect: Some(CreateBillingPortalSessionFlowDataAfterCompletionRedirect { - return_url: format!("{}/account", app.config.zed_dot_dev_url()), - }), - ..Default::default() - }), - subscription_cancel: Some( - stripe::CreateBillingPortalSessionFlowDataSubscriptionCancel { - subscription: subscription.stripe_subscription_id, - retention: None, - }, - ), - ..Default::default() - }) - } - ManageSubscriptionIntent::StopCancellation => unreachable!(), - }; - - let mut params = CreateBillingPortalSession::new(customer_id); - params.flow_data = flow; - let return_url = format!("{}/account", app.config.zed_dot_dev_url()); - params.return_url = Some(&return_url); - - let session = BillingPortalSession::create(&stripe_client, params).await?; - - Ok(Json(ManageBillingSubscriptionResponse { - billing_portal_session_url: Some(session.url), - })) + Router::new().route( + "/billing/subscriptions/sync", + post(sync_billing_subscription), + ) } #[derive(Debug, Deserialize)] From 31afda3c0c3ea326cbec7e3d99a0d334ad7d638b Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Thu, 24 Jul 2025 05:26:12 +0530 Subject: [PATCH 0172/1052] project_panel: Automatically open project panel when Rename or Duplicate is triggered from workspace (#34988) In project panel, `rename` and `duplicate` action further needs user input for editing, so if panel is closed we should open it. Release Notes: - Fixed project panel not opening when `project panel: rename` and `project panel: duplicate` actions are triggered from workspace. --- crates/project_panel/src/project_panel.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs index 44f4e8985a..b0073f294f 100644 --- a/crates/project_panel/src/project_panel.rs +++ b/crates/project_panel/src/project_panel.rs @@ -322,6 +322,7 @@ pub fn init(cx: &mut App) { }); workspace.register_action(|workspace, action: &Rename, window, cx| { + workspace.open_panel::(window, cx); if let Some(panel) = workspace.panel::(cx) { panel.update(cx, |panel, cx| { if let Some(first_marked) = panel.marked_entries.first() { @@ -335,6 +336,7 @@ pub fn init(cx: &mut App) { }); workspace.register_action(|workspace, action: &Duplicate, window, cx| { + workspace.open_panel::(window, cx); if let Some(panel) = workspace.panel::(cx) { panel.update(cx, |panel, cx| { panel.duplicate(action, window, cx); From 67027bb241ef1a0f4de60aace75539a60fa867c8 Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Thu, 24 Jul 2025 02:13:47 +0200 Subject: [PATCH 0173/1052] agent: Fix Zed header in settings view (#34993) Follow-up to taffy bump (#34939), fixes an issue reported by @MrSubidubi Release Notes: - N/A --- crates/agent_ui/src/agent_configuration.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/crates/agent_ui/src/agent_configuration.rs b/crates/agent_ui/src/agent_configuration.rs index 334c5ee6dc..7a160a5649 100644 --- a/crates/agent_ui/src/agent_configuration.rs +++ b/crates/agent_ui/src/agent_configuration.rs @@ -186,6 +186,7 @@ impl AgentConfiguration { }; v_flex() + .w_full() .when(is_expanded, |this| this.mb_2()) .child( div() @@ -216,6 +217,7 @@ impl AgentConfiguration { .hover(|hover| hover.bg(cx.theme().colors().element_hover)) .child( h_flex() + .w_full() .gap_2() .child( Icon::new(provider.icon()) @@ -224,6 +226,7 @@ impl AgentConfiguration { ) .child( h_flex() + .w_full() .gap_1() .child( Label::new(provider_name.clone()) @@ -307,6 +310,7 @@ impl AgentConfiguration { let providers = LanguageModelRegistry::read_global(cx).providers(); v_flex() + .w_full() .child( h_flex() .p(DynamicSpacing::Base16.rems(cx)) @@ -361,6 +365,7 @@ impl AgentConfiguration { ) .child( div() + .w_full() .pl(DynamicSpacing::Base08.rems(cx)) .pr(DynamicSpacing::Base20.rems(cx)) .children( From b93e1c736b33615e0b80a8e7fb3a294f40c70862 Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Wed, 23 Jul 2025 23:13:49 -0400 Subject: [PATCH 0174/1052] mistral: Add support for magistral-small and magistral-medium (#34983) Release Notes: - mistral: Added support for magistral-small and magistral-medium --- crates/mistral/src/mistral.rs | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/crates/mistral/src/mistral.rs b/crates/mistral/src/mistral.rs index bf6ccf2883..c466a598a0 100644 --- a/crates/mistral/src/mistral.rs +++ b/crates/mistral/src/mistral.rs @@ -48,20 +48,29 @@ pub enum Model { #[serde(rename = "codestral-latest", alias = "codestral-latest")] #[default] CodestralLatest, + #[serde(rename = "mistral-large-latest", alias = "mistral-large-latest")] MistralLargeLatest, #[serde(rename = "mistral-medium-latest", alias = "mistral-medium-latest")] MistralMediumLatest, #[serde(rename = "mistral-small-latest", alias = "mistral-small-latest")] MistralSmallLatest, + + #[serde(rename = "magistral-medium-latest", alias = "magistral-medium-latest")] + MagistralMediumLatest, + #[serde(rename = "magistral-small-latest", alias = "magistral-small-latest")] + MagistralSmallLatest, + #[serde(rename = "open-mistral-nemo", alias = "open-mistral-nemo")] OpenMistralNemo, #[serde(rename = "open-codestral-mamba", alias = "open-codestral-mamba")] OpenCodestralMamba, + #[serde(rename = "devstral-medium-latest", alias = "devstral-medium-latest")] DevstralMediumLatest, #[serde(rename = "devstral-small-latest", alias = "devstral-small-latest")] DevstralSmallLatest, + #[serde(rename = "pixtral-12b-latest", alias = "pixtral-12b-latest")] Pixtral12BLatest, #[serde(rename = "pixtral-large-latest", alias = "pixtral-large-latest")] @@ -91,6 +100,8 @@ impl Model { "mistral-large-latest" => Ok(Self::MistralLargeLatest), "mistral-medium-latest" => Ok(Self::MistralMediumLatest), "mistral-small-latest" => Ok(Self::MistralSmallLatest), + "magistral-medium-latest" => Ok(Self::MagistralMediumLatest), + "magistral-small-latest" => Ok(Self::MagistralSmallLatest), "open-mistral-nemo" => Ok(Self::OpenMistralNemo), "open-codestral-mamba" => Ok(Self::OpenCodestralMamba), "devstral-medium-latest" => Ok(Self::DevstralMediumLatest), @@ -107,6 +118,8 @@ impl Model { Self::MistralLargeLatest => "mistral-large-latest", Self::MistralMediumLatest => "mistral-medium-latest", Self::MistralSmallLatest => "mistral-small-latest", + Self::MagistralMediumLatest => "magistral-medium-latest", + Self::MagistralSmallLatest => "magistral-small-latest", Self::OpenMistralNemo => "open-mistral-nemo", Self::OpenCodestralMamba => "open-codestral-mamba", Self::DevstralMediumLatest => "devstral-medium-latest", @@ -123,6 +136,8 @@ impl Model { Self::MistralLargeLatest => "mistral-large-latest", Self::MistralMediumLatest => "mistral-medium-latest", Self::MistralSmallLatest => "mistral-small-latest", + Self::MagistralMediumLatest => "magistral-medium-latest", + Self::MagistralSmallLatest => "magistral-small-latest", Self::OpenMistralNemo => "open-mistral-nemo", Self::OpenCodestralMamba => "open-codestral-mamba", Self::DevstralMediumLatest => "devstral-medium-latest", @@ -141,6 +156,8 @@ impl Model { Self::MistralLargeLatest => 131000, Self::MistralMediumLatest => 128000, Self::MistralSmallLatest => 32000, + Self::MagistralMediumLatest => 40000, + Self::MagistralSmallLatest => 40000, Self::OpenMistralNemo => 131000, Self::OpenCodestralMamba => 256000, Self::DevstralMediumLatest => 128000, @@ -166,6 +183,8 @@ impl Model { | Self::MistralLargeLatest | Self::MistralMediumLatest | Self::MistralSmallLatest + | Self::MagistralMediumLatest + | Self::MagistralSmallLatest | Self::OpenMistralNemo | Self::OpenCodestralMamba | Self::DevstralMediumLatest @@ -184,6 +203,8 @@ impl Model { | Self::MistralSmallLatest => true, Self::CodestralLatest | Self::MistralLargeLatest + | Self::MagistralMediumLatest + | Self::MagistralSmallLatest | Self::OpenMistralNemo | Self::OpenCodestralMamba | Self::DevstralMediumLatest From c08851a85ea4e3a495cbc8cb951b06353ccfa015 Mon Sep 17 00:00:00 2001 From: versecafe <147033096+versecafe@users.noreply.github.com> Date: Wed, 23 Jul 2025 21:17:54 -0700 Subject: [PATCH 0175/1052] ollama: Add Magistral to Ollama (#35000) See also: #34983 Release Notes: - Added magistral support to ollama --- crates/ollama/src/ollama.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/crates/ollama/src/ollama.rs b/crates/ollama/src/ollama.rs index 109fea7353..62c32b4161 100644 --- a/crates/ollama/src/ollama.rs +++ b/crates/ollama/src/ollama.rs @@ -55,6 +55,7 @@ fn get_max_tokens(name: &str) -> u64 { "codellama" | "starcoder2" => 16384, "mistral" | "codestral" | "mixstral" | "llava" | "qwen2" | "qwen2.5-coder" | "dolphin-mixtral" => 32768, + "magistral" => 40000, "llama3.1" | "llama3.2" | "llama3.3" | "phi3" | "phi3.5" | "phi4" | "command-r" | "qwen3" | "gemma3" | "deepseek-coder-v2" | "deepseek-v3" | "deepseek-r1" | "yi-coder" | "devstral" => 128000, From 8b0ec287a53aa41d56232088b280a1a25cb6e74d Mon Sep 17 00:00:00 2001 From: AidanV <84053180+AidanV@users.noreply.github.com> Date: Wed, 23 Jul 2025 22:06:05 -0700 Subject: [PATCH 0176/1052] vim: Add `:norm` support (#33232) Closes #21198 Release Notes: - Adds support for `:norm` - Allows for vim and zed style modified keys specified in issue - Vim style and zed style - Differs from vim in how multi-line is handled - vim is sequential - zed is combinational (with multi-cursor) --- crates/editor/src/editor.rs | 18 +- crates/vim/src/command.rs | 195 +++++++++++++++++- crates/vim/src/insert.rs | 2 +- crates/vim/test_data/test_normal_command.json | 64 ++++++ crates/workspace/src/workspace.rs | 97 +++++---- 5 files changed, 328 insertions(+), 48 deletions(-) create mode 100644 crates/vim/test_data/test_normal_command.json diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index a695c8fd0c..069d8cffb3 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -16968,7 +16968,7 @@ impl Editor { now: Instant, window: &mut Window, cx: &mut Context, - ) { + ) -> Option { self.end_selection(window, cx); if let Some(tx_id) = self .buffer @@ -16978,7 +16978,10 @@ impl Editor { .insert_transaction(tx_id, self.selections.disjoint_anchors()); cx.emit(EditorEvent::TransactionBegun { transaction_id: tx_id, - }) + }); + Some(tx_id) + } else { + None } } @@ -17006,6 +17009,17 @@ impl Editor { } } + pub fn modify_transaction_selection_history( + &mut self, + transaction_id: TransactionId, + modify: impl FnOnce(&mut (Arc<[Selection]>, Option]>>)), + ) -> bool { + self.selection_history + .transaction_mut(transaction_id) + .map(modify) + .is_some() + } + pub fn set_mark(&mut self, _: &actions::SetMark, window: &mut Window, cx: &mut Context) { if self.selection_mark_mode { self.change_selections(SelectionEffects::no_scroll(), window, cx, |s| { diff --git a/crates/vim/src/command.rs b/crates/vim/src/command.rs index 23e04cae2c..7963db3571 100644 --- a/crates/vim/src/command.rs +++ b/crates/vim/src/command.rs @@ -6,7 +6,7 @@ use editor::{ actions::{SortLinesCaseInsensitive, SortLinesCaseSensitive}, display_map::ToDisplayPoint, }; -use gpui::{Action, App, AppContext as _, Context, Global, Window, actions}; +use gpui::{Action, App, AppContext as _, Context, Global, Keystroke, Window, actions}; use itertools::Itertools; use language::Point; use multi_buffer::MultiBufferRow; @@ -202,6 +202,7 @@ actions!( ArgumentRequired ] ); + /// Opens the specified file for editing. #[derive(Clone, PartialEq, Action)] #[action(namespace = vim, no_json, no_register)] @@ -209,6 +210,13 @@ struct VimEdit { pub filename: String, } +#[derive(Clone, PartialEq, Action)] +#[action(namespace = vim, no_json, no_register)] +struct VimNorm { + pub range: Option, + pub command: String, +} + #[derive(Debug)] struct WrappedAction(Box); @@ -447,6 +455,81 @@ pub fn register(editor: &mut Editor, cx: &mut Context) { }); }); + Vim::action(editor, cx, |vim, action: &VimNorm, window, cx| { + let keystrokes = action + .command + .chars() + .map(|c| Keystroke::parse(&c.to_string()).unwrap()) + .collect(); + vim.switch_mode(Mode::Normal, true, window, cx); + let initial_selections = vim.update_editor(window, cx, |_, editor, _, _| { + editor.selections.disjoint_anchors() + }); + if let Some(range) = &action.range { + let result = vim.update_editor(window, cx, |vim, editor, window, cx| { + let range = range.buffer_range(vim, editor, window, cx)?; + editor.change_selections( + SelectionEffects::no_scroll().nav_history(false), + window, + cx, + |s| { + s.select_ranges( + (range.start.0..=range.end.0) + .map(|line| Point::new(line, 0)..Point::new(line, 0)), + ); + }, + ); + anyhow::Ok(()) + }); + if let Some(Err(err)) = result { + log::error!("Error selecting range: {}", err); + return; + } + }; + + let Some(workspace) = vim.workspace(window) else { + return; + }; + let task = workspace.update(cx, |workspace, cx| { + workspace.send_keystrokes_impl(keystrokes, window, cx) + }); + let had_range = action.range.is_some(); + + cx.spawn_in(window, async move |vim, cx| { + task.await; + vim.update_in(cx, |vim, window, cx| { + vim.update_editor(window, cx, |_, editor, window, cx| { + if had_range { + editor.change_selections(SelectionEffects::default(), window, cx, |s| { + s.select_anchor_ranges([s.newest_anchor().range()]); + }) + } + }); + if matches!(vim.mode, Mode::Insert | Mode::Replace) { + vim.normal_before(&Default::default(), window, cx); + } else { + vim.switch_mode(Mode::Normal, true, window, cx); + } + vim.update_editor(window, cx, |_, editor, _, cx| { + if let Some(first_sel) = initial_selections { + if let Some(tx_id) = editor + .buffer() + .update(cx, |multi, cx| multi.last_transaction_id(cx)) + { + let last_sel = editor.selections.disjoint_anchors(); + editor.modify_transaction_selection_history(tx_id, |old| { + old.0 = first_sel; + old.1 = Some(last_sel); + }); + } + } + }); + }) + .ok(); + }) + .detach(); + }); + Vim::action(editor, cx, |vim, _: &CountCommand, window, cx| { let Some(workspace) = vim.workspace(window) else { return; @@ -675,14 +758,15 @@ impl VimCommand { } else { return None; }; - if !args.is_empty() { + + let action = if args.is_empty() { + action + } else { // if command does not accept args and we have args then we should do no action - if let Some(args_fn) = &self.args { - args_fn.deref()(action, args) - } else { - None - } - } else if let Some(range) = range { + self.args.as_ref()?(action, args)? + }; + + if let Some(range) = range { self.range.as_ref().and_then(|f| f(action, range)) } else { Some(action) @@ -1061,6 +1145,27 @@ fn generate_commands(_: &App) -> Vec { save_intent: Some(SaveIntent::Skip), close_pinned: true, }), + VimCommand::new( + ("norm", "al"), + VimNorm { + command: "".into(), + range: None, + }, + ) + .args(|_, args| { + Some( + VimNorm { + command: args, + range: None, + } + .boxed_clone(), + ) + }) + .range(|action, range| { + let mut action: VimNorm = action.as_any().downcast_ref::().unwrap().clone(); + action.range.replace(range.clone()); + Some(Box::new(action)) + }), VimCommand::new(("bn", "ext"), workspace::ActivateNextItem).count(), VimCommand::new(("bN", "ext"), workspace::ActivatePreviousItem).count(), VimCommand::new(("bp", "revious"), workspace::ActivatePreviousItem).count(), @@ -2298,4 +2403,78 @@ mod test { }); assert!(mark.is_none()) } + + #[gpui::test] + async fn test_normal_command(cx: &mut TestAppContext) { + let mut cx = NeovimBackedTestContext::new(cx).await; + + cx.set_shared_state(indoc! {" + The quick + brown« fox + jumpsˇ» over + the lazy dog + "}) + .await; + + cx.simulate_shared_keystrokes(": n o r m space w C w o r d") + .await; + cx.simulate_shared_keystrokes("enter").await; + + cx.shared_state().await.assert_eq(indoc! {" + The quick + brown word + jumps worˇd + the lazy dog + "}); + + cx.simulate_shared_keystrokes(": n o r m space _ w c i w t e s t") + .await; + cx.simulate_shared_keystrokes("enter").await; + + cx.shared_state().await.assert_eq(indoc! {" + The quick + brown word + jumps tesˇt + the lazy dog + "}); + + cx.simulate_shared_keystrokes("_ l v l : n o r m space s l a") + .await; + cx.simulate_shared_keystrokes("enter").await; + + cx.shared_state().await.assert_eq(indoc! {" + The quick + brown word + lˇaumps test + the lazy dog + "}); + + cx.set_shared_state(indoc! {" + ˇThe quick + brown fox + jumps over + the lazy dog + "}) + .await; + + cx.simulate_shared_keystrokes("c i w M y escape").await; + + cx.shared_state().await.assert_eq(indoc! {" + Mˇy quick + brown fox + jumps over + the lazy dog + "}); + + cx.simulate_shared_keystrokes(": n o r m space u").await; + cx.simulate_shared_keystrokes("enter").await; + + cx.shared_state().await.assert_eq(indoc! {" + ˇThe quick + brown fox + jumps over + the lazy dog + "}); + // Once ctrl-v to input character literals is added there should be a test for redo + } } diff --git a/crates/vim/src/insert.rs b/crates/vim/src/insert.rs index 89c60adee7..0a370e16ba 100644 --- a/crates/vim/src/insert.rs +++ b/crates/vim/src/insert.rs @@ -21,7 +21,7 @@ pub fn register(editor: &mut Editor, cx: &mut Context) { } impl Vim { - fn normal_before( + pub(crate) fn normal_before( &mut self, action: &NormalBefore, window: &mut Window, diff --git a/crates/vim/test_data/test_normal_command.json b/crates/vim/test_data/test_normal_command.json new file mode 100644 index 0000000000..efd1d532c4 --- /dev/null +++ b/crates/vim/test_data/test_normal_command.json @@ -0,0 +1,64 @@ +{"Put":{"state":"The quick\nbrown« fox\njumpsˇ» over\nthe lazy dog\n"}} +{"Key":":"} +{"Key":"n"} +{"Key":"o"} +{"Key":"r"} +{"Key":"m"} +{"Key":"space"} +{"Key":"w"} +{"Key":"C"} +{"Key":"w"} +{"Key":"o"} +{"Key":"r"} +{"Key":"d"} +{"Key":"enter"} +{"Get":{"state":"The quick\nbrown word\njumps worˇd\nthe lazy dog\n","mode":"Normal"}} +{"Key":":"} +{"Key":"n"} +{"Key":"o"} +{"Key":"r"} +{"Key":"m"} +{"Key":"space"} +{"Key":"_"} +{"Key":"w"} +{"Key":"c"} +{"Key":"i"} +{"Key":"w"} +{"Key":"t"} +{"Key":"e"} +{"Key":"s"} +{"Key":"t"} +{"Key":"enter"} +{"Get":{"state":"The quick\nbrown word\njumps tesˇt\nthe lazy dog\n","mode":"Normal"}} +{"Key":"_"} +{"Key":"l"} +{"Key":"v"} +{"Key":"l"} +{"Key":":"} +{"Key":"n"} +{"Key":"o"} +{"Key":"r"} +{"Key":"m"} +{"Key":"space"} +{"Key":"s"} +{"Key":"l"} +{"Key":"a"} +{"Key":"enter"} +{"Get":{"state":"The quick\nbrown word\nlˇaumps test\nthe lazy dog\n","mode":"Normal"}} +{"Put":{"state":"ˇThe quick\nbrown fox\njumps over\nthe lazy dog\n"}} +{"Key":"c"} +{"Key":"i"} +{"Key":"w"} +{"Key":"M"} +{"Key":"y"} +{"Key":"escape"} +{"Get":{"state":"Mˇy quick\nbrown fox\njumps over\nthe lazy dog\n","mode":"Normal"}} +{"Key":":"} +{"Key":"n"} +{"Key":"o"} +{"Key":"r"} +{"Key":"m"} +{"Key":"space"} +{"Key":"u"} +{"Key":"enter"} +{"Get":{"state":"ˇThe quick\nbrown fox\njumps over\nthe lazy dog\n","mode":"Normal"}} diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index 4c70c52d5a..0ee8177dd8 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -32,7 +32,7 @@ use futures::{ mpsc::{self, UnboundedReceiver, UnboundedSender}, oneshot, }, - future::try_join_all, + future::{Shared, try_join_all}, }; use gpui::{ Action, AnyEntity, AnyView, AnyWeakView, App, AsyncApp, AsyncWindowContext, Bounds, Context, @@ -87,7 +87,7 @@ use std::{ borrow::Cow, cell::RefCell, cmp, - collections::hash_map::DefaultHasher, + collections::{VecDeque, hash_map::DefaultHasher}, env, hash::{Hash, Hasher}, path::{Path, PathBuf}, @@ -1043,6 +1043,13 @@ type PromptForOpenPath = Box< ) -> oneshot::Receiver>>, >; +#[derive(Default)] +struct DispatchingKeystrokes { + dispatched: HashSet>, + queue: VecDeque, + task: Option>>, +} + /// Collects everything project-related for a certain window opened. /// In some way, is a counterpart of a window, as the [`WindowHandle`] could be downcast into `Workspace`. /// @@ -1080,7 +1087,7 @@ pub struct Workspace { leader_updates_tx: mpsc::UnboundedSender<(PeerId, proto::UpdateFollowers)>, database_id: Option, app_state: Arc, - dispatching_keystrokes: Rc, Vec)>>, + dispatching_keystrokes: Rc>, _subscriptions: Vec, _apply_leader_updates: Task>, _observe_current_user: Task>, @@ -2311,49 +2318,65 @@ impl Workspace { window: &mut Window, cx: &mut Context, ) { - let mut state = self.dispatching_keystrokes.borrow_mut(); - if !state.0.insert(action.0.clone()) { - cx.propagate(); - return; - } - let mut keystrokes: Vec = action + let keystrokes: Vec = action .0 .split(' ') .flat_map(|k| Keystroke::parse(k).log_err()) .collect(); - keystrokes.reverse(); + let _ = self.send_keystrokes_impl(keystrokes, window, cx); + } - state.1.append(&mut keystrokes); - drop(state); + pub fn send_keystrokes_impl( + &mut self, + keystrokes: Vec, + window: &mut Window, + cx: &mut Context, + ) -> Shared> { + let mut state = self.dispatching_keystrokes.borrow_mut(); + if !state.dispatched.insert(keystrokes.clone()) { + cx.propagate(); + return state.task.clone().unwrap(); + } + + state.queue.extend(keystrokes); let keystrokes = self.dispatching_keystrokes.clone(); - window - .spawn(cx, async move |cx| { - // limit to 100 keystrokes to avoid infinite recursion. - for _ in 0..100 { - let Some(keystroke) = keystrokes.borrow_mut().1.pop() else { - keystrokes.borrow_mut().0.clear(); - return Ok(()); - }; - cx.update(|window, cx| { - let focused = window.focused(cx); - window.dispatch_keystroke(keystroke.clone(), cx); - if window.focused(cx) != focused { - // dispatch_keystroke may cause the focus to change. - // draw's side effect is to schedule the FocusChanged events in the current flush effect cycle - // And we need that to happen before the next keystroke to keep vim mode happy... - // (Note that the tests always do this implicitly, so you must manually test with something like: - // "bindings": { "g z": ["workspace::SendKeystrokes", ": j u"]} - // ) - window.draw(cx).clear(); + if state.task.is_none() { + state.task = Some( + window + .spawn(cx, async move |cx| { + // limit to 100 keystrokes to avoid infinite recursion. + for _ in 0..100 { + let mut state = keystrokes.borrow_mut(); + let Some(keystroke) = state.queue.pop_front() else { + state.dispatched.clear(); + state.task.take(); + return; + }; + drop(state); + cx.update(|window, cx| { + let focused = window.focused(cx); + window.dispatch_keystroke(keystroke.clone(), cx); + if window.focused(cx) != focused { + // dispatch_keystroke may cause the focus to change. + // draw's side effect is to schedule the FocusChanged events in the current flush effect cycle + // And we need that to happen before the next keystroke to keep vim mode happy... + // (Note that the tests always do this implicitly, so you must manually test with something like: + // "bindings": { "g z": ["workspace::SendKeystrokes", ": j u"]} + // ) + window.draw(cx).clear(); + } + }) + .ok(); } - })?; - } - *keystrokes.borrow_mut() = Default::default(); - anyhow::bail!("over 100 keystrokes passed to send_keystrokes"); - }) - .detach_and_log_err(cx); + *keystrokes.borrow_mut() = Default::default(); + log::error!("over 100 keystrokes passed to send_keystrokes"); + }) + .shared(), + ); + } + state.task.clone().unwrap() } fn save_all_internal( From a6956eebcbf87ed36fe3cc82bd204b8ae6b997f0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pablo=20Ram=C3=B3n=20Guevara?= <50140021+praguevara@users.noreply.github.com> Date: Thu, 24 Jul 2025 07:27:07 +0200 Subject: [PATCH 0177/1052] Improve Helix insert (#34765) Closes #34763 Release Notes: - Improved insert in `helix_mode` when a selection exists to better match helix's behavior: collapse selection to avoid replacing it - Improved append (`insert_after`) to better match helix's behavior: move cursor to end of selection if it exists --- assets/keymaps/vim.json | 6 ++- crates/vim/src/helix.rs | 110 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 112 insertions(+), 4 deletions(-) diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json index d0cf4621a5..6458ac1510 100644 --- a/assets/keymaps/vim.json +++ b/assets/keymaps/vim.json @@ -220,6 +220,8 @@ { "context": "vim_mode == normal", "bindings": { + "i": "vim::InsertBefore", + "a": "vim::InsertAfter", "ctrl-[": "editor::Cancel", ":": "command_palette::Toggle", "c": "vim::PushChange", @@ -353,9 +355,7 @@ "shift-d": "vim::DeleteToEndOfLine", "shift-j": "vim::JoinLines", "shift-y": "vim::YankLine", - "i": "vim::InsertBefore", "shift-i": "vim::InsertFirstNonWhitespace", - "a": "vim::InsertAfter", "shift-a": "vim::InsertEndOfLine", "o": "vim::InsertLineBelow", "shift-o": "vim::InsertLineAbove", @@ -377,6 +377,8 @@ { "context": "vim_mode == helix_normal && !menu", "bindings": { + "i": "vim::HelixInsert", + "a": "vim::HelixAppend", "ctrl-[": "editor::Cancel", ";": "vim::HelixCollapseSelection", ":": "command_palette::Toggle", diff --git a/crates/vim/src/helix.rs b/crates/vim/src/helix.rs index ec9b959b12..798af3bff3 100644 --- a/crates/vim/src/helix.rs +++ b/crates/vim/src/helix.rs @@ -4,18 +4,28 @@ use gpui::{Context, Window}; use language::{CharClassifier, CharKind}; use text::SelectionGoal; -use crate::{Vim, motion::Motion, state::Mode}; +use crate::{ + Vim, + motion::{Motion, right}, + state::Mode, +}; actions!( vim, [ /// Switches to normal mode after the cursor (Helix-style). - HelixNormalAfter + HelixNormalAfter, + /// Inserts at the beginning of the selection. + HelixInsert, + /// Appends at the end of the selection. + HelixAppend, ] ); pub fn register(editor: &mut Editor, cx: &mut Context) { Vim::action(editor, cx, Vim::helix_normal_after); + Vim::action(editor, cx, Vim::helix_insert); + Vim::action(editor, cx, Vim::helix_append); } impl Vim { @@ -299,6 +309,38 @@ impl Vim { _ => self.helix_move_and_collapse(motion, times, window, cx), } } + + fn helix_insert(&mut self, _: &HelixInsert, window: &mut Window, cx: &mut Context) { + self.start_recording(cx); + self.update_editor(window, cx, |_, editor, window, cx| { + editor.change_selections(Default::default(), window, cx, |s| { + s.move_with(|_map, selection| { + // In helix normal mode, move cursor to start of selection and collapse + if !selection.is_empty() { + selection.collapse_to(selection.start, SelectionGoal::None); + } + }); + }); + }); + self.switch_mode(Mode::Insert, false, window, cx); + } + + fn helix_append(&mut self, _: &HelixAppend, window: &mut Window, cx: &mut Context) { + self.start_recording(cx); + self.switch_mode(Mode::Insert, false, window, cx); + self.update_editor(window, cx, |_, editor, window, cx| { + editor.change_selections(Default::default(), window, cx, |s| { + s.move_with(|map, selection| { + let point = if selection.is_empty() { + right(map, selection.head(), 1) + } else { + selection.end + }; + selection.collapse_to(point, SelectionGoal::None); + }); + }); + }); + } } #[cfg(test)] @@ -497,4 +539,68 @@ mod test { cx.assert_state("«ˇaa»\n", Mode::HelixNormal); } + + #[gpui::test] + async fn test_insert_selected(cx: &mut gpui::TestAppContext) { + let mut cx = VimTestContext::new(cx, true).await; + cx.set_state( + indoc! {" + «The ˇ»quick brown + fox jumps over + the lazy dog."}, + Mode::HelixNormal, + ); + + cx.simulate_keystrokes("i"); + + cx.assert_state( + indoc! {" + ˇThe quick brown + fox jumps over + the lazy dog."}, + Mode::Insert, + ); + } + + #[gpui::test] + async fn test_append(cx: &mut gpui::TestAppContext) { + let mut cx = VimTestContext::new(cx, true).await; + // test from the end of the selection + cx.set_state( + indoc! {" + «Theˇ» quick brown + fox jumps over + the lazy dog."}, + Mode::HelixNormal, + ); + + cx.simulate_keystrokes("a"); + + cx.assert_state( + indoc! {" + Theˇ quick brown + fox jumps over + the lazy dog."}, + Mode::Insert, + ); + + // test from the beginning of the selection + cx.set_state( + indoc! {" + «ˇThe» quick brown + fox jumps over + the lazy dog."}, + Mode::HelixNormal, + ); + + cx.simulate_keystrokes("a"); + + cx.assert_state( + indoc! {" + Theˇ quick brown + fox jumps over + the lazy dog."}, + Mode::Insert, + ); + } } From 34bf6ebba68cdbff01dfb4b3ff3c3a9c63240c08 Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Wed, 23 Jul 2025 23:45:01 -0600 Subject: [PATCH 0178/1052] Disable auto-close in search (#35005) Currently if you type `\(`, it auto-closes to `\()` which is broken. It's arguably nice that if you type `(` it auto-closes to `()`, but I am much more likely to be looking for a function call `name\(` than to be starting a group in search. Release Notes: - search: Regex search will no longer try to close parenthesis automatically. --- crates/search/src/buffer_search.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/crates/search/src/buffer_search.rs b/crates/search/src/buffer_search.rs index c2590ec9b0..91b7fe488e 100644 --- a/crates/search/src/buffer_search.rs +++ b/crates/search/src/buffer_search.rs @@ -700,7 +700,11 @@ impl BufferSearchBar { window: &mut Window, cx: &mut Context, ) -> Self { - let query_editor = cx.new(|cx| Editor::single_line(window, cx)); + let query_editor = cx.new(|cx| { + let mut editor = Editor::single_line(window, cx); + editor.set_use_autoclose(false); + editor + }); cx.subscribe_in(&query_editor, window, Self::on_query_editor_event) .detach(); let replacement_editor = cx.new(|cx| Editor::single_line(window, cx)); From ddd50aabbad67db1174255b2ce4743794b9618d9 Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Thu, 24 Jul 2025 02:52:02 -0400 Subject: [PATCH 0179/1052] Fix some bugs with `editor: diff clipboard with selection` (#34999) Improves testing around `editor: diff clipboard with selection` as well. Release Notes: - Fixed some bugs with `editor: diff clipboard with selection` --- crates/editor/src/editor_tests.rs | 2 +- crates/git_ui/src/text_diff_view.rs | 340 +++++++++++++++++++++------- 2 files changed, 264 insertions(+), 78 deletions(-) diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index 0d69c067ee..8d121972d0 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -16864,7 +16864,7 @@ async fn test_multibuffer_reverts(cx: &mut TestAppContext) { } #[gpui::test] -async fn test_mutlibuffer_in_navigation_history(cx: &mut TestAppContext) { +async fn test_multibuffer_in_navigation_history(cx: &mut TestAppContext) { init_test(cx, |_| {}); let cols = 4; diff --git a/crates/git_ui/src/text_diff_view.rs b/crates/git_ui/src/text_diff_view.rs index e7386cf7bd..be1866a354 100644 --- a/crates/git_ui/src/text_diff_view.rs +++ b/crates/git_ui/src/text_diff_view.rs @@ -12,6 +12,7 @@ use language::{self, Buffer, Point}; use project::Project; use std::{ any::{Any, TypeId}, + cmp, ops::Range, pin::pin, sync::Arc, @@ -45,38 +46,60 @@ impl TextDiffView { ) -> Option>>> { let source_editor = diff_data.editor.clone(); - let source_editor_buffer_and_range = source_editor.update(cx, |editor, cx| { + let selection_data = source_editor.update(cx, |editor, cx| { let multibuffer = editor.buffer().read(cx); let source_buffer = multibuffer.as_singleton()?.clone(); let selections = editor.selections.all::(cx); let buffer_snapshot = source_buffer.read(cx); let first_selection = selections.first()?; - let selection_range = if first_selection.is_empty() { - Point::new(0, 0)..buffer_snapshot.max_point() - } else { - first_selection.start..first_selection.end - }; + let max_point = buffer_snapshot.max_point(); - Some((source_buffer, selection_range)) + if first_selection.is_empty() { + let full_range = Point::new(0, 0)..max_point; + return Some((source_buffer, full_range)); + } + + let start = first_selection.start; + let end = first_selection.end; + let expanded_start = Point::new(start.row, 0); + + let expanded_end = if end.column > 0 { + let next_row = end.row + 1; + cmp::min(max_point, Point::new(next_row, 0)) + } else { + end + }; + Some((source_buffer, expanded_start..expanded_end)) }); - let Some((source_buffer, selected_range)) = source_editor_buffer_and_range else { + let Some((source_buffer, expanded_selection_range)) = selection_data else { log::warn!("There should always be at least one selection in Zed. This is a bug."); return None; }; - let clipboard_text = diff_data.clipboard_text.clone(); - - let workspace = workspace.weak_handle(); - - let diff_buffer = cx.new(|cx| { - let source_buffer_snapshot = source_buffer.read(cx).snapshot(); - let diff = BufferDiff::new(&source_buffer_snapshot.text, cx); - diff + source_editor.update(cx, |source_editor, cx| { + source_editor.change_selections(Default::default(), window, cx, |s| { + s.select_ranges(vec![ + expanded_selection_range.start..expanded_selection_range.end, + ]); + }) }); - let clipboard_buffer = - build_clipboard_buffer(clipboard_text, &source_buffer, selected_range.clone(), cx); + let source_buffer_snapshot = source_buffer.read(cx).snapshot(); + let mut clipboard_text = diff_data.clipboard_text.clone(); + + if !clipboard_text.ends_with("\n") { + clipboard_text.push_str("\n"); + } + + let workspace = workspace.weak_handle(); + let diff_buffer = cx.new(|cx| BufferDiff::new(&source_buffer_snapshot.text, cx)); + let clipboard_buffer = build_clipboard_buffer( + clipboard_text, + &source_buffer, + expanded_selection_range.clone(), + cx, + ); let task = window.spawn(cx, async move |cx| { let project = workspace.update(cx, |workspace, _| workspace.project().clone())?; @@ -89,7 +112,7 @@ impl TextDiffView { clipboard_buffer, source_editor, source_buffer, - selected_range, + expanded_selection_range, diff_buffer, project, window, @@ -208,9 +231,9 @@ impl TextDiffView { } fn build_clipboard_buffer( - clipboard_text: String, + text: String, source_buffer: &Entity, - selected_range: Range, + replacement_range: Range, cx: &mut App, ) -> Entity { let source_buffer_snapshot = source_buffer.read(cx).snapshot(); @@ -219,9 +242,9 @@ fn build_clipboard_buffer( let language = source_buffer.read(cx).language().cloned(); buffer.set_language(language, cx); - let range_start = source_buffer_snapshot.point_to_offset(selected_range.start); - let range_end = source_buffer_snapshot.point_to_offset(selected_range.end); - buffer.edit([(range_start..range_end, clipboard_text)], None, cx); + let range_start = source_buffer_snapshot.point_to_offset(replacement_range.start); + let range_end = source_buffer_snapshot.point_to_offset(replacement_range.end); + buffer.edit([(range_start..range_end, text)], None, cx); buffer }) @@ -395,21 +418,13 @@ pub fn selection_location_text(editor: &Editor, cx: &App) -> Option { let buffer_snapshot = buffer.snapshot(cx); let first_selection = editor.selections.disjoint.first()?; - let (start_row, start_column, end_row, end_column) = - if first_selection.start == first_selection.end { - let max_point = buffer_snapshot.max_point(); - (0, 0, max_point.row, max_point.column) - } else { - let selection_start = first_selection.start.to_point(&buffer_snapshot); - let selection_end = first_selection.end.to_point(&buffer_snapshot); + let selection_start = first_selection.start.to_point(&buffer_snapshot); + let selection_end = first_selection.end.to_point(&buffer_snapshot); - ( - selection_start.row, - selection_start.column, - selection_end.row, - selection_end.column, - ) - }; + let start_row = selection_start.row; + let start_column = selection_start.column; + let end_row = selection_end.row; + let end_column = selection_end.column; let range_text = if start_row == end_row { format!("L{}:{}-{}", start_row + 1, start_column + 1, end_column + 1) @@ -435,14 +450,13 @@ impl Render for TextDiffView { #[cfg(test)] mod tests { use super::*; - - use editor::{actions, test::editor_test_context::assert_state_with_diff}; + use editor::test::editor_test_context::assert_state_with_diff; use gpui::{TestAppContext, VisualContext}; use project::{FakeFs, Project}; use serde_json::json; use settings::{Settings, SettingsStore}; use unindent::unindent; - use util::path; + use util::{path, test::marked_text_ranges}; fn init_test(cx: &mut TestAppContext) { cx.update(|cx| { @@ -457,52 +471,236 @@ mod tests { } #[gpui::test] - async fn test_diffing_clipboard_against_specific_selection(cx: &mut TestAppContext) { - base_test(true, cx).await; + async fn test_diffing_clipboard_against_empty_selection_uses_full_buffer_selection( + cx: &mut TestAppContext, + ) { + base_test( + path!("/test"), + path!("/test/text.txt"), + "def process_incoming_inventory(items, warehouse_id):\n pass\n", + "def process_outgoing_inventory(items, warehouse_id):\n passˇ\n", + &unindent( + " + - def process_incoming_inventory(items, warehouse_id): + + ˇdef process_outgoing_inventory(items, warehouse_id): + pass + ", + ), + "Clipboard ↔ text.txt @ L1:1-L3:1", + &format!("Clipboard ↔ {} @ L1:1-L3:1", path!("test/text.txt")), + cx, + ) + .await; } #[gpui::test] - async fn test_diffing_clipboard_against_empty_selection_uses_full_buffer( + async fn test_diffing_clipboard_against_multiline_selection_expands_to_full_lines( cx: &mut TestAppContext, ) { - base_test(false, cx).await; + base_test( + path!("/test"), + path!("/test/text.txt"), + "def process_incoming_inventory(items, warehouse_id):\n pass\n", + "«def process_outgoing_inventory(items, warehouse_id):\n passˇ»\n", + &unindent( + " + - def process_incoming_inventory(items, warehouse_id): + + ˇdef process_outgoing_inventory(items, warehouse_id): + pass + ", + ), + "Clipboard ↔ text.txt @ L1:1-L3:1", + &format!("Clipboard ↔ {} @ L1:1-L3:1", path!("test/text.txt")), + cx, + ) + .await; } - async fn base_test(select_all_text: bool, cx: &mut TestAppContext) { + #[gpui::test] + async fn test_diffing_clipboard_against_single_line_selection(cx: &mut TestAppContext) { + base_test( + path!("/test"), + path!("/test/text.txt"), + "a", + "«bbˇ»", + &unindent( + " + - a + + ˇbb", + ), + "Clipboard ↔ text.txt @ L1:1-3", + &format!("Clipboard ↔ {} @ L1:1-3", path!("test/text.txt")), + cx, + ) + .await; + } + + #[gpui::test] + async fn test_diffing_clipboard_with_leading_whitespace_against_line(cx: &mut TestAppContext) { + base_test( + path!("/test"), + path!("/test/text.txt"), + " a", + "«bbˇ»", + &unindent( + " + - a + + ˇbb", + ), + "Clipboard ↔ text.txt @ L1:1-3", + &format!("Clipboard ↔ {} @ L1:1-3", path!("test/text.txt")), + cx, + ) + .await; + } + + #[gpui::test] + async fn test_diffing_clipboard_against_line_with_leading_whitespace(cx: &mut TestAppContext) { + base_test( + path!("/test"), + path!("/test/text.txt"), + "a", + " «bbˇ»", + &unindent( + " + - a + + ˇ bb", + ), + "Clipboard ↔ text.txt @ L1:1-7", + &format!("Clipboard ↔ {} @ L1:1-7", path!("test/text.txt")), + cx, + ) + .await; + } + + #[gpui::test] + async fn test_diffing_clipboard_against_line_with_leading_whitespace_included_in_selection( + cx: &mut TestAppContext, + ) { + base_test( + path!("/test"), + path!("/test/text.txt"), + "a", + "« bbˇ»", + &unindent( + " + - a + + ˇ bb", + ), + "Clipboard ↔ text.txt @ L1:1-7", + &format!("Clipboard ↔ {} @ L1:1-7", path!("test/text.txt")), + cx, + ) + .await; + } + + #[gpui::test] + async fn test_diffing_clipboard_with_leading_whitespace_against_line_with_leading_whitespace( + cx: &mut TestAppContext, + ) { + base_test( + path!("/test"), + path!("/test/text.txt"), + " a", + " «bbˇ»", + &unindent( + " + - a + + ˇ bb", + ), + "Clipboard ↔ text.txt @ L1:1-7", + &format!("Clipboard ↔ {} @ L1:1-7", path!("test/text.txt")), + cx, + ) + .await; + } + + #[gpui::test] + async fn test_diffing_clipboard_with_leading_whitespace_against_line_with_leading_whitespace_included_in_selection( + cx: &mut TestAppContext, + ) { + base_test( + path!("/test"), + path!("/test/text.txt"), + " a", + "« bbˇ»", + &unindent( + " + - a + + ˇ bb", + ), + "Clipboard ↔ text.txt @ L1:1-7", + &format!("Clipboard ↔ {} @ L1:1-7", path!("test/text.txt")), + cx, + ) + .await; + } + + #[gpui::test] + async fn test_diffing_clipboard_against_partial_selection_expands_to_include_trailing_characters( + cx: &mut TestAppContext, + ) { + base_test( + path!("/test"), + path!("/test/text.txt"), + "a", + "«bˇ»b", + &unindent( + " + - a + + ˇbb", + ), + "Clipboard ↔ text.txt @ L1:1-3", + &format!("Clipboard ↔ {} @ L1:1-3", path!("test/text.txt")), + cx, + ) + .await; + } + + async fn base_test( + project_root: &str, + file_path: &str, + clipboard_text: &str, + editor_text: &str, + expected_diff: &str, + expected_tab_title: &str, + expected_tab_tooltip: &str, + cx: &mut TestAppContext, + ) { init_test(cx); + let file_name = std::path::Path::new(file_path) + .file_name() + .unwrap() + .to_str() + .unwrap(); + let fs = FakeFs::new(cx.executor()); fs.insert_tree( - path!("/test"), + project_root, json!({ - "a": { - "b": { - "text.txt": "new line 1\nline 2\nnew line 3\nline 4" - } - } + file_name: editor_text }), ) .await; - let project = Project::test(fs, [path!("/test").as_ref()], cx).await; + let project = Project::test(fs, [project_root.as_ref()], cx).await; let (workspace, mut cx) = cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx)); let buffer = project - .update(cx, |project, cx| { - project.open_local_buffer(path!("/test/a/b/text.txt"), cx) - }) + .update(cx, |project, cx| project.open_local_buffer(file_path, cx)) .await .unwrap(); let editor = cx.new_window_entity(|window, cx| { let mut editor = Editor::for_buffer(buffer, None, window, cx); - editor.set_text("new line 1\nline 2\nnew line 3\nline 4\n", window, cx); - - if select_all_text { - editor.select_all(&actions::SelectAll, window, cx); - } + let (unmarked_text, selection_ranges) = marked_text_ranges(editor_text, false); + editor.set_text(unmarked_text, window, cx); + editor.change_selections(Default::default(), window, cx, |s| { + s.select_ranges(selection_ranges) + }); editor }); @@ -511,7 +709,7 @@ mod tests { .update_in(cx, |workspace, window, cx| { TextDiffView::open( &DiffClipboardWithSelectionData { - clipboard_text: "old line 1\nline 2\nold line 3\nline 4\n".to_string(), + clipboard_text: clipboard_text.to_string(), editor, }, workspace, @@ -528,26 +726,14 @@ mod tests { assert_state_with_diff( &diff_view.read_with(cx, |diff_view, _| diff_view.diff_editor.clone()), &mut cx, - &unindent( - " - - old line 1 - + ˇnew line 1 - line 2 - - old line 3 - + new line 3 - line 4 - ", - ), + expected_diff, ); diff_view.read_with(cx, |diff_view, cx| { - assert_eq!( - diff_view.tab_content_text(0, cx), - "Clipboard ↔ text.txt @ L1:1-L5:1" - ); + assert_eq!(diff_view.tab_content_text(0, cx), expected_tab_title); assert_eq!( diff_view.tab_tooltip_text(cx).unwrap(), - format!("Clipboard ↔ {}", path!("test/a/b/text.txt @ L1:1-L5:1")) + expected_tab_tooltip ); }); } From 65759d43163bd36cce8f8aa492ba2628ca005a7a Mon Sep 17 00:00:00 2001 From: Jason Lee Date: Thu, 24 Jul 2025 16:27:29 +0800 Subject: [PATCH 0180/1052] gpui: Fix Interactivity prepaint to update scroll_handle bounds (#35013) It took a long time to check this problem. Finally, I found that due to a detail missing when changing #34832, the bounds of `ScrollHandle` was not updated in the Interactivity `prepaint` phase. ```diff - scroll_handle_state.padded_content_size = padded_content_size; + scroll_handle_state.max_offset = scroll_max; ``` It was correct before the change, because the `padded_content_size` (including `bounds.size`) was saved before, and the bounds was missing after changing to `max_offset`, but the bounds were not updated anywhere. So when `scroll_handle.bounds()` is obtained outside, it is always 0px here. @MrSubidubi Release Notes: - N/A --- crates/gpui/src/elements/div.rs | 7 +------ crates/gpui/src/elements/uniform_list.rs | 5 ++--- 2 files changed, 3 insertions(+), 9 deletions(-) diff --git a/crates/gpui/src/elements/div.rs b/crates/gpui/src/elements/div.rs index 4655c92409..fa47758581 100644 --- a/crates/gpui/src/elements/div.rs +++ b/crates/gpui/src/elements/div.rs @@ -1334,7 +1334,6 @@ impl Element for Div { } else if let Some(scroll_handle) = self.interactivity.tracked_scroll_handle.as_ref() { let mut state = scroll_handle.0.borrow_mut(); state.child_bounds = Vec::with_capacity(request_layout.child_layout_ids.len()); - state.bounds = bounds; for child_layout_id in &request_layout.child_layout_ids { let child_bounds = window.layout_bounds(*child_layout_id); child_min = child_min.min(&child_bounds.origin); @@ -1706,6 +1705,7 @@ impl Interactivity { if let Some(mut scroll_handle_state) = tracked_scroll_handle { scroll_handle_state.max_offset = scroll_max; + scroll_handle_state.bounds = bounds; } *scroll_offset @@ -3007,11 +3007,6 @@ impl ScrollHandle { self.0.borrow().bounds } - /// Set the bounds into which this child is painted - pub(super) fn set_bounds(&self, bounds: Bounds) { - self.0.borrow_mut().bounds = bounds; - } - /// Get the bounds for a specific child. pub fn bounds_for_item(&self, ix: usize) -> Option> { self.0.borrow().child_bounds.get(ix).cloned() diff --git a/crates/gpui/src/elements/uniform_list.rs b/crates/gpui/src/elements/uniform_list.rs index 52e2015c20..e80656a078 100644 --- a/crates/gpui/src/elements/uniform_list.rs +++ b/crates/gpui/src/elements/uniform_list.rs @@ -295,9 +295,8 @@ impl Element for UniformList { bounds.bottom_right() - point(border.right + padding.right, border.bottom), ); - let y_flipped = if let Some(scroll_handle) = self.scroll_handle.as_mut() { - let mut scroll_state = scroll_handle.0.borrow_mut(); - scroll_state.base_handle.set_bounds(bounds); + let y_flipped = if let Some(scroll_handle) = &self.scroll_handle { + let scroll_state = scroll_handle.0.borrow(); scroll_state.y_flipped } else { false From cd9bcc7f0963c7dd06c6623fce039e18b42f682e Mon Sep 17 00:00:00 2001 From: Finn Evers Date: Thu, 24 Jul 2025 10:40:36 +0200 Subject: [PATCH 0181/1052] agent_ui: Improve wrapping behavior in provider configuration header (#34989) This ensures that the "Add provider" button does not move offscreen too fast and ensures the text wraps for smaller panel sizes. | Before | After | | --- | --- | | image | image | Release Notes: - N/A --- crates/agent_ui/src/agent_configuration.rs | 86 +++++++++++++--------- 1 file changed, 51 insertions(+), 35 deletions(-) diff --git a/crates/agent_ui/src/agent_configuration.rs b/crates/agent_ui/src/agent_configuration.rs index 7a160a5649..1870c3e3d2 100644 --- a/crates/agent_ui/src/agent_configuration.rs +++ b/crates/agent_ui/src/agent_configuration.rs @@ -321,46 +321,62 @@ impl AgentConfiguration { .justify_between() .child( v_flex() + .w_full() .gap_0p5() - .child(Headline::new("LLM Providers")) + .child( + h_flex() + .w_full() + .gap_2() + .justify_between() + .child(Headline::new("LLM Providers")) + .child( + PopoverMenu::new("add-provider-popover") + .trigger( + Button::new("add-provider", "Add Provider") + .icon_position(IconPosition::Start) + .icon(IconName::Plus) + .icon_size(IconSize::Small) + .icon_color(Color::Muted) + .label_size(LabelSize::Small), + ) + .anchor(gpui::Corner::TopRight) + .menu({ + let workspace = self.workspace.clone(); + move |window, cx| { + Some(ContextMenu::build( + window, + cx, + |menu, _window, _cx| { + menu.header("Compatible APIs").entry( + "OpenAI", + None, + { + let workspace = + workspace.clone(); + move |window, cx| { + workspace + .update(cx, |workspace, cx| { + AddLlmProviderModal::toggle( + LlmCompatibleProvider::OpenAi, + workspace, + window, + cx, + ); + }) + .log_err(); + } + }, + ) + }, + )) + } + }), + ), + ) .child( Label::new("Add at least one provider to use AI-powered features.") .color(Color::Muted), ), - ) - .child( - PopoverMenu::new("add-provider-popover") - .trigger( - Button::new("add-provider", "Add Provider") - .icon_position(IconPosition::Start) - .icon(IconName::Plus) - .icon_size(IconSize::Small) - .icon_color(Color::Muted) - .label_size(LabelSize::Small), - ) - .anchor(gpui::Corner::TopRight) - .menu({ - let workspace = self.workspace.clone(); - move |window, cx| { - Some(ContextMenu::build(window, cx, |menu, _window, _cx| { - menu.header("Compatible APIs").entry("OpenAI", None, { - let workspace = workspace.clone(); - move |window, cx| { - workspace - .update(cx, |workspace, cx| { - AddLlmProviderModal::toggle( - LlmCompatibleProvider::OpenAi, - workspace, - window, - cx, - ); - }) - .log_err(); - } - }) - })) - } - }), ), ) .child( From 5c9363b1c47426e9f65858f7dbc2e6af42bbe403 Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Thu, 24 Jul 2025 04:43:28 -0400 Subject: [PATCH 0182/1052] Differentiate between file and selection diff events (#35014) Release Notes: - N/A --- crates/git_ui/src/text_diff_view.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/git_ui/src/text_diff_view.rs b/crates/git_ui/src/text_diff_view.rs index be1866a354..005c1e18b4 100644 --- a/crates/git_ui/src/text_diff_view.rs +++ b/crates/git_ui/src/text_diff_view.rs @@ -316,7 +316,7 @@ impl Item for TextDiffView { } fn telemetry_event_text(&self) -> Option<&'static str> { - Some("Diff View Opened") + Some("Selection Diff View Opened") } fn deactivated(&mut self, window: &mut Window, cx: &mut Context) { From 913b9296d755d88a85ac6fad2d57f6c1e5d7cef6 Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Thu, 24 Jul 2025 04:49:04 -0400 Subject: [PATCH 0183/1052] Add `editor: convert to sentence case` (#35015) This PR adds an `editor: convert to sentence case` action. I frequently find myself copying branch names and then removing the hyphens and ensuring the first letter is capitalized, and then using the result text for the commit message. For example: image You can achieve this with a combination of other text manipulation commands, but this action makes it even easier. Also, moved `toggle_case` down into the area where all other commands internally using `manipulate_text` are located. Release Notes: - Added `editor: convert to sentence case` --- crates/editor/src/actions.rs | 2 ++ crates/editor/src/editor.rs | 31 ++++++++++++++++++++----------- crates/editor/src/editor_tests.rs | 17 +++++++++++++++++ crates/editor/src/element.rs | 3 ++- 4 files changed, 41 insertions(+), 12 deletions(-) diff --git a/crates/editor/src/actions.rs b/crates/editor/src/actions.rs index f80a6afbbb..1212651cb3 100644 --- a/crates/editor/src/actions.rs +++ b/crates/editor/src/actions.rs @@ -365,6 +365,8 @@ actions!( ConvertToLowerCase, /// Toggles the case of selected text. ConvertToOppositeCase, + /// Converts selected text to sentence case. + ConvertToSentenceCase, /// Converts selected text to snake_case. ConvertToSnakeCase, /// Converts selected text to Title Case. diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index 069d8cffb3..8f57fb1a20 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -10878,17 +10878,6 @@ impl Editor { }); } - pub fn toggle_case(&mut self, _: &ToggleCase, window: &mut Window, cx: &mut Context) { - self.manipulate_text(window, cx, |text| { - let has_upper_case_characters = text.chars().any(|c| c.is_uppercase()); - if has_upper_case_characters { - text.to_lowercase() - } else { - text.to_uppercase() - } - }) - } - fn manipulate_immutable_lines( &mut self, window: &mut Window, @@ -11144,6 +11133,26 @@ impl Editor { }) } + pub fn convert_to_sentence_case( + &mut self, + _: &ConvertToSentenceCase, + window: &mut Window, + cx: &mut Context, + ) { + self.manipulate_text(window, cx, |text| text.to_case(Case::Sentence)) + } + + pub fn toggle_case(&mut self, _: &ToggleCase, window: &mut Window, cx: &mut Context) { + self.manipulate_text(window, cx, |text| { + let has_upper_case_characters = text.chars().any(|c| c.is_uppercase()); + if has_upper_case_characters { + text.to_lowercase() + } else { + text.to_uppercase() + } + }) + } + pub fn convert_to_rot13( &mut self, _: &ConvertToRot13, diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index 8d121972d0..03b047e92e 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -4724,6 +4724,23 @@ async fn test_toggle_case(cx: &mut TestAppContext) { "}); } +#[gpui::test] +async fn test_convert_to_sentence_case(cx: &mut TestAppContext) { + init_test(cx, |_| {}); + + let mut cx = EditorTestContext::new(cx).await; + + cx.set_state(indoc! {" + «implement-windows-supportˇ» + "}); + cx.update_editor(|e, window, cx| { + e.convert_to_sentence_case(&ConvertToSentenceCase, window, cx) + }); + cx.assert_editor_state(indoc! {" + «Implement windows supportˇ» + "}); +} + #[gpui::test] async fn test_manipulate_text(cx: &mut TestAppContext) { init_test(cx, |_| {}); diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index d2ee9d6b0a..5fd6b028f4 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -230,7 +230,6 @@ impl EditorElement { register_action(editor, window, Editor::sort_lines_case_insensitive); register_action(editor, window, Editor::reverse_lines); register_action(editor, window, Editor::shuffle_lines); - register_action(editor, window, Editor::toggle_case); register_action(editor, window, Editor::convert_indentation_to_spaces); register_action(editor, window, Editor::convert_indentation_to_tabs); register_action(editor, window, Editor::convert_to_upper_case); @@ -241,6 +240,8 @@ impl EditorElement { register_action(editor, window, Editor::convert_to_upper_camel_case); register_action(editor, window, Editor::convert_to_lower_camel_case); register_action(editor, window, Editor::convert_to_opposite_case); + register_action(editor, window, Editor::convert_to_sentence_case); + register_action(editor, window, Editor::toggle_case); register_action(editor, window, Editor::convert_to_rot13); register_action(editor, window, Editor::convert_to_rot47); register_action(editor, window, Editor::delete_to_previous_word_start); From dd52fb58feddd1d6200bc40c641e9189836ad753 Mon Sep 17 00:00:00 2001 From: Finn Evers Date: Thu, 24 Jul 2025 10:51:40 +0200 Subject: [PATCH 0184/1052] terminal_view: Ensure breadcrumbs are updated on settings change (#35016) Currently, terminal breadcrumbs are only updated after a settings change once the terminal view is focused again. This change ensures that the breadcrumbs are updated instantaneously once the breadcrumb settings changes. Release Notes: - Fixed an issue where terminal breadcrumbs would not react instantly to settings changes. --- crates/terminal_view/src/terminal_view.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/crates/terminal_view/src/terminal_view.rs b/crates/terminal_view/src/terminal_view.rs index 1cc1fbcf6f..bf65a736e8 100644 --- a/crates/terminal_view/src/terminal_view.rs +++ b/crates/terminal_view/src/terminal_view.rs @@ -430,6 +430,7 @@ impl TerminalView { fn settings_changed(&mut self, cx: &mut Context) { let settings = TerminalSettings::get_global(cx); + let breadcrumb_visibility_changed = self.show_breadcrumbs != settings.toolbar.breadcrumbs; self.show_breadcrumbs = settings.toolbar.breadcrumbs; let new_cursor_shape = settings.cursor_shape.unwrap_or_default(); @@ -441,6 +442,9 @@ impl TerminalView { }); } + if breadcrumb_visibility_changed { + cx.emit(ItemEvent::UpdateBreadcrumbs); + } cx.notify(); } From 0af690080bc4353d71d1039374e5cbbfce656718 Mon Sep 17 00:00:00 2001 From: Oleksiy Syvokon Date: Thu, 24 Jul 2025 15:22:57 +0300 Subject: [PATCH 0185/1052] linux: Fix `ctrl-0..9`, `ctrl-[`, `ctrl-^` (#35028) There were two different underlying reasons for the issues with ctrl-number and ctrl-punctuation: 1. Some keys in the ctrl-0..9 range send codes in the `\1b`..`\1f` range. For example, `ctrl-2` sends keycode for `ctrl-[` (0x1b), but we want to map it to `2`, not to `[`. 2. `ctrl-[` and four other ctrl-punctuation were incorrectly mapped, since the expected conversion is by adding 0x40 Closes #35012 Release Notes: - N/A --- crates/gpui/src/platform/linux/platform.rs | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/crates/gpui/src/platform/linux/platform.rs b/crates/gpui/src/platform/linux/platform.rs index d65118e994..fe6a36baa8 100644 --- a/crates/gpui/src/platform/linux/platform.rs +++ b/crates/gpui/src/platform/linux/platform.rs @@ -845,9 +845,15 @@ impl crate::Keystroke { { if key.is_ascii_graphic() { key_utf8.to_lowercase() - // map ctrl-a to a - } else if key_utf32 <= 0x1f { - ((key_utf32 as u8 + 0x60) as char).to_string() + // map ctrl-a to `a` + // ctrl-0..9 may emit control codes like ctrl-[, but + // we don't want to map them to `[` + } else if key_utf32 <= 0x1f + && !name.chars().next().is_some_and(|c| c.is_ascii_digit()) + { + ((key_utf32 as u8 + 0x40) as char) + .to_ascii_lowercase() + .to_string() } else { name } From 1e2b0fcab6535f53857f401ba7ef2435c40b7e1e Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Thu, 24 Jul 2025 14:30:49 +0200 Subject: [PATCH 0186/1052] sum_tree: Remove Unit type (#35027) This solves one ~TODO, as Unit type was a workaround for a lack of ability to implement Summary for (). Release Notes: - N/A --- crates/sum_tree/src/sum_tree.rs | 12 +++++------- crates/worktree/src/worktree.rs | 14 ++++---------- 2 files changed, 9 insertions(+), 17 deletions(-) diff --git a/crates/sum_tree/src/sum_tree.rs b/crates/sum_tree/src/sum_tree.rs index 4f9e01ce20..4c5ce39590 100644 --- a/crates/sum_tree/src/sum_tree.rs +++ b/crates/sum_tree/src/sum_tree.rs @@ -41,16 +41,14 @@ pub trait Summary: Clone { fn add_summary(&mut self, summary: &Self, cx: &Self::Context); } -/// This type exists because we can't implement Summary for () without causing -/// type resolution errors -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub struct Unit; - -impl Summary for Unit { +/// Catch-all implementation for when you need something that implements [`Summary`] without a specific type. +/// We implement it on a &'static, as that avoids blanket impl collisions with `impl Dimension for T` +/// (as we also need unit type to be a fill-in dimension) +impl Summary for &'static () { type Context = (); fn zero(_: &()) -> Self { - Unit + &() } fn add_summary(&mut self, _: &Self, _: &()) {} diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs index 4fc6b91abb..e6949f62df 100644 --- a/crates/worktree/src/worktree.rs +++ b/crates/worktree/src/worktree.rs @@ -62,7 +62,7 @@ use std::{ }, time::{Duration, Instant}, }; -use sum_tree::{Bias, Edit, KeyedItem, SeekTarget, SumTree, Summary, TreeMap, TreeSet, Unit}; +use sum_tree::{Bias, Edit, KeyedItem, SeekTarget, SumTree, Summary, TreeMap, TreeSet}; use text::{LineEnding, Rope}; use util::{ ResultExt, @@ -407,12 +407,12 @@ struct LocalRepositoryEntry { } impl sum_tree::Item for LocalRepositoryEntry { - type Summary = PathSummary; + type Summary = PathSummary<&'static ()>; fn summary(&self, _: &::Context) -> Self::Summary { PathSummary { max_path: self.work_directory.path_key().0, - item_summary: Unit, + item_summary: &(), } } } @@ -425,12 +425,6 @@ impl KeyedItem for LocalRepositoryEntry { } } -//impl LocalRepositoryEntry { -// pub fn repo(&self) -> &Arc { -// &self.repo_ptr -// } -//} - impl Deref for LocalRepositoryEntry { type Target = WorkDirectory; @@ -5417,7 +5411,7 @@ impl<'a> SeekTarget<'a, EntrySummary, TraversalProgress<'a>> for TraversalTarget } } -impl<'a> SeekTarget<'a, PathSummary, TraversalProgress<'a>> for TraversalTarget<'_> { +impl<'a> SeekTarget<'a, PathSummary<&'static ()>, TraversalProgress<'a>> for TraversalTarget<'_> { fn cmp(&self, cursor_location: &TraversalProgress<'a>, _: &()) -> Ordering { self.cmp_progress(cursor_location) } From 4fb540d6d2adb58b2e61ab1bdfa7c820eb9798d8 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Thu, 24 Jul 2025 09:39:10 -0300 Subject: [PATCH 0187/1052] dock: Add divider between panels on the right side, too (#35003) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A while ago, we added a divider in the left side of the status bar between the icon buttons that open panels vs. those that open something else (tabs, popover menus, etc.). There isn't a super good reason why we wouldn't do the same in the right side, even more so given that (at least by default) we usually have more buttons on that side; buttons that _don't_ open panels (regardless of being docked to the bottom or right). So, this PR does this! CleanShot 2025-07-24 at 1  59 10@2x Release Notes: - N/A --- crates/workspace/src/dock.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/crates/workspace/src/dock.rs b/crates/workspace/src/dock.rs index 7165de23ec..ca63d3e553 100644 --- a/crates/workspace/src/dock.rs +++ b/crates/workspace/src/dock.rs @@ -934,6 +934,10 @@ impl Render for PanelButtons { h_flex() .gap_1() + .when( + has_buttons && dock.position == DockPosition::Bottom, + |this| this.child(Divider::vertical().color(DividerColor::Border)), + ) .children(buttons) .when(has_buttons && dock.position == DockPosition::Left, |this| { this.child(Divider::vertical().color(DividerColor::Border)) From fab450e39d39364ff6e2f08121c6d31e301a47ca Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Thu, 24 Jul 2025 09:20:25 -0400 Subject: [PATCH 0188/1052] Fix invalid regular expressions highlighting all search fields (#35001) Closes https://github.com/zed-industries/zed/issues/34969 Closes https://github.com/zed-industries/zed/issues/34970 Only highlight the search field on regex error (buffer search and project search). Clear errors when the buffer search hidden so stale errors aren't shown on next search. Before (all fields highlighted red): Screenshot 2025-07-23 at 22 59 45 After (only query field highlighted red): Screenshot 2025-07-23 at 23 10 49 Release Notes: - Improved highlighting of regex errors in search dialogs --- crates/search/src/buffer_search.rs | 22 +++++++++++++--------- crates/search/src/project_search.rs | 13 +++++++------ 2 files changed, 20 insertions(+), 15 deletions(-) diff --git a/crates/search/src/buffer_search.rs b/crates/search/src/buffer_search.rs index 91b7fe488e..5d77a95027 100644 --- a/crates/search/src/buffer_search.rs +++ b/crates/search/src/buffer_search.rs @@ -228,16 +228,17 @@ impl Render for BufferSearchBar { if in_replace { key_context.add("in_replace"); } - let editor_border = if self.query_error.is_some() { + let query_border = if self.query_error.is_some() { Color::Error.color(cx) } else { cx.theme().colors().border }; + let replacement_border = cx.theme().colors().border; let container_width = window.viewport_size().width; let input_width = SearchInputWidth::calc_width(container_width); - let input_base_styles = || { + let input_base_styles = |border_color| { h_flex() .min_w_32() .w(input_width) @@ -246,7 +247,7 @@ impl Render for BufferSearchBar { .pr_1() .py_1() .border_1() - .border_color(editor_border) + .border_color(border_color) .rounded_lg() }; @@ -256,7 +257,7 @@ impl Render for BufferSearchBar { el.child(Label::new("Find in results").color(Color::Hint)) }) .child( - input_base_styles() + input_base_styles(query_border) .id("editor-scroll") .track_scroll(&self.editor_scroll_handle) .child(self.render_text_input(&self.query_editor, color_override, cx)) @@ -430,11 +431,13 @@ impl Render for BufferSearchBar { let replace_line = should_show_replace_input.then(|| { h_flex() .gap_2() - .child(input_base_styles().child(self.render_text_input( - &self.replacement_editor, - None, - cx, - ))) + .child( + input_base_styles(replacement_border).child(self.render_text_input( + &self.replacement_editor, + None, + cx, + )), + ) .child( h_flex() .min_w_64() @@ -775,6 +778,7 @@ impl BufferSearchBar { pub fn dismiss(&mut self, _: &Dismiss, window: &mut Window, cx: &mut Context) { self.dismissed = true; + self.query_error = None; for searchable_item in self.searchable_items_with_matches.keys() { if let Some(searchable_item) = WeakSearchableItemHandle::upgrade(searchable_item.as_ref(), cx) diff --git a/crates/search/src/project_search.rs b/crates/search/src/project_search.rs index 57ca5e56b9..3b9700c5f1 100644 --- a/crates/search/src/project_search.rs +++ b/crates/search/src/project_search.rs @@ -195,6 +195,7 @@ pub struct ProjectSearch { #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] enum InputPanel { Query, + Replacement, Exclude, Include, } @@ -1962,7 +1963,7 @@ impl Render for ProjectSearchBar { MultipleInputs, } - let input_base_styles = |base_style: BaseStyle| { + let input_base_styles = |base_style: BaseStyle, panel: InputPanel| { h_flex() .min_w_32() .map(|div| match base_style { @@ -1974,11 +1975,11 @@ impl Render for ProjectSearchBar { .pr_1() .py_1() .border_1() - .border_color(search.border_color_for(InputPanel::Query, cx)) + .border_color(search.border_color_for(panel, cx)) .rounded_lg() }; - let query_column = input_base_styles(BaseStyle::SingleInput) + let query_column = input_base_styles(BaseStyle::SingleInput, InputPanel::Query) .on_action(cx.listener(|this, action, window, cx| this.confirm(action, window, cx))) .on_action(cx.listener(|this, action, window, cx| { this.previous_history_query(action, window, cx) @@ -2167,7 +2168,7 @@ impl Render for ProjectSearchBar { .child(h_flex().min_w_64().child(mode_column).child(matches_column)); let replace_line = search.replace_enabled.then(|| { - let replace_column = input_base_styles(BaseStyle::SingleInput) + let replace_column = input_base_styles(BaseStyle::SingleInput, InputPanel::Replacement) .child(self.render_text_input(&search.replacement_editor, cx)); let focus_handle = search.replacement_editor.read(cx).focus_handle(cx); @@ -2241,7 +2242,7 @@ impl Render for ProjectSearchBar { .gap_2() .w(input_width) .child( - input_base_styles(BaseStyle::MultipleInputs) + input_base_styles(BaseStyle::MultipleInputs, InputPanel::Include) .on_action(cx.listener(|this, action, window, cx| { this.previous_history_query(action, window, cx) })) @@ -2251,7 +2252,7 @@ impl Render for ProjectSearchBar { .child(self.render_text_input(&search.included_files_editor, cx)), ) .child( - input_base_styles(BaseStyle::MultipleInputs) + input_base_styles(BaseStyle::MultipleInputs, InputPanel::Exclude) .on_action(cx.listener(|this, action, window, cx| { this.previous_history_query(action, window, cx) })) From 29332c1962809b0cf812df5c444324e854c62011 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Thu, 24 Jul 2025 11:26:15 -0300 Subject: [PATCH 0189/1052] ai onboarding: Add overall fixes to the whole flow (#34996) Closes https://github.com/zed-industries/zed/issues/34979 Release Notes: - N/A --------- Co-authored-by: Agus Zubiaga Co-authored-by: Ben Kunkle --- crates/agent/src/thread_store.rs | 9 +- crates/agent_ui/src/agent_configuration.rs | 11 +- crates/agent_ui/src/agent_panel.rs | 56 +++--- crates/agent_ui/src/message_editor.rs | 52 +++--- crates/agent_ui/src/ui.rs | 1 - crates/agent_ui/src/ui/end_trial_upsell.rs | 55 +++--- crates/agent_ui/src/ui/upsell.rs | 163 ------------------ .../src/agent_panel_onboarding_content.rs | 7 +- crates/ai_onboarding/src/ai_onboarding.rs | 30 +++- crates/assistant_context/src/context_store.rs | 5 + crates/client/src/user.rs | 6 +- crates/language_models/src/provider/cloud.rs | 5 +- 12 files changed, 150 insertions(+), 250 deletions(-) delete mode 100644 crates/agent_ui/src/ui/upsell.rs diff --git a/crates/agent/src/thread_store.rs b/crates/agent/src/thread_store.rs index 0347156cd4..cc7cb50c91 100644 --- a/crates/agent/src/thread_store.rs +++ b/crates/agent/src/thread_store.rs @@ -41,6 +41,9 @@ use std::{ }; use util::ResultExt as _; +pub static ZED_STATELESS: std::sync::LazyLock = + std::sync::LazyLock::new(|| std::env::var("ZED_STATELESS").map_or(false, |v| !v.is_empty())); + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub enum DataType { #[serde(rename = "json")] @@ -874,7 +877,11 @@ impl ThreadsDatabase { let needs_migration_from_heed = mdb_path.exists(); - let connection = Connection::open_file(&sqlite_path.to_string_lossy()); + let connection = if *ZED_STATELESS { + Connection::open_memory(Some("THREAD_FALLBACK_DB")) + } else { + Connection::open_file(&sqlite_path.to_string_lossy()) + }; connection.exec(indoc! {" CREATE TABLE IF NOT EXISTS threads ( diff --git a/crates/agent_ui/src/agent_configuration.rs b/crates/agent_ui/src/agent_configuration.rs index 1870c3e3d2..cacd409ac6 100644 --- a/crates/agent_ui/src/agent_configuration.rs +++ b/crates/agent_ui/src/agent_configuration.rs @@ -185,6 +185,13 @@ impl AgentConfiguration { None }; + let is_signed_in = self + .workspace + .read_with(cx, |workspace, _| { + workspace.client().status().borrow().is_connected() + }) + .unwrap_or(false); + v_flex() .w_full() .when(is_expanded, |this| this.mb_2()) @@ -233,8 +240,8 @@ impl AgentConfiguration { .size(LabelSize::Large), ) .map(|this| { - if is_zed_provider { - this.gap_2().child( + if is_zed_provider && is_signed_in { + this.child( self.render_zed_plan_info(current_plan, cx), ) } else { diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 6ae2f12b5e..a0250816a0 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -564,6 +564,17 @@ impl AgentPanel { let inline_assist_context_store = cx.new(|_cx| ContextStore::new(project.downgrade(), Some(thread_store.downgrade()))); + let thread_id = thread.read(cx).id().clone(); + + let history_store = cx.new(|cx| { + HistoryStore::new( + thread_store.clone(), + context_store.clone(), + [HistoryEntryId::Thread(thread_id)], + cx, + ) + }); + let message_editor = cx.new(|cx| { MessageEditor::new( fs.clone(), @@ -573,22 +584,13 @@ impl AgentPanel { prompt_store.clone(), thread_store.downgrade(), context_store.downgrade(), + Some(history_store.downgrade()), thread.clone(), window, cx, ) }); - let thread_id = thread.read(cx).id().clone(); - let history_store = cx.new(|cx| { - HistoryStore::new( - thread_store.clone(), - context_store.clone(), - [HistoryEntryId::Thread(thread_id)], - cx, - ) - }); - cx.observe(&history_store, |_, _, cx| cx.notify()).detach(); let active_thread = cx.new(|cx| { @@ -851,6 +853,7 @@ impl AgentPanel { self.prompt_store.clone(), self.thread_store.downgrade(), self.context_store.downgrade(), + Some(self.history_store.downgrade()), thread.clone(), window, cx, @@ -1124,6 +1127,7 @@ impl AgentPanel { self.prompt_store.clone(), self.thread_store.downgrade(), self.context_store.downgrade(), + Some(self.history_store.downgrade()), thread.clone(), window, cx, @@ -2283,20 +2287,21 @@ impl AgentPanel { } match &self.active_view { - ActiveView::Thread { thread, .. } => thread - .read(cx) - .thread() - .read(cx) - .configured_model() - .map_or(true, |model| { - model.provider.id() == language_model::ZED_CLOUD_PROVIDER_ID - }), - ActiveView::TextThread { .. } => LanguageModelRegistry::global(cx) - .read(cx) - .default_model() - .map_or(true, |model| { - model.provider.id() == language_model::ZED_CLOUD_PROVIDER_ID - }), + ActiveView::Thread { .. } | ActiveView::TextThread { .. } => { + let history_is_empty = self + .history_store + .update(cx, |store, cx| store.recent_entries(1, cx).is_empty()); + + let has_configured_non_zed_providers = LanguageModelRegistry::read_global(cx) + .providers() + .iter() + .any(|provider| { + provider.is_authenticated(cx) + && provider.id() != language_model::ZED_CLOUD_PROVIDER_ID + }); + + history_is_empty || !has_configured_non_zed_providers + } ActiveView::ExternalAgentThread { .. } | ActiveView::History | ActiveView::Configuration => false, @@ -2317,9 +2322,8 @@ impl AgentPanel { Some( div() - .size_full() .when(thread_view, |this| { - this.bg(cx.theme().colors().panel_background) + this.size_full().bg(cx.theme().colors().panel_background) }) .when(text_thread_view, |this| { this.bg(cx.theme().colors().editor_background) diff --git a/crates/agent_ui/src/message_editor.rs b/crates/agent_ui/src/message_editor.rs index 62be5629f1..c160f1de04 100644 --- a/crates/agent_ui/src/message_editor.rs +++ b/crates/agent_ui/src/message_editor.rs @@ -9,6 +9,7 @@ use crate::ui::{ MaxModeTooltip, preview::{AgentPreview, UsageCallout}, }; +use agent::history_store::HistoryStore; use agent::{ context::{AgentContextKey, ContextLoadResult, load_context}, context_store::ContextStoreEvent, @@ -29,8 +30,9 @@ use fs::Fs; use futures::future::Shared; use futures::{FutureExt as _, future}; use gpui::{ - Animation, AnimationExt, App, Entity, EventEmitter, Focusable, KeyContext, Subscription, Task, - TextStyle, WeakEntity, linear_color_stop, linear_gradient, point, pulsating_between, + Animation, AnimationExt, App, Entity, EventEmitter, Focusable, IntoElement, KeyContext, + Subscription, Task, TextStyle, WeakEntity, linear_color_stop, linear_gradient, point, + pulsating_between, }; use language::{Buffer, Language, Point}; use language_model::{ @@ -80,6 +82,7 @@ pub struct MessageEditor { user_store: Entity, context_store: Entity, prompt_store: Option>, + history_store: Option>, context_strip: Entity, context_picker_menu_handle: PopoverMenuHandle, model_selector: Entity, @@ -161,6 +164,7 @@ impl MessageEditor { prompt_store: Option>, thread_store: WeakEntity, text_thread_store: WeakEntity, + history_store: Option>, thread: Entity, window: &mut Window, cx: &mut Context, @@ -233,6 +237,7 @@ impl MessageEditor { workspace, context_store, prompt_store, + history_store, context_strip, context_picker_menu_handle, load_context_task: None, @@ -1661,32 +1666,36 @@ impl Render for MessageEditor { let line_height = TextSize::Small.rems(cx).to_pixels(window.rem_size()) * 1.5; - let in_pro_trial = matches!( - self.user_store.read(cx).current_plan(), - Some(proto::Plan::ZedProTrial) - ); + let has_configured_providers = LanguageModelRegistry::read_global(cx) + .providers() + .iter() + .filter(|provider| { + provider.is_authenticated(cx) && provider.id() != ZED_CLOUD_PROVIDER_ID + }) + .count() + > 0; - let pro_user = matches!( - self.user_store.read(cx).current_plan(), - Some(proto::Plan::ZedPro) - ); + let is_signed_out = self + .workspace + .read_with(cx, |workspace, _| { + workspace.client().status().borrow().is_signed_out() + }) + .unwrap_or(true); - let configured_providers: Vec<(IconName, SharedString)> = - LanguageModelRegistry::read_global(cx) - .providers() - .iter() - .filter(|provider| { - provider.is_authenticated(cx) && provider.id() != ZED_CLOUD_PROVIDER_ID - }) - .map(|provider| (provider.icon(), provider.name().0.clone())) - .collect(); - let has_existing_providers = configured_providers.len() > 0; + let has_history = self + .history_store + .as_ref() + .and_then(|hs| hs.update(cx, |hs, cx| hs.entries(cx).len() > 0).ok()) + .unwrap_or(false) + || self + .thread + .read_with(cx, |thread, _| thread.messages().len() > 0); v_flex() .size_full() .bg(cx.theme().colors().panel_background) .when( - has_existing_providers && !in_pro_trial && !pro_user, + !has_history && is_signed_out && has_configured_providers, |this| this.child(cx.new(ApiKeysWithProviders::new)), ) .when(changed_buffers.len() > 0, |parent| { @@ -1778,6 +1787,7 @@ impl AgentPreview for MessageEditor { None, thread_store.downgrade(), text_thread_store.downgrade(), + None, thread, window, cx, diff --git a/crates/agent_ui/src/ui.rs b/crates/agent_ui/src/ui.rs index 15f2e28e58..b477a8c385 100644 --- a/crates/agent_ui/src/ui.rs +++ b/crates/agent_ui/src/ui.rs @@ -5,7 +5,6 @@ mod end_trial_upsell; mod new_thread_button; mod onboarding_modal; pub mod preview; -mod upsell; pub use agent_notification::*; pub use burn_mode_tooltip::*; diff --git a/crates/agent_ui/src/ui/end_trial_upsell.rs b/crates/agent_ui/src/ui/end_trial_upsell.rs index 9c2dd98d20..36770c2197 100644 --- a/crates/agent_ui/src/ui/end_trial_upsell.rs +++ b/crates/agent_ui/src/ui/end_trial_upsell.rs @@ -3,7 +3,7 @@ use std::sync::Arc; use ai_onboarding::{AgentPanelOnboardingCard, BulletItem}; use client::zed_urls; use gpui::{AnyElement, App, IntoElement, RenderOnce, Window}; -use ui::{Divider, List, prelude::*}; +use ui::{Divider, List, Tooltip, prelude::*}; #[derive(IntoElement, RegisterComponent)] pub struct EndTrialUpsell { @@ -33,14 +33,19 @@ impl RenderOnce for EndTrialUpsell { ) .child( List::new() - .child(BulletItem::new("500 prompts per month with Claude models")) - .child(BulletItem::new("Unlimited edit predictions")), + .child(BulletItem::new("500 prompts with Claude models")) + .child(BulletItem::new( + "Unlimited edit predictions with Zeta, our open-source model", + )), ) .child( Button::new("cta-button", "Upgrade to Zed Pro") .full_width() .style(ButtonStyle::Tinted(ui::TintColor::Accent)) - .on_click(|_, _, cx| cx.open_url(&zed_urls::upgrade_to_zed_pro_url(cx))), + .on_click(move |_, _window, cx| { + telemetry::event!("Upgrade To Pro Clicked", state = "end-of-trial"); + cx.open_url(&zed_urls::upgrade_to_zed_pro_url(cx)) + }), ); let free_section = v_flex() @@ -55,37 +60,43 @@ impl RenderOnce for EndTrialUpsell { .color(Color::Muted) .buffer_font(cx), ) + .child( + Label::new("(Current Plan)") + .size(LabelSize::Small) + .color(Color::Custom(cx.theme().colors().text_muted.opacity(0.6))) + .buffer_font(cx), + ) .child(Divider::horizontal()), ) .child( List::new() - .child(BulletItem::new( - "50 prompts per month with the Claude models", - )) - .child(BulletItem::new( - "2000 accepted edit predictions using our open-source Zeta model", - )), - ) - .child( - Button::new("dismiss-button", "Stay on Free") - .full_width() - .style(ButtonStyle::Outlined) - .on_click({ - let callback = self.dismiss_upsell.clone(); - move |_, window, cx| callback(window, cx) - }), + .child(BulletItem::new("50 prompts with the Claude models")) + .child(BulletItem::new("2,000 accepted edit predictions")), ); AgentPanelOnboardingCard::new() - .child(Headline::new("Your Zed Pro trial has expired.")) + .child(Headline::new("Your Zed Pro Trial has expired")) .child( Label::new("You've been automatically reset to the Free plan.") - .size(LabelSize::Small) .color(Color::Muted) - .mb_1(), + .mb_2(), ) .child(pro_section) .child(free_section) + .child( + h_flex().absolute().top_4().right_4().child( + IconButton::new("dismiss_onboarding", IconName::Close) + .icon_size(IconSize::Small) + .tooltip(Tooltip::text("Dismiss")) + .on_click({ + let callback = self.dismiss_upsell.clone(); + move |_, window, cx| { + telemetry::event!("Banner Dismissed", source = "AI Onboarding"); + callback(window, cx) + } + }), + ), + ) } } diff --git a/crates/agent_ui/src/ui/upsell.rs b/crates/agent_ui/src/ui/upsell.rs deleted file mode 100644 index f311aade22..0000000000 --- a/crates/agent_ui/src/ui/upsell.rs +++ /dev/null @@ -1,163 +0,0 @@ -use component::{Component, ComponentScope, single_example}; -use gpui::{ - AnyElement, App, ClickEvent, IntoElement, ParentElement, RenderOnce, SharedString, Styled, - Window, -}; -use theme::ActiveTheme; -use ui::{ - Button, ButtonCommon, ButtonStyle, Checkbox, Clickable, Color, Label, LabelCommon, - RegisterComponent, ToggleState, h_flex, v_flex, -}; - -/// A component that displays an upsell message with a call-to-action button -/// -/// # Example -/// ``` -/// let upsell = Upsell::new( -/// "Upgrade to Zed Pro", -/// "Get access to advanced AI features and more", -/// "Upgrade Now", -/// Box::new(|_, _window, cx| { -/// cx.open_url("https://zed.dev/pricing"); -/// }), -/// Box::new(|_, _window, cx| { -/// // Handle dismiss -/// }), -/// Box::new(|checked, window, cx| { -/// // Handle don't show again -/// }), -/// ); -/// ``` -#[derive(IntoElement, RegisterComponent)] -pub struct Upsell { - title: SharedString, - message: SharedString, - cta_text: SharedString, - on_click: Box, - on_dismiss: Box, - on_dont_show_again: Box, -} - -impl Upsell { - /// Create a new upsell component - pub fn new( - title: impl Into, - message: impl Into, - cta_text: impl Into, - on_click: Box, - on_dismiss: Box, - on_dont_show_again: Box, - ) -> Self { - Self { - title: title.into(), - message: message.into(), - cta_text: cta_text.into(), - on_click, - on_dismiss, - on_dont_show_again, - } - } -} - -impl RenderOnce for Upsell { - fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement { - v_flex() - .w_full() - .p_4() - .gap_3() - .bg(cx.theme().colors().surface_background) - .rounded_md() - .border_1() - .border_color(cx.theme().colors().border) - .child( - v_flex() - .gap_1() - .child( - Label::new(self.title) - .size(ui::LabelSize::Large) - .weight(gpui::FontWeight::BOLD), - ) - .child(Label::new(self.message).color(Color::Muted)), - ) - .child( - h_flex() - .w_full() - .justify_between() - .items_center() - .child( - h_flex() - .items_center() - .gap_1() - .child( - Checkbox::new("dont-show-again", ToggleState::Unselected).on_click( - move |_, window, cx| { - (self.on_dont_show_again)(true, window, cx); - }, - ), - ) - .child( - Label::new("Don't show again") - .color(Color::Muted) - .size(ui::LabelSize::Small), - ), - ) - .child( - h_flex() - .gap_2() - .child( - Button::new("dismiss-button", "No Thanks") - .style(ButtonStyle::Subtle) - .on_click(self.on_dismiss), - ) - .child( - Button::new("cta-button", self.cta_text) - .style(ButtonStyle::Filled) - .on_click(self.on_click), - ), - ), - ) - } -} - -impl Component for Upsell { - fn scope() -> ComponentScope { - ComponentScope::Agent - } - - fn name() -> &'static str { - "Upsell" - } - - fn description() -> Option<&'static str> { - Some("A promotional component that displays a message with a call-to-action.") - } - - fn preview(window: &mut Window, cx: &mut App) -> Option { - let examples = vec![ - single_example( - "Default", - Upsell::new( - "Upgrade to Zed Pro", - "Get unlimited access to AI features and more with Zed Pro. Unlock advanced AI capabilities and other premium features.", - "Upgrade Now", - Box::new(|_, _, _| {}), - Box::new(|_, _, _| {}), - Box::new(|_, _, _| {}), - ).render(window, cx).into_any_element(), - ), - single_example( - "Short Message", - Upsell::new( - "Try Zed Pro for free", - "Start your 7-day trial today.", - "Start Trial", - Box::new(|_, _, _| {}), - Box::new(|_, _, _| {}), - Box::new(|_, _, _| {}), - ).render(window, cx).into_any_element(), - ), - ]; - - Some(v_flex().gap_4().children(examples).into_any_element()) - } -} diff --git a/crates/ai_onboarding/src/agent_panel_onboarding_content.rs b/crates/ai_onboarding/src/agent_panel_onboarding_content.rs index 771482abf3..e8a62f7ff2 100644 --- a/crates/ai_onboarding/src/agent_panel_onboarding_content.rs +++ b/crates/ai_onboarding/src/agent_panel_onboarding_content.rs @@ -61,6 +61,11 @@ impl Render for AgentPanelOnboarding { Some(proto::Plan::ZedProTrial) ); + let is_pro_user = matches!( + self.user_store.read(cx).current_plan(), + Some(proto::Plan::ZedPro) + ); + AgentPanelOnboardingCard::new() .child( ZedAiOnboarding::new( @@ -75,7 +80,7 @@ impl Render for AgentPanelOnboarding { }), ) .map(|this| { - if enrolled_in_trial || self.configured_providers.len() >= 1 { + if enrolled_in_trial || is_pro_user || self.configured_providers.len() >= 1 { this } else { this.child(ApiKeysWithoutProviders::new()) diff --git a/crates/ai_onboarding/src/ai_onboarding.rs b/crates/ai_onboarding/src/ai_onboarding.rs index f9a91503ae..7fffb60ecc 100644 --- a/crates/ai_onboarding/src/ai_onboarding.rs +++ b/crates/ai_onboarding/src/ai_onboarding.rs @@ -16,6 +16,7 @@ use client::{Client, UserStore, zed_urls}; use gpui::{AnyElement, Entity, IntoElement, ParentElement, SharedString}; use ui::{Divider, List, ListItem, RegisterComponent, TintColor, Tooltip, prelude::*}; +#[derive(IntoElement)] pub struct BulletItem { label: SharedString, } @@ -28,18 +29,27 @@ impl BulletItem { } } -impl IntoElement for BulletItem { - type Element = AnyElement; +impl RenderOnce for BulletItem { + fn render(self, window: &mut Window, _cx: &mut App) -> impl IntoElement { + let line_height = 0.85 * window.line_height(); - fn into_element(self) -> Self::Element { ListItem::new("list-item") .selectable(false) - .start_slot( - Icon::new(IconName::Dash) - .size(IconSize::XSmall) - .color(Color::Hidden), + .child( + h_flex() + .w_full() + .min_w_0() + .gap_1() + .items_start() + .child( + h_flex().h(line_height).justify_center().child( + Icon::new(IconName::Dash) + .size(IconSize::XSmall) + .color(Color::Hidden), + ), + ) + .child(div().w_full().min_w_0().child(Label::new(self.label))), ) - .child(div().w_full().child(Label::new(self.label))) .into_any_element() } } @@ -373,7 +383,9 @@ impl ZedAiOnboarding { .child( List::new() .child(BulletItem::new("500 prompts with Claude models")) - .child(BulletItem::new("Unlimited edit predictions")), + .child(BulletItem::new( + "Unlimited edit predictions with Zeta, our open-source model", + )), ) .child( Button::new("pro", "Continue with Zed Pro") diff --git a/crates/assistant_context/src/context_store.rs b/crates/assistant_context/src/context_store.rs index 3400913eb8..3090a7b234 100644 --- a/crates/assistant_context/src/context_store.rs +++ b/crates/assistant_context/src/context_store.rs @@ -767,6 +767,11 @@ impl ContextStore { fn reload(&mut self, cx: &mut Context) -> Task> { let fs = self.fs.clone(); cx.spawn(async move |this, cx| { + pub static ZED_STATELESS: LazyLock = + LazyLock::new(|| std::env::var("ZED_STATELESS").map_or(false, |v| !v.is_empty())); + if *ZED_STATELESS { + return Ok(()); + } fs.create_dir(contexts_dir()).await?; let mut paths = fs.read_dir(contexts_dir()).await?; diff --git a/crates/client/src/user.rs b/crates/client/src/user.rs index f5213fbcb6..5ed258aa8e 100644 --- a/crates/client/src/user.rs +++ b/crates/client/src/user.rs @@ -765,12 +765,14 @@ impl UserStore { pub fn current_plan(&self) -> Option { #[cfg(debug_assertions)] - if let Ok(plan) = std::env::var("ZED_SIMULATE_ZED_PRO_PLAN").as_ref() { + if let Ok(plan) = std::env::var("ZED_SIMULATE_PLAN").as_ref() { return match plan.as_str() { "free" => Some(proto::Plan::Free), "trial" => Some(proto::Plan::ZedProTrial), "pro" => Some(proto::Plan::ZedPro), - _ => None, + _ => { + panic!("ZED_SIMULATE_PLAN must be one of 'free', 'trial', or 'pro'"); + } }; } diff --git a/crates/language_models/src/provider/cloud.rs b/crates/language_models/src/provider/cloud.rs index fac8810714..09a2ac6e0a 100644 --- a/crates/language_models/src/provider/cloud.rs +++ b/crates/language_models/src/provider/cloud.rs @@ -1159,19 +1159,20 @@ impl RenderOnce for ZedAiConfiguration { let manage_subscription_buttons = if is_pro { Button::new("manage_settings", "Manage Subscription") + .full_width() .style(ButtonStyle::Tinted(TintColor::Accent)) .on_click(|_, _, cx| cx.open_url(&zed_urls::account_url(cx))) .into_any_element() } else if self.plan.is_none() || self.eligible_for_trial { Button::new("start_trial", "Start 14-day Free Pro Trial") - .style(ui::ButtonStyle::Tinted(ui::TintColor::Accent)) .full_width() + .style(ui::ButtonStyle::Tinted(ui::TintColor::Accent)) .on_click(|_, _, cx| cx.open_url(&zed_urls::start_trial_url(cx))) .into_any_element() } else { Button::new("upgrade", "Upgrade to Pro") - .style(ui::ButtonStyle::Tinted(ui::TintColor::Accent)) .full_width() + .style(ui::ButtonStyle::Tinted(ui::TintColor::Accent)) .on_click(|_, _, cx| cx.open_url(&zed_urls::upgrade_to_zed_pro_url(cx))) .into_any_element() }; From 7cdd808db23caa9082b542abbd13b1cace73a501 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pablo=20Ram=C3=B3n=20Guevara?= <50140021+praguevara@users.noreply.github.com> Date: Thu, 24 Jul 2025 16:29:58 +0200 Subject: [PATCH 0190/1052] helix: Fix replace in helix mode (#34789) Closes https://github.com/zed-industries/zed/issues/33076 Release Notes: - Fixed replace command on helix mode: now it actually replaces what was selected and keeps the replaced text selected to better match helix --- crates/vim/src/helix.rs | 104 +++++++++++++++++++++++++++++++++++++++- crates/vim/src/vim.rs | 1 + 2 files changed, 103 insertions(+), 2 deletions(-) diff --git a/crates/vim/src/helix.rs b/crates/vim/src/helix.rs index 798af3bff3..ca93c9c1de 100644 --- a/crates/vim/src/helix.rs +++ b/crates/vim/src/helix.rs @@ -1,8 +1,8 @@ -use editor::{DisplayPoint, Editor, movement}; +use editor::{DisplayPoint, Editor, SelectionEffects, ToOffset, ToPoint, movement}; use gpui::{Action, actions}; use gpui::{Context, Window}; use language::{CharClassifier, CharKind}; -use text::SelectionGoal; +use text::{Bias, SelectionGoal}; use crate::{ Vim, @@ -341,6 +341,80 @@ impl Vim { }); }); } + + pub fn helix_replace(&mut self, text: &str, window: &mut Window, cx: &mut Context) { + self.update_editor(window, cx, |_, editor, window, cx| { + editor.transact(window, cx, |editor, window, cx| { + let (map, selections) = editor.selections.all_display(cx); + + // Store selection info for positioning after edit + let selection_info: Vec<_> = selections + .iter() + .map(|selection| { + let range = selection.range(); + let start_offset = range.start.to_offset(&map, Bias::Left); + let end_offset = range.end.to_offset(&map, Bias::Left); + let was_empty = range.is_empty(); + let was_reversed = selection.reversed; + ( + map.buffer_snapshot.anchor_at(start_offset, Bias::Left), + end_offset - start_offset, + was_empty, + was_reversed, + ) + }) + .collect(); + + let mut edits = Vec::new(); + for selection in &selections { + let mut range = selection.range(); + + // For empty selections, extend to replace one character + if range.is_empty() { + range.end = movement::saturating_right(&map, range.start); + } + + let byte_range = range.start.to_offset(&map, Bias::Left) + ..range.end.to_offset(&map, Bias::Left); + + if !byte_range.is_empty() { + let replacement_text = text.repeat(byte_range.len()); + edits.push((byte_range, replacement_text)); + } + } + + editor.edit(edits, cx); + + // Restore selections based on original info + let snapshot = editor.buffer().read(cx).snapshot(cx); + let ranges: Vec<_> = selection_info + .into_iter() + .map(|(start_anchor, original_len, was_empty, was_reversed)| { + let start_point = start_anchor.to_point(&snapshot); + if was_empty { + // For cursor-only, collapse to start + start_point..start_point + } else { + // For selections, span the replaced text + let replacement_len = text.len() * original_len; + let end_offset = start_anchor.to_offset(&snapshot) + replacement_len; + let end_point = snapshot.offset_to_point(end_offset); + if was_reversed { + end_point..start_point + } else { + start_point..end_point + } + } + }) + .collect(); + + editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| { + s.select_ranges(ranges); + }); + }); + }); + self.switch_mode(Mode::HelixNormal, true, window, cx); + } } #[cfg(test)] @@ -603,4 +677,30 @@ mod test { Mode::Insert, ); } + + #[gpui::test] + async fn test_replace(cx: &mut gpui::TestAppContext) { + let mut cx = VimTestContext::new(cx, true).await; + + // No selection (single character) + cx.set_state("ˇaa", Mode::HelixNormal); + + cx.simulate_keystrokes("r x"); + + cx.assert_state("ˇxa", Mode::HelixNormal); + + // Cursor at the beginning + cx.set_state("«ˇaa»", Mode::HelixNormal); + + cx.simulate_keystrokes("r x"); + + cx.assert_state("«ˇxx»", Mode::HelixNormal); + + // Cursor at the end + cx.set_state("«aaˇ»", Mode::HelixNormal); + + cx.simulate_keystrokes("r x"); + + cx.assert_state("«xxˇ»", Mode::HelixNormal); + } } diff --git a/crates/vim/src/vim.rs b/crates/vim/src/vim.rs index 95a08d7c66..c747c30462 100644 --- a/crates/vim/src/vim.rs +++ b/crates/vim/src/vim.rs @@ -1639,6 +1639,7 @@ impl Vim { Mode::Visual | Mode::VisualLine | Mode::VisualBlock => { self.visual_replace(text, window, cx) } + Mode::HelixNormal => self.helix_replace(&text, window, cx), _ => self.clear_operator(window, cx), }, Some(Operator::Digraph { first_char }) => { From fa788a39a4b8dded19cd27d79c9bd0c63d601039 Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Thu, 24 Jul 2025 20:07:38 +0530 Subject: [PATCH 0191/1052] project_panel: Reuse `index_for_entry` in `index_for_selection` (#35034) Just refactor I came across while working on another issue. `index_for_entry` and `index_for_selection` have the exact same logic, here we can simply reuse `index_for_entry` for `index_for_selection`. Release Notes: - N/A --- crates/project_panel/src/project_panel.rs | 27 ++++------------------- 1 file changed, 4 insertions(+), 23 deletions(-) diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs index b0073f294f..76be97e393 100644 --- a/crates/project_panel/src/project_panel.rs +++ b/crates/project_panel/src/project_panel.rs @@ -2723,26 +2723,7 @@ impl ProjectPanel { } fn index_for_selection(&self, selection: SelectedEntry) -> Option<(usize, usize, usize)> { - let mut entry_index = 0; - let mut visible_entries_index = 0; - for (worktree_index, (worktree_id, worktree_entries, _)) in - self.visible_entries.iter().enumerate() - { - if *worktree_id == selection.worktree_id { - for entry in worktree_entries { - if entry.id == selection.entry_id { - return Some((worktree_index, entry_index, visible_entries_index)); - } else { - visible_entries_index += 1; - entry_index += 1; - } - } - break; - } else { - visible_entries_index += worktree_entries.len(); - } - } - None + self.index_for_entry(selection.entry_id, selection.worktree_id) } fn disjoint_entries(&self, cx: &App) -> BTreeSet { @@ -3353,12 +3334,12 @@ impl ProjectPanel { entry_id: ProjectEntryId, worktree_id: WorktreeId, ) -> Option<(usize, usize, usize)> { - let mut worktree_ix = 0; let mut total_ix = 0; - for (current_worktree_id, visible_worktree_entries, _) in &self.visible_entries { + for (worktree_ix, (current_worktree_id, visible_worktree_entries, _)) in + self.visible_entries.iter().enumerate() + { if worktree_id != *current_worktree_id { total_ix += visible_worktree_entries.len(); - worktree_ix += 1; continue; } From 2a9355a3d25ddd887556741a30bbafd5d6ff58f0 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 24 Jul 2025 11:11:26 -0400 Subject: [PATCH 0192/1052] Don't auto-retry in certain circumstances (#35037) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Someone encountered this in production, which should not happen: Screenshot 2025-07-24 at 10 38 40 AM This moves certain errors into the category of "never retry" and reduces the number of retries for some others. Also it adds some diagnostic logging for retry policy. It's not a complete fix for the above, because the underlying issues is that the server is sending a HTTP 403 response and although we were already treating 403s as "do not retry" it was deciding to retry with 2 attempts anyway. So further debugging is needed to figure out why it wasn't going down the 403 branch by the time the request got here. Release Notes: - N/A --- crates/agent/src/thread.rs | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs index 1b3b022ab2..1af27ca8a7 100644 --- a/crates/agent/src/thread.rs +++ b/crates/agent/src/thread.rs @@ -2037,6 +2037,12 @@ impl Thread { if let Some(retry_strategy) = Thread::get_retry_strategy(completion_error) { + log::info!( + "Retrying with {:?} for language model completion error {:?}", + retry_strategy, + completion_error + ); + retry_scheduled = thread .handle_retryable_error_with_delay( &completion_error, @@ -2246,15 +2252,14 @@ impl Thread { .. } | AuthenticationError { .. } - | PermissionError { .. } => None, - // These errors might be transient, so retry them - SerializeRequest { .. } - | BuildRequestBody { .. } - | PromptTooLarge { .. } + | PermissionError { .. } + | NoApiKey { .. } | ApiEndpointNotFound { .. } - | NoApiKey { .. } => Some(RetryStrategy::Fixed { + | PromptTooLarge { .. } => None, + // These errors might be transient, so retry them + SerializeRequest { .. } | BuildRequestBody { .. } => Some(RetryStrategy::Fixed { delay: BASE_RETRY_DELAY, - max_attempts: 2, + max_attempts: 1, }), // Retry all other 4xx and 5xx errors once. HttpResponseError { status_code, .. } From 2658b2801e382ed01261b4c9566759d735c8ce17 Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Thu, 24 Jul 2025 18:24:53 +0300 Subject: [PATCH 0193/1052] Shutdown language servers better (#35038) Follow-up of https://github.com/zed-industries/zed/pull/33417 * adjust prettier mock LSP to handle `shutdown` and `exit` messages * removed another `?.log_err()` backtrace from logs and improved the logging info * always handle the last parts of the shutdown logic even if the shutdown response had failed Release Notes: - N/A --- crates/lsp/src/lsp.rs | 56 +++++++++++++------------- crates/prettier/src/prettier_server.js | 4 ++ 2 files changed, 33 insertions(+), 27 deletions(-) diff --git a/crates/lsp/src/lsp.rs b/crates/lsp/src/lsp.rs index a820aaf748..9978d7ebb1 100644 --- a/crates/lsp/src/lsp.rs +++ b/crates/lsp/src/lsp.rs @@ -877,39 +877,41 @@ impl LanguageServer { let server = self.server.clone(); let name = self.name.clone(); + let server_id = self.server_id; let mut timer = self.executor.timer(SERVER_SHUTDOWN_TIMEOUT).fuse(); - Some( - async move { - log::debug!("language server shutdown started"); + Some(async move { + log::debug!("language server shutdown started"); - select! { - request_result = shutdown_request.fuse() => { - match request_result { - ConnectionResult::Timeout => { - log::warn!("timeout waiting for language server {name} to shutdown"); - }, - ConnectionResult::ConnectionReset => {}, - ConnectionResult::Result(r) => r?, - } + select! { + request_result = shutdown_request.fuse() => { + match request_result { + ConnectionResult::Timeout => { + log::warn!("timeout waiting for language server {name} (id {server_id}) to shutdown"); + }, + ConnectionResult::ConnectionReset => { + log::warn!("language server {name} (id {server_id}) closed the shutdown request connection"); + }, + ConnectionResult::Result(Err(e)) => { + log::error!("Shutdown request failure, server {name} (id {server_id}): {e:#}"); + }, + ConnectionResult::Result(Ok(())) => {} } - - _ = timer => { - log::info!("timeout waiting for language server {name} to shutdown"); - }, } - response_handlers.lock().take(); - Self::notify_internal::(&outbound_tx, &()).ok(); - outbound_tx.close(); - output_done.recv().await; - server.lock().take().map(|mut child| child.kill()); - log::debug!("language server shutdown finished"); - - drop(tasks); - anyhow::Ok(()) + _ = timer => { + log::info!("timeout waiting for language server {name} (id {server_id}) to shutdown"); + }, } - .log_err(), - ) + + response_handlers.lock().take(); + Self::notify_internal::(&outbound_tx, &()).ok(); + outbound_tx.close(); + output_done.recv().await; + server.lock().take().map(|mut child| child.kill()); + drop(tasks); + log::debug!("language server shutdown finished"); + Some(()) + }) } else { None } diff --git a/crates/prettier/src/prettier_server.js b/crates/prettier/src/prettier_server.js index 6799b4aceb..b3d8a660a4 100644 --- a/crates/prettier/src/prettier_server.js +++ b/crates/prettier/src/prettier_server.js @@ -152,6 +152,10 @@ async function handleMessage(message, prettier) { throw new Error(`Message method is undefined: ${JSON.stringify(message)}`); } else if (method == "initialized") { return; + } else if (method === "shutdown") { + sendResponse({ result: {} }); + } else if (method == "exit") { + process.exit(0); } if (id === undefined) { From 45ddf32a1d0f8dda645f564486f6a4128dacd1a6 Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Thu, 24 Jul 2025 13:08:02 -0400 Subject: [PATCH 0194/1052] Fix variable name in project type reporting (#35045) Release Notes: - N/A --- crates/client/src/telemetry.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/crates/client/src/telemetry.rs b/crates/client/src/telemetry.rs index 4983fda5ef..7d39464e4a 100644 --- a/crates/client/src/telemetry.rs +++ b/crates/client/src/telemetry.rs @@ -358,13 +358,13 @@ impl Telemetry { worktree_id: WorktreeId, updated_entries_set: &UpdatedEntriesSet, ) { - let Some(project_type_names) = self.detect_project_types(worktree_id, updated_entries_set) + let Some(project_types) = self.detect_project_types(worktree_id, updated_entries_set) else { return; }; - for project_type_name in project_type_names { - telemetry::event!("Project Opened", project_type = project_type_name); + for project_type in project_types { + telemetry::event!("Project Opened", project_type = project_type); } } From 2d0f10c48a3308bde3079fdb5301006256f8d50b Mon Sep 17 00:00:00 2001 From: Agus Zubiaga Date: Thu, 24 Jul 2025 14:39:29 -0300 Subject: [PATCH 0195/1052] Refactor to use new ACP crate (#35043) This will prepare us for running the protocol over MCP Release Notes: - N/A --------- Co-authored-by: Ben Brandt Co-authored-by: Conrad Irwin Co-authored-by: Richard Feldman --- Cargo.lock | 15 +- Cargo.toml | 1 + crates/acp_thread/Cargo.toml | 1 + crates/acp_thread/src/acp_thread.rs | 1002 +++++++---------- crates/acp_thread/src/connection.rs | 36 +- crates/acp_thread/src/old_acp_support.rs | 461 ++++++++ crates/agent_servers/Cargo.toml | 1 + crates/agent_servers/src/agent_servers.rs | 11 +- crates/agent_servers/src/claude.rs | 497 ++++---- crates/agent_servers/src/claude/mcp_server.rs | 179 +-- crates/agent_servers/src/claude/tools.rs | 275 ++--- crates/agent_servers/src/e2e_tests.rs | 95 +- crates/agent_servers/src/gemini.rs | 98 +- .../agent_servers/src/stdio_agent_server.rs | 119 -- crates/agent_ui/Cargo.toml | 4 +- crates/agent_ui/src/acp/thread_view.rs | 652 +++++------ crates/agent_ui/src/agent_diff.rs | 6 +- crates/agent_ui/src/agent_panel.rs | 2 +- crates/context_server/src/client.rs | 87 +- crates/context_server/src/protocol.rs | 20 + crates/context_server/src/types.rs | 16 +- 21 files changed, 1830 insertions(+), 1748 deletions(-) create mode 100644 crates/acp_thread/src/old_acp_support.rs delete mode 100644 crates/agent_servers/src/stdio_agent_server.rs diff --git a/Cargo.lock b/Cargo.lock index 8f791d395a..2c65131db0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6,6 +6,7 @@ version = 4 name = "acp_thread" version = "0.1.0" dependencies = [ + "agent-client-protocol", "agentic-coding-protocol", "anyhow", "assistant_tool", @@ -135,11 +136,23 @@ dependencies = [ "zstd", ] +[[package]] +name = "agent-client-protocol" +version = "0.0.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7fb7f39671e02f8a1aeb625652feae40b6fc2597baaa97e028a98863477aecbd" +dependencies = [ + "schemars", + "serde", + "serde_json", +] + [[package]] name = "agent_servers" version = "0.1.0" dependencies = [ "acp_thread", + "agent-client-protocol", "agentic-coding-protocol", "anyhow", "collections", @@ -195,9 +208,9 @@ version = "0.1.0" dependencies = [ "acp_thread", "agent", + "agent-client-protocol", "agent_servers", "agent_settings", - "agentic-coding-protocol", "ai_onboarding", "anyhow", "assistant_context", diff --git a/Cargo.toml b/Cargo.toml index ec793a7429..9062950127 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -413,6 +413,7 @@ zlog_settings = { path = "crates/zlog_settings" } # agentic-coding-protocol = "0.0.10" +agent-client-protocol = "0.0.10" aho-corasick = "1.1" alacritty_terminal = { git = "https://github.com/zed-industries/alacritty.git", branch = "add-hush-login-flag" } any_vec = "0.14" diff --git a/crates/acp_thread/Cargo.toml b/crates/acp_thread/Cargo.toml index b44c25ccc9..011f26f364 100644 --- a/crates/acp_thread/Cargo.toml +++ b/crates/acp_thread/Cargo.toml @@ -16,6 +16,7 @@ doctest = false test-support = ["gpui/test-support", "project/test-support"] [dependencies] +agent-client-protocol.workspace = true agentic-coding-protocol.workspace = true anyhow.workspace = true assistant_tool.workspace = true diff --git a/crates/acp_thread/src/acp_thread.rs b/crates/acp_thread/src/acp_thread.rs index 9af1eeb187..3c6c21205f 100644 --- a/crates/acp_thread/src/acp_thread.rs +++ b/crates/acp_thread/src/acp_thread.rs @@ -1,17 +1,15 @@ mod connection; +mod old_acp_support; pub use connection::*; +pub use old_acp_support::*; -pub use acp::ToolCallId; -use agentic_coding_protocol::{ - self as acp, AgentRequest, ProtocolVersion, ToolCallConfirmationOutcome, ToolCallLocation, - UserMessageChunk, -}; +use agent_client_protocol as acp; use anyhow::{Context as _, Result}; use assistant_tool::ActionLog; use buffer_diff::BufferDiff; use editor::{Bias, MultiBuffer, PathKey}; use futures::{FutureExt, channel::oneshot, future::BoxFuture}; -use gpui::{AppContext, AsyncApp, Context, Entity, EventEmitter, SharedString, Task, WeakEntity}; +use gpui::{AppContext, Context, Entity, EventEmitter, SharedString, Task}; use itertools::Itertools; use language::{ Anchor, Buffer, BufferSnapshot, Capability, LanguageRegistry, OffsetRangeExt as _, Point, @@ -21,46 +19,37 @@ use markdown::Markdown; use project::{AgentLocation, Project}; use std::collections::HashMap; use std::error::Error; -use std::fmt::{Formatter, Write}; +use std::fmt::Formatter; +use std::rc::Rc; use std::{ fmt::Display, mem, path::{Path, PathBuf}, sync::Arc, }; -use ui::{App, IconName}; +use ui::App; use util::ResultExt; -#[derive(Clone, Debug, Eq, PartialEq)] +#[derive(Debug)] pub struct UserMessage { - pub content: Entity, + pub content: ContentBlock, } impl UserMessage { pub fn from_acp( - message: &acp::SendUserMessageParams, + message: impl IntoIterator, language_registry: Arc, cx: &mut App, ) -> Self { - let mut md_source = String::new(); - - for chunk in &message.chunks { - match chunk { - UserMessageChunk::Text { text } => md_source.push_str(&text), - UserMessageChunk::Path { path } => { - write!(&mut md_source, "{}", MentionPath(&path)).unwrap() - } - } - } - - Self { - content: cx - .new(|cx| Markdown::new(md_source.into(), Some(language_registry), None, cx)), + let mut content = ContentBlock::Empty; + for chunk in message { + content.append(chunk, &language_registry, cx) } + Self { content: content } } fn to_markdown(&self, cx: &App) -> String { - format!("## User\n\n{}\n\n", self.content.read(cx).source()) + format!("## User\n\n{}\n\n", self.content.to_markdown(cx)) } } @@ -96,7 +85,7 @@ impl Display for MentionPath<'_> { } } -#[derive(Clone, Debug, Eq, PartialEq)] +#[derive(Debug, PartialEq)] pub struct AssistantMessage { pub chunks: Vec, } @@ -113,42 +102,24 @@ impl AssistantMessage { } } -#[derive(Clone, Debug, Eq, PartialEq)] +#[derive(Debug, PartialEq)] pub enum AssistantMessageChunk { - Text { chunk: Entity }, - Thought { chunk: Entity }, + Message { block: ContentBlock }, + Thought { block: ContentBlock }, } impl AssistantMessageChunk { - pub fn from_acp( - chunk: acp::AssistantMessageChunk, - language_registry: Arc, - cx: &mut App, - ) -> Self { - match chunk { - acp::AssistantMessageChunk::Text { text } => Self::Text { - chunk: cx.new(|cx| Markdown::new(text.into(), Some(language_registry), None, cx)), - }, - acp::AssistantMessageChunk::Thought { thought } => Self::Thought { - chunk: cx - .new(|cx| Markdown::new(thought.into(), Some(language_registry), None, cx)), - }, - } - } - - pub fn from_str(chunk: &str, language_registry: Arc, cx: &mut App) -> Self { - Self::Text { - chunk: cx.new(|cx| { - Markdown::new(chunk.to_owned().into(), Some(language_registry), None, cx) - }), + pub fn from_str(chunk: &str, language_registry: &Arc, cx: &mut App) -> Self { + Self::Message { + block: ContentBlock::new(chunk.into(), language_registry, cx), } } fn to_markdown(&self, cx: &App) -> String { match self { - Self::Text { chunk } => chunk.read(cx).source().to_string(), - Self::Thought { chunk } => { - format!("\n{}\n", chunk.read(cx).source()) + Self::Message { block } => block.to_markdown(cx).to_string(), + Self::Thought { block } => { + format!("\n{}\n", block.to_markdown(cx)) } } } @@ -166,19 +137,15 @@ impl AgentThreadEntry { match self { Self::UserMessage(message) => message.to_markdown(cx), Self::AssistantMessage(message) => message.to_markdown(cx), - Self::ToolCall(too_call) => too_call.to_markdown(cx), + Self::ToolCall(tool_call) => tool_call.to_markdown(cx), } } - pub fn diff(&self) -> Option<&Diff> { - if let AgentThreadEntry::ToolCall(ToolCall { - content: Some(ToolCallContent::Diff { diff }), - .. - }) = self - { - Some(&diff) + pub fn diffs(&self) -> impl Iterator { + if let AgentThreadEntry::ToolCall(call) = self { + itertools::Either::Left(call.diffs()) } else { - None + itertools::Either::Right(std::iter::empty()) } } @@ -195,20 +162,54 @@ impl AgentThreadEntry { pub struct ToolCall { pub id: acp::ToolCallId, pub label: Entity, - pub icon: IconName, - pub content: Option, + pub kind: acp::ToolKind, + pub content: Vec, pub status: ToolCallStatus, pub locations: Vec, } impl ToolCall { + fn from_acp( + tool_call: acp::ToolCall, + status: ToolCallStatus, + language_registry: Arc, + cx: &mut App, + ) -> Self { + Self { + id: tool_call.id, + label: cx.new(|cx| { + Markdown::new( + tool_call.label.into(), + Some(language_registry.clone()), + None, + cx, + ) + }), + kind: tool_call.kind, + content: tool_call + .content + .into_iter() + .map(|content| ToolCallContent::from_acp(content, language_registry.clone(), cx)) + .collect(), + locations: tool_call.locations, + status, + } + } + + pub fn diffs(&self) -> impl Iterator { + self.content.iter().filter_map(|content| match content { + ToolCallContent::ContentBlock { .. } => None, + ToolCallContent::Diff { diff } => Some(diff), + }) + } + fn to_markdown(&self, cx: &App) -> String { let mut markdown = format!( "**Tool Call: {}**\nStatus: {}\n\n", self.label.read(cx).source(), self.status ); - if let Some(content) = &self.content { + for content in &self.content { markdown.push_str(content.to_markdown(cx).as_str()); markdown.push_str("\n\n"); } @@ -219,8 +220,8 @@ impl ToolCall { #[derive(Debug)] pub enum ToolCallStatus { WaitingForConfirmation { - confirmation: ToolCallConfirmation, - respond_tx: oneshot::Sender, + options: Vec, + respond_tx: oneshot::Sender, }, Allowed { status: acp::ToolCallStatus, @@ -237,9 +238,9 @@ impl Display for ToolCallStatus { match self { ToolCallStatus::WaitingForConfirmation { .. } => "Waiting for confirmation", ToolCallStatus::Allowed { status } => match status { - acp::ToolCallStatus::Running => "Running", - acp::ToolCallStatus::Finished => "Finished", - acp::ToolCallStatus::Error => "Error", + acp::ToolCallStatus::InProgress => "In Progress", + acp::ToolCallStatus::Completed => "Completed", + acp::ToolCallStatus::Failed => "Failed", }, ToolCallStatus::Rejected => "Rejected", ToolCallStatus::Canceled => "Canceled", @@ -248,86 +249,92 @@ impl Display for ToolCallStatus { } } -#[derive(Debug)] -pub enum ToolCallConfirmation { - Edit { - description: Option>, - }, - Execute { - command: String, - root_command: String, - description: Option>, - }, - Mcp { - server_name: String, - tool_name: String, - tool_display_name: String, - description: Option>, - }, - Fetch { - urls: Vec, - description: Option>, - }, - Other { - description: Entity, - }, +#[derive(Debug, PartialEq, Clone)] +pub enum ContentBlock { + Empty, + Markdown { markdown: Entity }, } -impl ToolCallConfirmation { - pub fn from_acp( - confirmation: acp::ToolCallConfirmation, +impl ContentBlock { + pub fn new( + block: acp::ContentBlock, + language_registry: &Arc, + cx: &mut App, + ) -> Self { + let mut this = Self::Empty; + this.append(block, language_registry, cx); + this + } + + pub fn new_combined( + blocks: impl IntoIterator, language_registry: Arc, cx: &mut App, ) -> Self { - let to_md = |description: String, cx: &mut App| -> Entity { - cx.new(|cx| { - Markdown::new( - description.into(), - Some(language_registry.clone()), - None, - cx, - ) - }) + let mut this = Self::Empty; + for block in blocks { + this.append(block, &language_registry, cx); + } + this + } + + pub fn append( + &mut self, + block: acp::ContentBlock, + language_registry: &Arc, + cx: &mut App, + ) { + let new_content = match block { + acp::ContentBlock::Text(text_content) => text_content.text.clone(), + acp::ContentBlock::ResourceLink(resource_link) => { + if let Some(path) = resource_link.uri.strip_prefix("file://") { + format!("{}", MentionPath(path.as_ref())) + } else { + resource_link.uri.clone() + } + } + acp::ContentBlock::Image(_) + | acp::ContentBlock::Audio(_) + | acp::ContentBlock::Resource(_) => String::new(), }; - match confirmation { - acp::ToolCallConfirmation::Edit { description } => Self::Edit { - description: description.map(|description| to_md(description, cx)), - }, - acp::ToolCallConfirmation::Execute { - command, - root_command, - description, - } => Self::Execute { - command, - root_command, - description: description.map(|description| to_md(description, cx)), - }, - acp::ToolCallConfirmation::Mcp { - server_name, - tool_name, - tool_display_name, - description, - } => Self::Mcp { - server_name, - tool_name, - tool_display_name, - description: description.map(|description| to_md(description, cx)), - }, - acp::ToolCallConfirmation::Fetch { urls, description } => Self::Fetch { - urls: urls.iter().map(|url| url.into()).collect(), - description: description.map(|description| to_md(description, cx)), - }, - acp::ToolCallConfirmation::Other { description } => Self::Other { - description: to_md(description, cx), - }, + match self { + ContentBlock::Empty => { + *self = ContentBlock::Markdown { + markdown: cx.new(|cx| { + Markdown::new( + new_content.into(), + Some(language_registry.clone()), + None, + cx, + ) + }), + }; + } + ContentBlock::Markdown { markdown } => { + markdown.update(cx, |markdown, cx| markdown.append(&new_content, cx)); + } + } + } + + fn to_markdown<'a>(&'a self, cx: &'a App) -> &'a str { + match self { + ContentBlock::Empty => "", + ContentBlock::Markdown { markdown } => markdown.read(cx).source(), + } + } + + pub fn markdown(&self) -> Option<&Entity> { + match self { + ContentBlock::Empty => None, + ContentBlock::Markdown { markdown } => Some(markdown), } } } #[derive(Debug)] pub enum ToolCallContent { - Markdown { markdown: Entity }, + ContentBlock { content: ContentBlock }, Diff { diff: Diff }, } @@ -338,8 +345,8 @@ impl ToolCallContent { cx: &mut App, ) -> Self { match content { - acp::ToolCallContent::Markdown { markdown } => Self::Markdown { - markdown: cx.new(|cx| Markdown::new_text(markdown.into(), cx)), + acp::ToolCallContent::ContentBlock { content } => Self::ContentBlock { + content: ContentBlock::new(content, &language_registry, cx), }, acp::ToolCallContent::Diff { diff } => Self::Diff { diff: Diff::from_acp(diff, language_registry, cx), @@ -347,9 +354,9 @@ impl ToolCallContent { } } - fn to_markdown(&self, cx: &App) -> String { + pub fn to_markdown(&self, cx: &App) -> String { match self { - Self::Markdown { markdown } => markdown.read(cx).source().to_string(), + Self::ContentBlock { content } => content.to_markdown(cx).to_string(), Self::Diff { diff } => diff.to_markdown(cx), } } @@ -520,8 +527,8 @@ pub struct AcpThread { action_log: Entity, shared_buffers: HashMap, BufferSnapshot>, send_task: Option>, - connection: Arc, - child_status: Option>>, + connection: Rc, + session_id: acp::SessionId, } pub enum AcpThreadEvent { @@ -563,10 +570,9 @@ impl Error for LoadError {} impl AcpThread { pub fn new( - connection: impl AgentConnection + 'static, - title: SharedString, - child_status: Option>>, + connection: Rc, project: Entity, + session_id: acp::SessionId, cx: &mut Context, ) -> Self { let action_log = cx.new(|_| ActionLog::new(project.clone())); @@ -576,24 +582,11 @@ impl AcpThread { shared_buffers: Default::default(), entries: Default::default(), plan: Default::default(), - title, + title: connection.name().into(), project, send_task: None, - connection: Arc::new(connection), - child_status, - } - } - - /// Send a request to the agent and wait for a response. - pub fn request( - &self, - params: R, - ) -> impl use + Future> { - let params = params.into_any(); - let result = self.connection.request_any(params); - async move { - let result = result.await?; - Ok(R::response_from_any(result)?) + connection, + session_id, } } @@ -629,15 +622,7 @@ impl AcpThread { for entry in self.entries.iter().rev() { match entry { AgentThreadEntry::UserMessage(_) => return false, - AgentThreadEntry::ToolCall(ToolCall { - status: - ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Running, - .. - }, - content: Some(ToolCallContent::Diff { .. }), - .. - }) => return true, + AgentThreadEntry::ToolCall(call) if call.diffs().next().is_some() => return true, AgentThreadEntry::ToolCall(_) | AgentThreadEntry::AssistantMessage(_) => {} } } @@ -652,42 +637,37 @@ impl AcpThread { pub fn push_assistant_chunk( &mut self, - chunk: acp::AssistantMessageChunk, + chunk: acp::ContentBlock, + is_thought: bool, cx: &mut Context, ) { + let language_registry = self.project.read(cx).languages().clone(); let entries_len = self.entries.len(); if let Some(last_entry) = self.entries.last_mut() && let AgentThreadEntry::AssistantMessage(AssistantMessage { chunks }) = last_entry { cx.emit(AcpThreadEvent::EntryUpdated(entries_len - 1)); - - match (chunks.last_mut(), &chunk) { - ( - Some(AssistantMessageChunk::Text { chunk: old_chunk }), - acp::AssistantMessageChunk::Text { text: new_chunk }, - ) - | ( - Some(AssistantMessageChunk::Thought { chunk: old_chunk }), - acp::AssistantMessageChunk::Thought { thought: new_chunk }, - ) => { - old_chunk.update(cx, |old_chunk, cx| { - old_chunk.append(&new_chunk, cx); - }); + match (chunks.last_mut(), is_thought) { + (Some(AssistantMessageChunk::Message { block }), false) + | (Some(AssistantMessageChunk::Thought { block }), true) => { + block.append(chunk, &language_registry, cx) } _ => { - chunks.push(AssistantMessageChunk::from_acp( - chunk, - self.project.read(cx).languages().clone(), - cx, - )); + let block = ContentBlock::new(chunk, &language_registry, cx); + if is_thought { + chunks.push(AssistantMessageChunk::Thought { block }) + } else { + chunks.push(AssistantMessageChunk::Message { block }) + } } } } else { - let chunk = AssistantMessageChunk::from_acp( - chunk, - self.project.read(cx).languages().clone(), - cx, - ); + let block = ContentBlock::new(chunk, &language_registry, cx); + let chunk = if is_thought { + AssistantMessageChunk::Thought { block } + } else { + AssistantMessageChunk::Message { block } + }; self.push_entry( AgentThreadEntry::AssistantMessage(AssistantMessage { @@ -698,122 +678,122 @@ impl AcpThread { } } - pub fn request_new_tool_call( + pub fn update_tool_call( &mut self, - tool_call: acp::RequestToolCallConfirmationParams, + id: acp::ToolCallId, + status: acp::ToolCallStatus, + content: Option>, cx: &mut Context, - ) -> ToolCallRequest { - let (tx, rx) = oneshot::channel(); + ) -> Result<()> { + let languages = self.project.read(cx).languages().clone(); + let (ix, current_call) = self.tool_call_mut(&id).context("Tool call not found")?; - let status = ToolCallStatus::WaitingForConfirmation { - confirmation: ToolCallConfirmation::from_acp( - tool_call.confirmation, - self.project.read(cx).languages().clone(), - cx, - ), - respond_tx: tx, - }; + if let Some(content) = content { + current_call.content = content + .into_iter() + .map(|chunk| ToolCallContent::from_acp(chunk, languages.clone(), cx)) + .collect(); + } + current_call.status = ToolCallStatus::Allowed { status }; - let id = self.insert_tool_call(tool_call.tool_call, status, cx); - ToolCallRequest { id, outcome: rx } + cx.emit(AcpThreadEvent::EntryUpdated(ix)); + + Ok(()) } - pub fn request_tool_call_confirmation( - &mut self, - tool_call_id: ToolCallId, - confirmation: acp::ToolCallConfirmation, - cx: &mut Context, - ) -> Result { - let project = self.project.read(cx).languages().clone(); - let Some((idx, call)) = self.tool_call_mut(tool_call_id) else { - anyhow::bail!("Tool call not found"); - }; - - let (tx, rx) = oneshot::channel(); - - call.status = ToolCallStatus::WaitingForConfirmation { - confirmation: ToolCallConfirmation::from_acp(confirmation, project, cx), - respond_tx: tx, - }; - - cx.emit(AcpThreadEvent::EntryUpdated(idx)); - - Ok(ToolCallRequest { - id: tool_call_id, - outcome: rx, - }) - } - - pub fn push_tool_call( - &mut self, - request: acp::PushToolCallParams, - cx: &mut Context, - ) -> acp::ToolCallId { + /// Updates a tool call if id matches an existing entry, otherwise inserts a new one. + pub fn upsert_tool_call(&mut self, tool_call: acp::ToolCall, cx: &mut Context) { let status = ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Running, + status: tool_call.status, }; - - self.insert_tool_call(request, status, cx) + self.upsert_tool_call_inner(tool_call, status, cx) } - fn insert_tool_call( + pub fn upsert_tool_call_inner( &mut self, - tool_call: acp::PushToolCallParams, + tool_call: acp::ToolCall, status: ToolCallStatus, cx: &mut Context, - ) -> acp::ToolCallId { + ) { let language_registry = self.project.read(cx).languages().clone(); - let id = acp::ToolCallId(self.entries.len() as u64); - let call = ToolCall { - id, - label: cx.new(|cx| { - Markdown::new( - tool_call.label.into(), - Some(language_registry.clone()), - None, - cx, - ) - }), - icon: acp_icon_to_ui_icon(tool_call.icon), - content: tool_call - .content - .map(|content| ToolCallContent::from_acp(content, language_registry, cx)), - locations: tool_call.locations, - status, - }; + let call = ToolCall::from_acp(tool_call, status, language_registry, cx); let location = call.locations.last().cloned(); + + if let Some((ix, current_call)) = self.tool_call_mut(&call.id) { + *current_call = call; + + cx.emit(AcpThreadEvent::EntryUpdated(ix)); + } else { + self.push_entry(AgentThreadEntry::ToolCall(call), cx); + } + if let Some(location) = location { self.set_project_location(location, cx) } + } - self.push_entry(AgentThreadEntry::ToolCall(call), cx); + fn tool_call_mut(&mut self, id: &acp::ToolCallId) -> Option<(usize, &mut ToolCall)> { + // The tool call we are looking for is typically the last one, or very close to the end. + // At the moment, it doesn't seem like a hashmap would be a good fit for this use case. + self.entries + .iter_mut() + .enumerate() + .rev() + .find_map(|(index, tool_call)| { + if let AgentThreadEntry::ToolCall(tool_call) = tool_call + && &tool_call.id == id + { + Some((index, tool_call)) + } else { + None + } + }) + } - id + pub fn request_tool_call_permission( + &mut self, + tool_call: acp::ToolCall, + options: Vec, + cx: &mut Context, + ) -> oneshot::Receiver { + let (tx, rx) = oneshot::channel(); + + let status = ToolCallStatus::WaitingForConfirmation { + options, + respond_tx: tx, + }; + + self.upsert_tool_call_inner(tool_call, status, cx); + rx } pub fn authorize_tool_call( &mut self, id: acp::ToolCallId, - outcome: acp::ToolCallConfirmationOutcome, + option_id: acp::PermissionOptionId, + option_kind: acp::PermissionOptionKind, cx: &mut Context, ) { - let Some((ix, call)) = self.tool_call_mut(id) else { + let Some((ix, call)) = self.tool_call_mut(&id) else { return; }; - let new_status = if outcome == acp::ToolCallConfirmationOutcome::Reject { - ToolCallStatus::Rejected - } else { - ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Running, + let new_status = match option_kind { + acp::PermissionOptionKind::RejectOnce | acp::PermissionOptionKind::RejectAlways => { + ToolCallStatus::Rejected + } + acp::PermissionOptionKind::AllowOnce | acp::PermissionOptionKind::AllowAlways => { + ToolCallStatus::Allowed { + status: acp::ToolCallStatus::InProgress, + } } }; let curr_status = mem::replace(&mut call.status, new_status); if let ToolCallStatus::WaitingForConfirmation { respond_tx, .. } = curr_status { - respond_tx.send(outcome).log_err(); + respond_tx.send(option_id).log_err(); } else if cfg!(debug_assertions) { panic!("tried to authorize an already authorized tool call"); } @@ -821,70 +801,11 @@ impl AcpThread { cx.emit(AcpThreadEvent::EntryUpdated(ix)); } - pub fn update_tool_call( - &mut self, - id: acp::ToolCallId, - new_status: acp::ToolCallStatus, - new_content: Option, - cx: &mut Context, - ) -> Result<()> { - let language_registry = self.project.read(cx).languages().clone(); - let (ix, call) = self.tool_call_mut(id).context("Entry not found")?; - - if let Some(new_content) = new_content { - call.content = Some(ToolCallContent::from_acp( - new_content, - language_registry, - cx, - )); - } - - match &mut call.status { - ToolCallStatus::Allowed { status } => { - *status = new_status; - } - ToolCallStatus::WaitingForConfirmation { .. } => { - anyhow::bail!("Tool call hasn't been authorized yet") - } - ToolCallStatus::Rejected => { - anyhow::bail!("Tool call was rejected and therefore can't be updated") - } - ToolCallStatus::Canceled => { - call.status = ToolCallStatus::Allowed { status: new_status }; - } - } - - let location = call.locations.last().cloned(); - if let Some(location) = location { - self.set_project_location(location, cx) - } - - cx.emit(AcpThreadEvent::EntryUpdated(ix)); - Ok(()) - } - - fn tool_call_mut(&mut self, id: acp::ToolCallId) -> Option<(usize, &mut ToolCall)> { - let entry = self.entries.get_mut(id.0 as usize); - debug_assert!( - entry.is_some(), - "We shouldn't give out ids to entries that don't exist" - ); - match entry { - Some(AgentThreadEntry::ToolCall(call)) if call.id == id => Some((id.0 as usize, call)), - _ => { - if cfg!(debug_assertions) { - panic!("entry is not a tool call"); - } - None - } - } - } - pub fn plan(&self) -> &Plan { &self.plan } - pub fn update_plan(&mut self, request: acp::UpdatePlanParams, cx: &mut Context) { + pub fn update_plan(&mut self, request: acp::Plan, cx: &mut Context) { self.plan = Plan { entries: request .entries @@ -896,14 +817,14 @@ impl AcpThread { cx.notify(); } - pub fn clear_completed_plan_entries(&mut self, cx: &mut Context) { + fn clear_completed_plan_entries(&mut self, cx: &mut Context) { self.plan .entries .retain(|entry| !matches!(entry.status, acp::PlanEntryStatus::Completed)); cx.notify(); } - pub fn set_project_location(&self, location: ToolCallLocation, cx: &mut Context) { + pub fn set_project_location(&self, location: acp::ToolCallLocation, cx: &mut Context) { self.project.update(cx, |project, cx| { let Some(path) = project.project_path_for_absolute_path(&location.path, cx) else { return; @@ -953,14 +874,8 @@ impl AcpThread { false } - pub fn initialize(&self) -> impl use<> + Future> { - self.request(acp::InitializeParams { - protocol_version: ProtocolVersion::latest(), - }) - } - - pub fn authenticate(&self) -> impl use<> + Future> { - self.request(acp::AuthenticateParams) + pub fn authenticate(&self, cx: &mut App) -> impl use<> + Future> { + self.connection.authenticate(cx) } #[cfg(any(test, feature = "test-support"))] @@ -968,39 +883,50 @@ impl AcpThread { &mut self, message: &str, cx: &mut Context, - ) -> BoxFuture<'static, Result<(), acp::Error>> { + ) -> BoxFuture<'static, Result<()>> { self.send( - acp::SendUserMessageParams { - chunks: vec![acp::UserMessageChunk::Text { - text: message.to_string(), - }], - }, + vec![acp::ContentBlock::Text(acp::TextContent { + text: message.to_string(), + annotations: None, + })], cx, ) } pub fn send( &mut self, - message: acp::SendUserMessageParams, + message: Vec, cx: &mut Context, - ) -> BoxFuture<'static, Result<(), acp::Error>> { - self.push_entry( - AgentThreadEntry::UserMessage(UserMessage::from_acp( - &message, - self.project.read(cx).languages().clone(), - cx, - )), + ) -> BoxFuture<'static, Result<()>> { + let block = ContentBlock::new_combined( + message.clone(), + self.project.read(cx).languages().clone(), cx, ); + self.push_entry( + AgentThreadEntry::UserMessage(UserMessage { content: block }), + cx, + ); + self.clear_completed_plan_entries(cx); let (tx, rx) = oneshot::channel(); - let cancel = self.cancel(cx); + let cancel_task = self.cancel(cx); self.send_task = Some(cx.spawn(async move |this, cx| { async { - cancel.await.log_err(); + cancel_task.await; - let result = this.update(cx, |this, _| this.request(message))?.await; + let result = this + .update(cx, |this, cx| { + this.connection.prompt( + acp::PromptToolArguments { + prompt: message, + session_id: this.session_id.clone(), + }, + cx, + ) + })? + .await; tx.send(result).log_err(); this.update(cx, |this, _cx| this.send_task.take())?; anyhow::Ok(()) @@ -1018,48 +944,38 @@ impl AcpThread { .boxed() } - pub fn cancel(&mut self, cx: &mut Context) -> Task> { - if self.send_task.take().is_some() { - let request = self.request(acp::CancelSendMessageParams); - cx.spawn(async move |this, cx| { - request.await?; - this.update(cx, |this, _cx| { - for entry in this.entries.iter_mut() { - if let AgentThreadEntry::ToolCall(call) = entry { - let cancel = matches!( - call.status, - ToolCallStatus::WaitingForConfirmation { .. } - | ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Running - } - ); + pub fn cancel(&mut self, cx: &mut Context) -> Task<()> { + let Some(send_task) = self.send_task.take() else { + return Task::ready(()); + }; - if cancel { - let curr_status = - mem::replace(&mut call.status, ToolCallStatus::Canceled); - - if let ToolCallStatus::WaitingForConfirmation { - respond_tx, .. - } = curr_status - { - respond_tx - .send(acp::ToolCallConfirmationOutcome::Cancel) - .ok(); - } - } + for entry in self.entries.iter_mut() { + if let AgentThreadEntry::ToolCall(call) = entry { + let cancel = matches!( + call.status, + ToolCallStatus::WaitingForConfirmation { .. } + | ToolCallStatus::Allowed { + status: acp::ToolCallStatus::InProgress } - } - })?; - Ok(()) - }) - } else { - Task::ready(Ok(())) + ); + + if cancel { + call.status = ToolCallStatus::Canceled; + } + } } + + self.connection.cancel(&self.session_id, cx); + + // Wait for the send task to complete + cx.foreground_executor().spawn(send_task) } pub fn read_text_file( &self, - request: acp::ReadTextFileParams, + path: PathBuf, + line: Option, + limit: Option, reuse_shared_snapshot: bool, cx: &mut Context, ) -> Task> { @@ -1068,7 +984,7 @@ impl AcpThread { cx.spawn(async move |this, cx| { let load = project.update(cx, |project, cx| { let path = project - .project_path_for_absolute_path(&request.path, cx) + .project_path_for_absolute_path(&path, cx) .context("invalid path")?; anyhow::Ok(project.open_buffer(path, cx)) }); @@ -1094,7 +1010,7 @@ impl AcpThread { let position = buffer .read(cx) .snapshot() - .anchor_before(Point::new(request.line.unwrap_or_default(), 0)); + .anchor_before(Point::new(line.unwrap_or_default(), 0)); project.set_agent_location( Some(AgentLocation { buffer: buffer.downgrade(), @@ -1110,11 +1026,11 @@ impl AcpThread { this.update(cx, |this, _| { let text = snapshot.text(); this.shared_buffers.insert(buffer.clone(), snapshot); - if request.line.is_none() && request.limit.is_none() { + if line.is_none() && limit.is_none() { return Ok(text); } - let limit = request.limit.unwrap_or(u32::MAX) as usize; - let Some(line) = request.line else { + let limit = limit.unwrap_or(u32::MAX) as usize; + let Some(line) = line else { return Ok(text.lines().take(limit).collect::()); }; @@ -1199,197 +1115,15 @@ impl AcpThread { }) } - pub fn child_status(&mut self) -> Option>> { - self.child_status.take() - } - pub fn to_markdown(&self, cx: &App) -> String { self.entries.iter().map(|e| e.to_markdown(cx)).collect() } } -#[derive(Clone)] -pub struct AcpClientDelegate { - thread: WeakEntity, - cx: AsyncApp, - // sent_buffer_versions: HashMap, HashMap>, -} - -impl AcpClientDelegate { - pub fn new(thread: WeakEntity, cx: AsyncApp) -> Self { - Self { thread, cx } - } - - pub async fn clear_completed_plan_entries(&self) -> Result<()> { - let cx = &mut self.cx.clone(); - cx.update(|cx| { - self.thread - .update(cx, |thread, cx| thread.clear_completed_plan_entries(cx)) - })? - .context("Failed to update thread")?; - - Ok(()) - } - - pub async fn request_existing_tool_call_confirmation( - &self, - tool_call_id: ToolCallId, - confirmation: acp::ToolCallConfirmation, - ) -> Result { - let cx = &mut self.cx.clone(); - let ToolCallRequest { outcome, .. } = cx - .update(|cx| { - self.thread.update(cx, |thread, cx| { - thread.request_tool_call_confirmation(tool_call_id, confirmation, cx) - }) - })? - .context("Failed to update thread")??; - - Ok(outcome.await?) - } - - pub async fn read_text_file_reusing_snapshot( - &self, - request: acp::ReadTextFileParams, - ) -> Result { - let content = self - .cx - .update(|cx| { - self.thread - .update(cx, |thread, cx| thread.read_text_file(request, true, cx)) - })? - .context("Failed to update thread")? - .await?; - Ok(acp::ReadTextFileResponse { content }) - } -} - -impl acp::Client for AcpClientDelegate { - async fn stream_assistant_message_chunk( - &self, - params: acp::StreamAssistantMessageChunkParams, - ) -> Result<(), acp::Error> { - let cx = &mut self.cx.clone(); - - cx.update(|cx| { - self.thread - .update(cx, |thread, cx| { - thread.push_assistant_chunk(params.chunk, cx) - }) - .ok(); - })?; - - Ok(()) - } - - async fn request_tool_call_confirmation( - &self, - request: acp::RequestToolCallConfirmationParams, - ) -> Result { - let cx = &mut self.cx.clone(); - let ToolCallRequest { id, outcome } = cx - .update(|cx| { - self.thread - .update(cx, |thread, cx| thread.request_new_tool_call(request, cx)) - })? - .context("Failed to update thread")?; - - Ok(acp::RequestToolCallConfirmationResponse { - id, - outcome: outcome.await.map_err(acp::Error::into_internal_error)?, - }) - } - - async fn push_tool_call( - &self, - request: acp::PushToolCallParams, - ) -> Result { - let cx = &mut self.cx.clone(); - let id = cx - .update(|cx| { - self.thread - .update(cx, |thread, cx| thread.push_tool_call(request, cx)) - })? - .context("Failed to update thread")?; - - Ok(acp::PushToolCallResponse { id }) - } - - async fn update_tool_call(&self, request: acp::UpdateToolCallParams) -> Result<(), acp::Error> { - let cx = &mut self.cx.clone(); - - cx.update(|cx| { - self.thread.update(cx, |thread, cx| { - thread.update_tool_call(request.tool_call_id, request.status, request.content, cx) - }) - })? - .context("Failed to update thread")??; - - Ok(()) - } - - async fn update_plan(&self, request: acp::UpdatePlanParams) -> Result<(), acp::Error> { - let cx = &mut self.cx.clone(); - - cx.update(|cx| { - self.thread - .update(cx, |thread, cx| thread.update_plan(request, cx)) - })? - .context("Failed to update thread")?; - - Ok(()) - } - - async fn read_text_file( - &self, - request: acp::ReadTextFileParams, - ) -> Result { - let content = self - .cx - .update(|cx| { - self.thread - .update(cx, |thread, cx| thread.read_text_file(request, false, cx)) - })? - .context("Failed to update thread")? - .await?; - Ok(acp::ReadTextFileResponse { content }) - } - - async fn write_text_file(&self, request: acp::WriteTextFileParams) -> Result<(), acp::Error> { - self.cx - .update(|cx| { - self.thread.update(cx, |thread, cx| { - thread.write_text_file(request.path, request.content, cx) - }) - })? - .context("Failed to update thread")? - .await?; - - Ok(()) - } -} - -fn acp_icon_to_ui_icon(icon: acp::Icon) -> IconName { - match icon { - acp::Icon::FileSearch => IconName::ToolSearch, - acp::Icon::Folder => IconName::ToolFolder, - acp::Icon::Globe => IconName::ToolWeb, - acp::Icon::Hammer => IconName::ToolHammer, - acp::Icon::LightBulb => IconName::ToolBulb, - acp::Icon::Pencil => IconName::ToolPencil, - acp::Icon::Regex => IconName::ToolRegex, - acp::Icon::Terminal => IconName::ToolTerminal, - } -} - -pub struct ToolCallRequest { - pub id: acp::ToolCallId, - pub outcome: oneshot::Receiver, -} - #[cfg(test)] mod tests { use super::*; + use agentic_coding_protocol as acp_old; use anyhow::anyhow; use async_pipe::{PipeReader, PipeWriter}; use futures::{channel::mpsc, future::LocalBoxFuture, select}; @@ -1400,6 +1134,7 @@ mod tests { use settings::SettingsStore; use smol::{future::BoxedLocal, stream::StreamExt as _}; use std::{cell::RefCell, rc::Rc, time::Duration}; + use util::path; fn init_test(cx: &mut TestAppContext) { @@ -1424,8 +1159,8 @@ mod tests { fake_server.on_user_message(move |_, server, mut cx| async move { server .update(&mut cx, |server, _| { - server.send_to_zed(acp::StreamAssistantMessageChunkParams { - chunk: acp::AssistantMessageChunk::Thought { + server.send_to_zed(acp_old::StreamAssistantMessageChunkParams { + chunk: acp_old::AssistantMessageChunk::Thought { thought: "Thinking ".into(), }, }) @@ -1434,8 +1169,8 @@ mod tests { .unwrap(); server .update(&mut cx, |server, _| { - server.send_to_zed(acp::StreamAssistantMessageChunkParams { - chunk: acp::AssistantMessageChunk::Thought { + server.send_to_zed(acp_old::StreamAssistantMessageChunkParams { + chunk: acp_old::AssistantMessageChunk::Thought { thought: "hard!".into(), }, }) @@ -1501,7 +1236,7 @@ mod tests { async move { let content = server .update(&mut cx, |server, _| { - server.send_to_zed(acp::ReadTextFileParams { + server.send_to_zed(acp_old::ReadTextFileParams { path: path!("/tmp/foo").into(), line: None, limit: None, @@ -1513,7 +1248,7 @@ mod tests { read_file_tx.take().unwrap().send(()).unwrap(); server .update(&mut cx, |server, _| { - server.send_to_zed(acp::WriteTextFileParams { + server.send_to_zed(acp_old::WriteTextFileParams { path: path!("/tmp/foo").into(), content: "one\ntwo\nthree\nfour\nfive\n".to_string(), }) @@ -1564,9 +1299,9 @@ mod tests { async move { let tool_call_result = server .update(&mut cx, |server, _| { - server.send_to_zed(acp::PushToolCallParams { + server.send_to_zed(acp_old::PushToolCallParams { label: "Fetch".to_string(), - icon: acp::Icon::Globe, + icon: acp_old::Icon::Globe, content: None, locations: vec![], }) @@ -1592,7 +1327,7 @@ mod tests { thread.entries[1], AgentThreadEntry::ToolCall(ToolCall { status: ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Running, + status: acp::ToolCallStatus::InProgress, .. }, .. @@ -1602,10 +1337,7 @@ mod tests { cx.run_until_parked(); - thread - .update(cx, |thread, cx| thread.cancel(cx)) - .await - .unwrap(); + thread.update(cx, |thread, cx| thread.cancel(cx)).await; thread.read_with(cx, |thread, _| { assert!(matches!( @@ -1619,9 +1351,9 @@ mod tests { fake_server .update(cx, |fake_server, _| { - fake_server.send_to_zed(acp::UpdateToolCallParams { + fake_server.send_to_zed(acp_old::UpdateToolCallParams { tool_call_id: tool_call_id.borrow().unwrap(), - status: acp::ToolCallStatus::Finished, + status: acp_old::ToolCallStatus::Finished, content: None, }) }) @@ -1629,14 +1361,14 @@ mod tests { .unwrap(); drop(end_turn_tx); - request.await.unwrap(); + assert!(request.await.unwrap_err().to_string().contains("canceled")); thread.read_with(cx, |thread, _| { assert!(matches!( thread.entries[1], AgentThreadEntry::ToolCall(ToolCall { status: ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Finished, + status: acp::ToolCallStatus::Completed, .. }, .. @@ -1681,8 +1413,10 @@ mod tests { let thread = cx.new(|cx| { let foreground_executor = cx.foreground_executor().clone(); - let (connection, io_fut) = acp::AgentConnection::connect_to_agent( - AcpClientDelegate::new(cx.entity().downgrade(), cx.to_async()), + let thread_rc = Rc::new(RefCell::new(cx.entity().downgrade())); + + let (connection, io_fut) = acp_old::AgentConnection::connect_to_agent( + OldAcpClientDelegate::new(thread_rc.clone(), cx.to_async()), stdin_tx, stdout_rx, move |fut| { @@ -1696,23 +1430,34 @@ mod tests { Ok(()) } }); - AcpThread::new(connection, "Test".into(), Some(io_task), project, cx) + let connection = OldAcpAgentConnection { + name: "test", + connection, + child_status: io_task, + }; + + AcpThread::new( + Rc::new(connection), + project, + acp::SessionId("test".into()), + cx, + ) }); let agent = cx.update(|cx| cx.new(|cx| FakeAcpServer::new(stdin_rx, stdout_tx, cx))); (thread, agent) } pub struct FakeAcpServer { - connection: acp::ClientConnection, + connection: acp_old::ClientConnection, _io_task: Task<()>, on_user_message: Option< Rc< dyn Fn( - acp::SendUserMessageParams, + acp_old::SendUserMessageParams, Entity, AsyncApp, - ) -> LocalBoxFuture<'static, Result<(), acp::Error>>, + ) -> LocalBoxFuture<'static, Result<(), acp_old::Error>>, >, >, } @@ -1721,31 +1466,38 @@ mod tests { struct FakeAgent { server: Entity, cx: AsyncApp, + cancel_tx: Rc>>>, } - impl acp::Agent for FakeAgent { + impl acp_old::Agent for FakeAgent { async fn initialize( &self, - params: acp::InitializeParams, - ) -> Result { - Ok(acp::InitializeResponse { + params: acp_old::InitializeParams, + ) -> Result { + Ok(acp_old::InitializeResponse { protocol_version: params.protocol_version, is_authenticated: true, }) } - async fn authenticate(&self) -> Result<(), acp::Error> { + async fn authenticate(&self) -> Result<(), acp_old::Error> { Ok(()) } - async fn cancel_send_message(&self) -> Result<(), acp::Error> { + async fn cancel_send_message(&self) -> Result<(), acp_old::Error> { + if let Some(cancel_tx) = self.cancel_tx.take() { + cancel_tx.send(()).log_err(); + } Ok(()) } async fn send_user_message( &self, - request: acp::SendUserMessageParams, - ) -> Result<(), acp::Error> { + request: acp_old::SendUserMessageParams, + ) -> Result<(), acp_old::Error> { + let (cancel_tx, cancel_rx) = oneshot::channel(); + self.cancel_tx.replace(Some(cancel_tx)); + let mut cx = self.cx.clone(); let handler = self .server @@ -1753,7 +1505,10 @@ mod tests { .ok() .flatten(); if let Some(handler) = handler { - handler(request, self.server.clone(), self.cx.clone()).await + select! { + _ = cancel_rx.fuse() => Err(anyhow::anyhow!("Message sending canceled").into()), + _ = handler(request, self.server.clone(), self.cx.clone()).fuse() => Ok(()), + } } else { Err(anyhow::anyhow!("No handler for on_user_message").into()) } @@ -1765,10 +1520,11 @@ mod tests { let agent = FakeAgent { server: cx.entity(), cx: cx.to_async(), + cancel_tx: Default::default(), }; let foreground_executor = cx.foreground_executor().clone(); - let (connection, io_fut) = acp::ClientConnection::connect_to_client( + let (connection, io_fut) = acp_old::ClientConnection::connect_to_client( agent.clone(), stdout, stdin, @@ -1787,10 +1543,14 @@ mod tests { fn on_user_message( &mut self, - handler: impl for<'a> Fn(acp::SendUserMessageParams, Entity, AsyncApp) -> F + handler: impl for<'a> Fn( + acp_old::SendUserMessageParams, + Entity, + AsyncApp, + ) -> F + 'static, ) where - F: Future> + 'static, + F: Future> + 'static, { self.on_user_message .replace(Rc::new(move |request, server, cx| { @@ -1798,7 +1558,7 @@ mod tests { })); } - fn send_to_zed( + fn send_to_zed( &self, message: T, ) -> BoxedLocal> { diff --git a/crates/acp_thread/src/connection.rs b/crates/acp_thread/src/connection.rs index 7c0ba4f41c..fde167da5f 100644 --- a/crates/acp_thread/src/connection.rs +++ b/crates/acp_thread/src/connection.rs @@ -1,20 +1,26 @@ -use agentic_coding_protocol as acp; +use std::{path::Path, rc::Rc}; + +use agent_client_protocol as acp; use anyhow::Result; -use futures::future::{FutureExt as _, LocalBoxFuture}; +use gpui::{AsyncApp, Entity, Task}; +use project::Project; +use ui::App; + +use crate::AcpThread; pub trait AgentConnection { - fn request_any( - &self, - params: acp::AnyAgentRequest, - ) -> LocalBoxFuture<'static, Result>; -} + fn name(&self) -> &'static str; -impl AgentConnection for acp::AgentConnection { - fn request_any( - &self, - params: acp::AnyAgentRequest, - ) -> LocalBoxFuture<'static, Result> { - let task = self.request_any(params); - async move { Ok(task.await?) }.boxed_local() - } + fn new_thread( + self: Rc, + project: Entity, + cwd: &Path, + cx: &mut AsyncApp, + ) -> Task>>; + + fn authenticate(&self, cx: &mut App) -> Task>; + + fn prompt(&self, params: acp::PromptToolArguments, cx: &mut App) -> Task>; + + fn cancel(&self, session_id: &acp::SessionId, cx: &mut App); } diff --git a/crates/acp_thread/src/old_acp_support.rs b/crates/acp_thread/src/old_acp_support.rs new file mode 100644 index 0000000000..316a5bcf25 --- /dev/null +++ b/crates/acp_thread/src/old_acp_support.rs @@ -0,0 +1,461 @@ +// Translates old acp agents into the new schema +use agent_client_protocol as acp; +use agentic_coding_protocol::{self as acp_old, AgentRequest as _}; +use anyhow::{Context as _, Result}; +use futures::channel::oneshot; +use gpui::{AppContext as _, AsyncApp, Entity, Task, WeakEntity}; +use project::Project; +use std::{cell::RefCell, error::Error, fmt, path::Path, rc::Rc}; +use ui::App; + +use crate::{AcpThread, AcpThreadEvent, AgentConnection, ToolCallContent, ToolCallStatus}; + +#[derive(Clone)] +pub struct OldAcpClientDelegate { + thread: Rc>>, + cx: AsyncApp, + next_tool_call_id: Rc>, + // sent_buffer_versions: HashMap, HashMap>, +} + +impl OldAcpClientDelegate { + pub fn new(thread: Rc>>, cx: AsyncApp) -> Self { + Self { + thread, + cx, + next_tool_call_id: Rc::new(RefCell::new(0)), + } + } +} + +impl acp_old::Client for OldAcpClientDelegate { + async fn stream_assistant_message_chunk( + &self, + params: acp_old::StreamAssistantMessageChunkParams, + ) -> Result<(), acp_old::Error> { + let cx = &mut self.cx.clone(); + + cx.update(|cx| { + self.thread + .borrow() + .update(cx, |thread, cx| match params.chunk { + acp_old::AssistantMessageChunk::Text { text } => { + thread.push_assistant_chunk(text.into(), false, cx) + } + acp_old::AssistantMessageChunk::Thought { thought } => { + thread.push_assistant_chunk(thought.into(), true, cx) + } + }) + .ok(); + })?; + + Ok(()) + } + + async fn request_tool_call_confirmation( + &self, + request: acp_old::RequestToolCallConfirmationParams, + ) -> Result { + let cx = &mut self.cx.clone(); + + let old_acp_id = *self.next_tool_call_id.borrow() + 1; + self.next_tool_call_id.replace(old_acp_id); + + let tool_call = into_new_tool_call( + acp::ToolCallId(old_acp_id.to_string().into()), + request.tool_call, + ); + + let mut options = match request.confirmation { + acp_old::ToolCallConfirmation::Edit { .. } => vec![( + acp_old::ToolCallConfirmationOutcome::AlwaysAllow, + acp::PermissionOptionKind::AllowAlways, + "Always Allow Edits".to_string(), + )], + acp_old::ToolCallConfirmation::Execute { root_command, .. } => vec![( + acp_old::ToolCallConfirmationOutcome::AlwaysAllow, + acp::PermissionOptionKind::AllowAlways, + format!("Always Allow {}", root_command), + )], + acp_old::ToolCallConfirmation::Mcp { + server_name, + tool_name, + .. + } => vec![ + ( + acp_old::ToolCallConfirmationOutcome::AlwaysAllowMcpServer, + acp::PermissionOptionKind::AllowAlways, + format!("Always Allow {}", server_name), + ), + ( + acp_old::ToolCallConfirmationOutcome::AlwaysAllowTool, + acp::PermissionOptionKind::AllowAlways, + format!("Always Allow {}", tool_name), + ), + ], + acp_old::ToolCallConfirmation::Fetch { .. } => vec![( + acp_old::ToolCallConfirmationOutcome::AlwaysAllow, + acp::PermissionOptionKind::AllowAlways, + "Always Allow".to_string(), + )], + acp_old::ToolCallConfirmation::Other { .. } => vec![( + acp_old::ToolCallConfirmationOutcome::AlwaysAllow, + acp::PermissionOptionKind::AllowAlways, + "Always Allow".to_string(), + )], + }; + + options.extend([ + ( + acp_old::ToolCallConfirmationOutcome::Allow, + acp::PermissionOptionKind::AllowOnce, + "Allow".to_string(), + ), + ( + acp_old::ToolCallConfirmationOutcome::Reject, + acp::PermissionOptionKind::RejectOnce, + "Reject".to_string(), + ), + ]); + + let mut outcomes = Vec::with_capacity(options.len()); + let mut acp_options = Vec::with_capacity(options.len()); + + for (index, (outcome, kind, label)) in options.into_iter().enumerate() { + outcomes.push(outcome); + acp_options.push(acp::PermissionOption { + id: acp::PermissionOptionId(index.to_string().into()), + label, + kind, + }) + } + + let response = cx + .update(|cx| { + self.thread.borrow().update(cx, |thread, cx| { + thread.request_tool_call_permission(tool_call, acp_options, cx) + }) + })? + .context("Failed to update thread")? + .await; + + let outcome = match response { + Ok(option_id) => outcomes[option_id.0.parse::().unwrap_or(0)], + Err(oneshot::Canceled) => acp_old::ToolCallConfirmationOutcome::Cancel, + }; + + Ok(acp_old::RequestToolCallConfirmationResponse { + id: acp_old::ToolCallId(old_acp_id), + outcome: outcome, + }) + } + + async fn push_tool_call( + &self, + request: acp_old::PushToolCallParams, + ) -> Result { + let cx = &mut self.cx.clone(); + + let old_acp_id = *self.next_tool_call_id.borrow() + 1; + self.next_tool_call_id.replace(old_acp_id); + + cx.update(|cx| { + self.thread.borrow().update(cx, |thread, cx| { + thread.upsert_tool_call( + into_new_tool_call(acp::ToolCallId(old_acp_id.to_string().into()), request), + cx, + ) + }) + })? + .context("Failed to update thread")?; + + Ok(acp_old::PushToolCallResponse { + id: acp_old::ToolCallId(old_acp_id), + }) + } + + async fn update_tool_call( + &self, + request: acp_old::UpdateToolCallParams, + ) -> Result<(), acp_old::Error> { + let cx = &mut self.cx.clone(); + + cx.update(|cx| { + self.thread.borrow().update(cx, |thread, cx| { + let languages = thread.project.read(cx).languages().clone(); + + if let Some((ix, tool_call)) = thread + .tool_call_mut(&acp::ToolCallId(request.tool_call_id.0.to_string().into())) + { + tool_call.status = ToolCallStatus::Allowed { + status: into_new_tool_call_status(request.status), + }; + tool_call.content = request + .content + .into_iter() + .map(|content| { + ToolCallContent::from_acp( + into_new_tool_call_content(content), + languages.clone(), + cx, + ) + }) + .collect(); + + cx.emit(AcpThreadEvent::EntryUpdated(ix)); + anyhow::Ok(()) + } else { + anyhow::bail!("Tool call not found") + } + }) + })? + .context("Failed to update thread")??; + + Ok(()) + } + + async fn update_plan(&self, request: acp_old::UpdatePlanParams) -> Result<(), acp_old::Error> { + let cx = &mut self.cx.clone(); + + cx.update(|cx| { + self.thread.borrow().update(cx, |thread, cx| { + thread.update_plan( + acp::Plan { + entries: request + .entries + .into_iter() + .map(into_new_plan_entry) + .collect(), + }, + cx, + ) + }) + })? + .context("Failed to update thread")?; + + Ok(()) + } + + async fn read_text_file( + &self, + acp_old::ReadTextFileParams { path, line, limit }: acp_old::ReadTextFileParams, + ) -> Result { + let content = self + .cx + .update(|cx| { + self.thread.borrow().update(cx, |thread, cx| { + thread.read_text_file(path, line, limit, false, cx) + }) + })? + .context("Failed to update thread")? + .await?; + Ok(acp_old::ReadTextFileResponse { content }) + } + + async fn write_text_file( + &self, + acp_old::WriteTextFileParams { path, content }: acp_old::WriteTextFileParams, + ) -> Result<(), acp_old::Error> { + self.cx + .update(|cx| { + self.thread + .borrow() + .update(cx, |thread, cx| thread.write_text_file(path, content, cx)) + })? + .context("Failed to update thread")? + .await?; + + Ok(()) + } +} + +fn into_new_tool_call(id: acp::ToolCallId, request: acp_old::PushToolCallParams) -> acp::ToolCall { + acp::ToolCall { + id: id, + label: request.label, + kind: acp_kind_from_old_icon(request.icon), + status: acp::ToolCallStatus::InProgress, + content: request + .content + .into_iter() + .map(into_new_tool_call_content) + .collect(), + locations: request + .locations + .into_iter() + .map(into_new_tool_call_location) + .collect(), + } +} + +fn acp_kind_from_old_icon(icon: acp_old::Icon) -> acp::ToolKind { + match icon { + acp_old::Icon::FileSearch => acp::ToolKind::Search, + acp_old::Icon::Folder => acp::ToolKind::Search, + acp_old::Icon::Globe => acp::ToolKind::Search, + acp_old::Icon::Hammer => acp::ToolKind::Other, + acp_old::Icon::LightBulb => acp::ToolKind::Think, + acp_old::Icon::Pencil => acp::ToolKind::Edit, + acp_old::Icon::Regex => acp::ToolKind::Search, + acp_old::Icon::Terminal => acp::ToolKind::Execute, + } +} + +fn into_new_tool_call_status(status: acp_old::ToolCallStatus) -> acp::ToolCallStatus { + match status { + acp_old::ToolCallStatus::Running => acp::ToolCallStatus::InProgress, + acp_old::ToolCallStatus::Finished => acp::ToolCallStatus::Completed, + acp_old::ToolCallStatus::Error => acp::ToolCallStatus::Failed, + } +} + +fn into_new_tool_call_content(content: acp_old::ToolCallContent) -> acp::ToolCallContent { + match content { + acp_old::ToolCallContent::Markdown { markdown } => acp::ToolCallContent::ContentBlock { + content: acp::ContentBlock::Text(acp::TextContent { + annotations: None, + text: markdown, + }), + }, + acp_old::ToolCallContent::Diff { diff } => acp::ToolCallContent::Diff { + diff: into_new_diff(diff), + }, + } +} + +fn into_new_diff(diff: acp_old::Diff) -> acp::Diff { + acp::Diff { + path: diff.path, + old_text: diff.old_text, + new_text: diff.new_text, + } +} + +fn into_new_tool_call_location(location: acp_old::ToolCallLocation) -> acp::ToolCallLocation { + acp::ToolCallLocation { + path: location.path, + line: location.line, + } +} + +fn into_new_plan_entry(entry: acp_old::PlanEntry) -> acp::PlanEntry { + acp::PlanEntry { + content: entry.content, + priority: into_new_plan_priority(entry.priority), + status: into_new_plan_status(entry.status), + } +} + +fn into_new_plan_priority(priority: acp_old::PlanEntryPriority) -> acp::PlanEntryPriority { + match priority { + acp_old::PlanEntryPriority::Low => acp::PlanEntryPriority::Low, + acp_old::PlanEntryPriority::Medium => acp::PlanEntryPriority::Medium, + acp_old::PlanEntryPriority::High => acp::PlanEntryPriority::High, + } +} + +fn into_new_plan_status(status: acp_old::PlanEntryStatus) -> acp::PlanEntryStatus { + match status { + acp_old::PlanEntryStatus::Pending => acp::PlanEntryStatus::Pending, + acp_old::PlanEntryStatus::InProgress => acp::PlanEntryStatus::InProgress, + acp_old::PlanEntryStatus::Completed => acp::PlanEntryStatus::Completed, + } +} + +#[derive(Debug)] +pub struct Unauthenticated; + +impl Error for Unauthenticated {} +impl fmt::Display for Unauthenticated { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "Unauthenticated") + } +} + +pub struct OldAcpAgentConnection { + pub name: &'static str, + pub connection: acp_old::AgentConnection, + pub child_status: Task>, +} + +impl AgentConnection for OldAcpAgentConnection { + fn name(&self) -> &'static str { + self.name + } + + fn new_thread( + self: Rc, + project: Entity, + _cwd: &Path, + cx: &mut AsyncApp, + ) -> Task>> { + let task = self.connection.request_any( + acp_old::InitializeParams { + protocol_version: acp_old::ProtocolVersion::latest(), + } + .into_any(), + ); + cx.spawn(async move |cx| { + let result = task.await?; + let result = acp_old::InitializeParams::response_from_any(result)?; + + if !result.is_authenticated { + anyhow::bail!(Unauthenticated) + } + + cx.update(|cx| { + let thread = cx.new(|cx| { + let session_id = acp::SessionId("acp-old-no-id".into()); + AcpThread::new(self.clone(), project, session_id, cx) + }); + thread + }) + }) + } + + fn authenticate(&self, cx: &mut App) -> Task> { + let task = self + .connection + .request_any(acp_old::AuthenticateParams.into_any()); + cx.foreground_executor().spawn(async move { + task.await?; + Ok(()) + }) + } + + fn prompt(&self, params: acp::PromptToolArguments, cx: &mut App) -> Task> { + let chunks = params + .prompt + .into_iter() + .filter_map(|block| match block { + acp::ContentBlock::Text(text) => { + Some(acp_old::UserMessageChunk::Text { text: text.text }) + } + acp::ContentBlock::ResourceLink(link) => Some(acp_old::UserMessageChunk::Path { + path: link.uri.into(), + }), + _ => None, + }) + .collect(); + + let task = self + .connection + .request_any(acp_old::SendUserMessageParams { chunks }.into_any()); + cx.foreground_executor().spawn(async move { + task.await?; + anyhow::Ok(()) + }) + } + + fn cancel(&self, _session_id: &acp::SessionId, cx: &mut App) { + let task = self + .connection + .request_any(acp_old::CancelSendMessageParams.into_any()); + cx.foreground_executor() + .spawn(async move { + task.await?; + anyhow::Ok(()) + }) + .detach_and_log_err(cx) + } +} diff --git a/crates/agent_servers/Cargo.toml b/crates/agent_servers/Cargo.toml index 4714245b94..4371f7684d 100644 --- a/crates/agent_servers/Cargo.toml +++ b/crates/agent_servers/Cargo.toml @@ -18,6 +18,7 @@ doctest = false [dependencies] acp_thread.workspace = true +agent-client-protocol.workspace = true agentic-coding-protocol.workspace = true anyhow.workspace = true collections.workspace = true diff --git a/crates/agent_servers/src/agent_servers.rs b/crates/agent_servers/src/agent_servers.rs index 6d9c77f296..660f61f907 100644 --- a/crates/agent_servers/src/agent_servers.rs +++ b/crates/agent_servers/src/agent_servers.rs @@ -1,7 +1,6 @@ mod claude; mod gemini; mod settings; -mod stdio_agent_server; #[cfg(test)] mod e2e_tests; @@ -9,9 +8,8 @@ mod e2e_tests; pub use claude::*; pub use gemini::*; pub use settings::*; -pub use stdio_agent_server::*; -use acp_thread::AcpThread; +use acp_thread::AgentConnection; use anyhow::Result; use collections::HashMap; use gpui::{App, AsyncApp, Entity, SharedString, Task}; @@ -20,6 +18,7 @@ use schemars::JsonSchema; use serde::{Deserialize, Serialize}; use std::{ path::{Path, PathBuf}, + rc::Rc, sync::Arc, }; use util::ResultExt as _; @@ -33,14 +32,14 @@ pub trait AgentServer: Send { fn name(&self) -> &'static str; fn empty_state_headline(&self) -> &'static str; fn empty_state_message(&self) -> &'static str; - fn supports_always_allow(&self) -> bool; - fn new_thread( + fn connect( &self, + // these will go away when old_acp is fully removed root_dir: &Path, project: &Entity, cx: &mut App, - ) -> Task>>; + ) -> Task>>; } impl std::fmt::Debug for AgentServerCommand { diff --git a/crates/agent_servers/src/claude.rs b/crates/agent_servers/src/claude.rs index 835efbd655..5f35b4af73 100644 --- a/crates/agent_servers/src/claude.rs +++ b/crates/agent_servers/src/claude.rs @@ -1,5 +1,5 @@ mod mcp_server; -mod tools; +pub mod tools; use collections::HashMap; use project::Project; @@ -12,28 +12,24 @@ use std::pin::pin; use std::rc::Rc; use uuid::Uuid; -use agentic_coding_protocol::{ - self as acp, AnyAgentRequest, AnyAgentResult, Client, ProtocolVersion, - StreamAssistantMessageChunkParams, ToolCallContent, UpdateToolCallParams, -}; +use agent_client_protocol as acp; use anyhow::{Result, anyhow}; use futures::channel::oneshot; -use futures::future::LocalBoxFuture; -use futures::{AsyncBufReadExt, AsyncWriteExt, SinkExt}; +use futures::{AsyncBufReadExt, AsyncWriteExt}; use futures::{ AsyncRead, AsyncWrite, FutureExt, StreamExt, channel::mpsc::{self, UnboundedReceiver, UnboundedSender}, io::BufReader, select_biased, }; -use gpui::{App, AppContext, Entity, Task}; +use gpui::{App, AppContext, AsyncApp, Entity, Task, WeakEntity}; use serde::{Deserialize, Serialize}; use util::ResultExt; -use crate::claude::mcp_server::ClaudeMcpServer; +use crate::claude::mcp_server::{ClaudeZedMcpServer, McpConfig}; use crate::claude::tools::ClaudeTool; use crate::{AgentServer, AgentServerCommand, AllAgentServersSettings}; -use acp_thread::{AcpClientDelegate, AcpThread, AgentConnection}; +use acp_thread::{AcpThread, AgentConnection}; #[derive(Clone)] pub struct ClaudeCode; @@ -55,29 +51,57 @@ impl AgentServer for ClaudeCode { ui::IconName::AiClaude } - fn supports_always_allow(&self) -> bool { - false + fn connect( + &self, + _root_dir: &Path, + _project: &Entity, + _cx: &mut App, + ) -> Task>> { + let connection = ClaudeAgentConnection { + sessions: Default::default(), + }; + + Task::ready(Ok(Rc::new(connection) as _)) + } +} + +#[cfg(unix)] +fn send_interrupt(pid: libc::pid_t) -> anyhow::Result<()> { + let pid = nix::unistd::Pid::from_raw(pid); + + nix::sys::signal::kill(pid, nix::sys::signal::SIGINT) + .map_err(|e| anyhow!("Failed to interrupt process: {}", e)) +} + +#[cfg(windows)] +fn send_interrupt(_pid: i32) -> anyhow::Result<()> { + panic!("Cancel not implemented on Windows") +} + +struct ClaudeAgentConnection { + sessions: Rc>>, +} + +impl AgentConnection for ClaudeAgentConnection { + fn name(&self) -> &'static str { + ClaudeCode.name() } fn new_thread( - &self, - root_dir: &Path, - project: &Entity, - cx: &mut App, + self: Rc, + project: Entity, + cwd: &Path, + cx: &mut AsyncApp, ) -> Task>> { - let project = project.clone(); - let root_dir = root_dir.to_path_buf(); - let title = self.name().into(); + let cwd = cwd.to_owned(); cx.spawn(async move |cx| { - let (mut delegate_tx, delegate_rx) = watch::channel(None); - let tool_id_map = Rc::new(RefCell::new(HashMap::default())); - - let mcp_server = ClaudeMcpServer::new(delegate_rx, tool_id_map.clone(), cx).await?; + let (mut thread_tx, thread_rx) = watch::channel(WeakEntity::new_invalid()); + let permission_mcp_server = ClaudeZedMcpServer::new(thread_rx.clone(), cx).await?; let mut mcp_servers = HashMap::default(); mcp_servers.insert( mcp_server::SERVER_NAME.to_string(), - mcp_server.server_config()?, + permission_mcp_server.server_config()?, ); let mcp_config = McpConfig { mcp_servers }; @@ -104,177 +128,180 @@ impl AgentServer for ClaudeCode { let (outgoing_tx, outgoing_rx) = mpsc::unbounded(); let (cancel_tx, mut cancel_rx) = mpsc::unbounded::>>(); - let session_id = Uuid::new_v4(); + let session_id = acp::SessionId(Uuid::new_v4().to_string().into()); log::trace!("Starting session with id: {}", session_id); - cx.background_spawn(async move { - let mut outgoing_rx = Some(outgoing_rx); - let mut mode = ClaudeSessionMode::Start; + cx.background_spawn({ + let session_id = session_id.clone(); + async move { + let mut outgoing_rx = Some(outgoing_rx); + let mut mode = ClaudeSessionMode::Start; - loop { - let mut child = - spawn_claude(&command, mode, session_id, &mcp_config_path, &root_dir) - .await?; - mode = ClaudeSessionMode::Resume; - - let pid = child.id(); - log::trace!("Spawned (pid: {})", pid); - - let mut io_fut = pin!( - ClaudeAgentConnection::handle_io( - outgoing_rx.take().unwrap(), - incoming_message_tx.clone(), - child.stdin.take().unwrap(), - child.stdout.take().unwrap(), + loop { + let mut child = spawn_claude( + &command, + mode, + session_id.clone(), + &mcp_config_path, + &cwd, ) - .fuse() - ); + .await?; + mode = ClaudeSessionMode::Resume; - select_biased! { - done_tx = cancel_rx.next() => { - if let Some(done_tx) = done_tx { - log::trace!("Interrupted (pid: {})", pid); - let result = send_interrupt(pid as i32); - outgoing_rx.replace(io_fut.await?); - done_tx.send(result).log_err(); - continue; + let pid = child.id(); + log::trace!("Spawned (pid: {})", pid); + + let mut io_fut = pin!( + ClaudeAgentSession::handle_io( + outgoing_rx.take().unwrap(), + incoming_message_tx.clone(), + child.stdin.take().unwrap(), + child.stdout.take().unwrap(), + ) + .fuse() + ); + + select_biased! { + done_tx = cancel_rx.next() => { + if let Some(done_tx) = done_tx { + log::trace!("Interrupted (pid: {})", pid); + let result = send_interrupt(pid as i32); + outgoing_rx.replace(io_fut.await?); + done_tx.send(result).log_err(); + continue; + } + } + result = io_fut => { + result?; } } - result = io_fut => { - result?; - } + + log::trace!("Stopped (pid: {})", pid); + break; } - log::trace!("Stopped (pid: {})", pid); - break; + drop(mcp_config_path); + anyhow::Ok(()) } - - drop(mcp_config_path); - anyhow::Ok(()) }) .detach(); - cx.new(|cx| { - let end_turn_tx = Rc::new(RefCell::new(None)); - let delegate = AcpClientDelegate::new(cx.entity().downgrade(), cx.to_async()); - delegate_tx.send(Some(delegate.clone())).log_err(); - - let handler_task = cx.foreground_executor().spawn({ - let end_turn_tx = end_turn_tx.clone(); - let tool_id_map = tool_id_map.clone(); - let delegate = delegate.clone(); - async move { - while let Some(message) = incoming_message_rx.next().await { - ClaudeAgentConnection::handle_message( - delegate.clone(), - message, - end_turn_tx.clone(), - tool_id_map.clone(), - ) - .await - } + let end_turn_tx = Rc::new(RefCell::new(None)); + let handler_task = cx.spawn({ + let end_turn_tx = end_turn_tx.clone(); + let thread_rx = thread_rx.clone(); + async move |cx| { + while let Some(message) = incoming_message_rx.next().await { + ClaudeAgentSession::handle_message( + thread_rx.clone(), + message, + end_turn_tx.clone(), + cx, + ) + .await } - }); + } + }); - let mut connection = ClaudeAgentConnection { - delegate, - outgoing_tx, - end_turn_tx, - cancel_tx, - session_id, - _handler_task: handler_task, - _mcp_server: None, - }; + let thread = + cx.new(|cx| AcpThread::new(self.clone(), project, session_id.clone(), cx))?; - connection._mcp_server = Some(mcp_server); - acp_thread::AcpThread::new(connection, title, None, project.clone(), cx) - }) + thread_tx.send(thread.downgrade())?; + + let session = ClaudeAgentSession { + outgoing_tx, + end_turn_tx, + cancel_tx, + _handler_task: handler_task, + _mcp_server: Some(permission_mcp_server), + }; + + self.sessions.borrow_mut().insert(session_id, session); + + Ok(thread) }) } -} -#[cfg(unix)] -fn send_interrupt(pid: libc::pid_t) -> anyhow::Result<()> { - let pid = nix::unistd::Pid::from_raw(pid); + fn authenticate(&self, _cx: &mut App) -> Task> { + Task::ready(Err(anyhow!("Authentication not supported"))) + } - nix::sys::signal::kill(pid, nix::sys::signal::SIGINT) - .map_err(|e| anyhow!("Failed to interrupt process: {}", e)) -} + fn prompt(&self, params: acp::PromptToolArguments, cx: &mut App) -> Task> { + let sessions = self.sessions.borrow(); + let Some(session) = sessions.get(¶ms.session_id) else { + return Task::ready(Err(anyhow!( + "Attempted to send message to nonexistent session {}", + params.session_id + ))); + }; -#[cfg(windows)] -fn send_interrupt(_pid: i32) -> anyhow::Result<()> { - panic!("Cancel not implemented on Windows") -} + let (tx, rx) = oneshot::channel(); + session.end_turn_tx.borrow_mut().replace(tx); -impl AgentConnection for ClaudeAgentConnection { - /// Send a request to the agent and wait for a response. - fn request_any( - &self, - params: AnyAgentRequest, - ) -> LocalBoxFuture<'static, Result> { - let delegate = self.delegate.clone(); - let end_turn_tx = self.end_turn_tx.clone(); - let outgoing_tx = self.outgoing_tx.clone(); - let mut cancel_tx = self.cancel_tx.clone(); - let session_id = self.session_id; - async move { - match params { - // todo: consider sending an empty request so we get the init response? - AnyAgentRequest::InitializeParams(_) => Ok(AnyAgentResult::InitializeResponse( - acp::InitializeResponse { - is_authenticated: true, - protocol_version: ProtocolVersion::latest(), - }, - )), - AnyAgentRequest::AuthenticateParams(_) => { - Err(anyhow!("Authentication not supported")) + let mut content = String::new(); + for chunk in params.prompt { + match chunk { + acp::ContentBlock::Text(text_content) => { + content.push_str(&text_content.text); } - AnyAgentRequest::SendUserMessageParams(message) => { - delegate.clear_completed_plan_entries().await?; - - let (tx, rx) = oneshot::channel(); - end_turn_tx.borrow_mut().replace(tx); - let mut content = String::new(); - for chunk in message.chunks { - match chunk { - agentic_coding_protocol::UserMessageChunk::Text { text } => { - content.push_str(&text) - } - agentic_coding_protocol::UserMessageChunk::Path { path } => { - content.push_str(&format!("@{path:?}")) - } - } - } - outgoing_tx.unbounded_send(SdkMessage::User { - message: Message { - role: Role::User, - content: Content::UntaggedText(content), - id: None, - model: None, - stop_reason: None, - stop_sequence: None, - usage: None, - }, - session_id: Some(session_id), - })?; - rx.await??; - Ok(AnyAgentResult::SendUserMessageResponse( - acp::SendUserMessageResponse, - )) + acp::ContentBlock::ResourceLink(resource_link) => { + content.push_str(&format!("@{}", resource_link.uri)); } - AnyAgentRequest::CancelSendMessageParams(_) => { - let (done_tx, done_rx) = oneshot::channel(); - cancel_tx.send(done_tx).await?; - done_rx.await??; - - Ok(AnyAgentResult::CancelSendMessageResponse( - acp::CancelSendMessageResponse, - )) + acp::ContentBlock::Audio(_) + | acp::ContentBlock::Image(_) + | acp::ContentBlock::Resource(_) => { + // TODO } } } - .boxed_local() + + if let Err(err) = session.outgoing_tx.unbounded_send(SdkMessage::User { + message: Message { + role: Role::User, + content: Content::UntaggedText(content), + id: None, + model: None, + stop_reason: None, + stop_sequence: None, + usage: None, + }, + session_id: Some(params.session_id.to_string()), + }) { + return Task::ready(Err(anyhow!(err))); + } + + cx.foreground_executor().spawn(async move { + rx.await??; + Ok(()) + }) + } + + fn cancel(&self, session_id: &acp::SessionId, cx: &mut App) { + let sessions = self.sessions.borrow(); + let Some(session) = sessions.get(&session_id) else { + log::warn!("Attempted to cancel nonexistent session {}", session_id); + return; + }; + + let (done_tx, done_rx) = oneshot::channel(); + if session + .cancel_tx + .unbounded_send(done_tx) + .log_err() + .is_some() + { + let end_turn_tx = session.end_turn_tx.clone(); + cx.foreground_executor() + .spawn(async move { + done_rx.await??; + if let Some(end_turn_tx) = end_turn_tx.take() { + end_turn_tx.send(Ok(())).ok(); + } + anyhow::Ok(()) + }) + .detach_and_log_err(cx); + } } } @@ -287,7 +314,7 @@ enum ClaudeSessionMode { async fn spawn_claude( command: &AgentServerCommand, mode: ClaudeSessionMode, - session_id: Uuid, + session_id: acp::SessionId, mcp_config_path: &Path, root_dir: &Path, ) -> Result { @@ -327,88 +354,103 @@ async fn spawn_claude( Ok(child) } -struct ClaudeAgentConnection { - delegate: AcpClientDelegate, - session_id: Uuid, +struct ClaudeAgentSession { outgoing_tx: UnboundedSender, end_turn_tx: Rc>>>>, cancel_tx: UnboundedSender>>, - _mcp_server: Option, + _mcp_server: Option, _handler_task: Task<()>, } -impl ClaudeAgentConnection { +impl ClaudeAgentSession { async fn handle_message( - delegate: AcpClientDelegate, + mut thread_rx: watch::Receiver>, message: SdkMessage, end_turn_tx: Rc>>>>, - tool_id_map: Rc>>, + cx: &mut AsyncApp, ) { match message { - SdkMessage::Assistant { message, .. } | SdkMessage::User { message, .. } => { + SdkMessage::Assistant { + message, + session_id: _, + } + | SdkMessage::User { + message, + session_id: _, + } => { + let Some(thread) = thread_rx + .recv() + .await + .log_err() + .and_then(|entity| entity.upgrade()) + else { + log::error!("Received an SDK message but thread is gone"); + return; + }; + for chunk in message.content.chunks() { match chunk { ContentChunk::Text { text } | ContentChunk::UntaggedText(text) => { - delegate - .stream_assistant_message_chunk(StreamAssistantMessageChunkParams { - chunk: acp::AssistantMessageChunk::Text { text }, + thread + .update(cx, |thread, cx| { + thread.push_assistant_chunk(text.into(), false, cx) }) - .await .log_err(); } ContentChunk::ToolUse { id, name, input } => { let claude_tool = ClaudeTool::infer(&name, input); - if let ClaudeTool::TodoWrite(Some(params)) = claude_tool { - delegate - .update_plan(acp::UpdatePlanParams { - entries: params.todos.into_iter().map(Into::into).collect(), - }) - .await - .log_err(); - } else if let Some(resp) = delegate - .push_tool_call(claude_tool.as_acp()) - .await - .log_err() - { - tool_id_map.borrow_mut().insert(id, resp.id); - } + thread + .update(cx, |thread, cx| { + if let ClaudeTool::TodoWrite(Some(params)) = claude_tool { + thread.update_plan( + acp::Plan { + entries: params + .todos + .into_iter() + .map(Into::into) + .collect(), + }, + cx, + ) + } else { + thread.upsert_tool_call( + claude_tool.as_acp(acp::ToolCallId(id.into())), + cx, + ); + } + }) + .log_err(); } ContentChunk::ToolResult { content, tool_use_id, } => { - let id = tool_id_map.borrow_mut().remove(&tool_use_id); - if let Some(id) = id { - let content = content.to_string(); - delegate - .update_tool_call(UpdateToolCallParams { - tool_call_id: id, - status: acp::ToolCallStatus::Finished, - // Don't unset existing content - content: (!content.is_empty()).then_some( - ToolCallContent::Markdown { - // For now we only include text content - markdown: content, - }, - ), - }) - .await - .log_err(); - } + let content = content.to_string(); + thread + .update(cx, |thread, cx| { + thread.update_tool_call( + acp::ToolCallId(tool_use_id.into()), + acp::ToolCallStatus::Completed, + (!content.is_empty()).then(|| vec![content.into()]), + cx, + ) + }) + .log_err(); } ContentChunk::Image | ContentChunk::Document | ContentChunk::Thinking | ContentChunk::RedactedThinking | ContentChunk::WebSearchToolResult => { - delegate - .stream_assistant_message_chunk(StreamAssistantMessageChunkParams { - chunk: acp::AssistantMessageChunk::Text { - text: format!("Unsupported content: {:?}", chunk), - }, + thread + .update(cx, |thread, cx| { + thread.push_assistant_chunk( + format!("Unsupported content: {:?}", chunk).into(), + false, + cx, + ) }) - .await .log_err(); } } @@ -592,14 +634,14 @@ enum SdkMessage { Assistant { message: Message, // from Anthropic SDK #[serde(skip_serializing_if = "Option::is_none")] - session_id: Option, + session_id: Option, }, // A user message User { message: Message, // from Anthropic SDK #[serde(skip_serializing_if = "Option::is_none")] - session_id: Option, + session_id: Option, }, // Emitted as the last message in a conversation @@ -661,21 +703,6 @@ enum PermissionMode { Plan, } -#[derive(Serialize)] -#[serde(rename_all = "camelCase")] -struct McpConfig { - mcp_servers: HashMap, -} - -#[derive(Serialize)] -#[serde(rename_all = "camelCase")] -struct McpServerConfig { - command: String, - args: Vec, - #[serde(skip_serializing_if = "Option::is_none")] - env: Option>, -} - #[cfg(test)] pub(crate) mod tests { use super::*; diff --git a/crates/agent_servers/src/claude/mcp_server.rs b/crates/agent_servers/src/claude/mcp_server.rs index 2405603550..0a39a02931 100644 --- a/crates/agent_servers/src/claude/mcp_server.rs +++ b/crates/agent_servers/src/claude/mcp_server.rs @@ -1,29 +1,22 @@ -use std::{cell::RefCell, rc::Rc}; +use std::path::PathBuf; -use acp_thread::AcpClientDelegate; -use agentic_coding_protocol::{self as acp, Client, ReadTextFileParams, WriteTextFileParams}; +use acp_thread::AcpThread; +use agent_client_protocol as acp; use anyhow::{Context, Result}; use collections::HashMap; -use context_server::{ - listener::McpServer, - types::{ - CallToolParams, CallToolResponse, Implementation, InitializeParams, InitializeResponse, - ListToolsResponse, ProtocolVersion, ServerCapabilities, Tool, ToolAnnotations, - ToolResponseContent, ToolsCapabilities, requests, - }, +use context_server::types::{ + CallToolParams, CallToolResponse, Implementation, InitializeParams, InitializeResponse, + ListToolsResponse, ProtocolVersion, ServerCapabilities, Tool, ToolAnnotations, + ToolResponseContent, ToolsCapabilities, requests, }; -use gpui::{App, AsyncApp, Task}; +use gpui::{App, AsyncApp, Entity, Task, WeakEntity}; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; -use util::debug_panic; -use crate::claude::{ - McpServerConfig, - tools::{ClaudeTool, EditToolParams, ReadToolParams}, -}; +use crate::claude::tools::{ClaudeTool, EditToolParams, ReadToolParams}; -pub struct ClaudeMcpServer { - server: McpServer, +pub struct ClaudeZedMcpServer { + server: context_server::listener::McpServer, } pub const SERVER_NAME: &str = "zed"; @@ -52,17 +45,16 @@ enum PermissionToolBehavior { Deny, } -impl ClaudeMcpServer { +impl ClaudeZedMcpServer { pub async fn new( - delegate: watch::Receiver>, - tool_id_map: Rc>>, + thread_rx: watch::Receiver>, cx: &AsyncApp, ) -> Result { - let mut mcp_server = McpServer::new(cx).await?; + let mut mcp_server = context_server::listener::McpServer::new(cx).await?; mcp_server.handle_request::(Self::handle_initialize); mcp_server.handle_request::(Self::handle_list_tools); mcp_server.handle_request::(move |request, cx| { - Self::handle_call_tool(request, delegate.clone(), tool_id_map.clone(), cx) + Self::handle_call_tool(request, thread_rx.clone(), cx) }); Ok(Self { server: mcp_server }) @@ -70,9 +62,7 @@ impl ClaudeMcpServer { pub fn server_config(&self) -> Result { let zed_path = std::env::current_exe() - .context("finding current executable path for use in mcp_server")? - .to_string_lossy() - .to_string(); + .context("finding current executable path for use in mcp_server")?; Ok(McpServerConfig { command: zed_path, @@ -152,22 +142,19 @@ impl ClaudeMcpServer { fn handle_call_tool( request: CallToolParams, - mut delegate_watch: watch::Receiver>, - tool_id_map: Rc>>, + mut thread_rx: watch::Receiver>, cx: &App, ) -> Task> { cx.spawn(async move |cx| { - let Some(delegate) = delegate_watch.recv().await? else { - debug_panic!("Sent None delegate"); - anyhow::bail!("Server not available"); + let Some(thread) = thread_rx.recv().await?.upgrade() else { + anyhow::bail!("Thread closed"); }; if request.name.as_str() == PERMISSION_TOOL { let input = serde_json::from_value(request.arguments.context("Arguments required")?)?; - let result = - Self::handle_permissions_tool_call(input, delegate, tool_id_map, cx).await?; + let result = Self::handle_permissions_tool_call(input, thread, cx).await?; Ok(CallToolResponse { content: vec![ToolResponseContent::Text { text: serde_json::to_string(&result)?, @@ -179,7 +166,7 @@ impl ClaudeMcpServer { let input = serde_json::from_value(request.arguments.context("Arguments required")?)?; - let content = Self::handle_read_tool_call(input, delegate, cx).await?; + let content = Self::handle_read_tool_call(input, thread, cx).await?; Ok(CallToolResponse { content, is_error: None, @@ -189,7 +176,7 @@ impl ClaudeMcpServer { let input = serde_json::from_value(request.arguments.context("Arguments required")?)?; - Self::handle_edit_tool_call(input, delegate, cx).await?; + Self::handle_edit_tool_call(input, thread, cx).await?; Ok(CallToolResponse { content: vec![], is_error: None, @@ -202,49 +189,46 @@ impl ClaudeMcpServer { } fn handle_read_tool_call( - params: ReadToolParams, - delegate: AcpClientDelegate, + ReadToolParams { + abs_path, + offset, + limit, + }: ReadToolParams, + thread: Entity, cx: &AsyncApp, ) -> Task>> { - cx.foreground_executor().spawn(async move { - let response = delegate - .read_text_file(ReadTextFileParams { - path: params.abs_path, - line: params.offset, - limit: params.limit, - }) + cx.spawn(async move |cx| { + let content = thread + .update(cx, |thread, cx| { + thread.read_text_file(abs_path, offset, limit, false, cx) + })? .await?; - Ok(vec![ToolResponseContent::Text { - text: response.content, - }]) + Ok(vec![ToolResponseContent::Text { text: content }]) }) } fn handle_edit_tool_call( params: EditToolParams, - delegate: AcpClientDelegate, + thread: Entity, cx: &AsyncApp, ) -> Task> { - cx.foreground_executor().spawn(async move { - let response = delegate - .read_text_file_reusing_snapshot(ReadTextFileParams { - path: params.abs_path.clone(), - line: None, - limit: None, - }) + cx.spawn(async move |cx| { + let content = thread + .update(cx, |threads, cx| { + threads.read_text_file(params.abs_path.clone(), None, None, true, cx) + })? .await?; - let new_content = response.content.replace(¶ms.old_text, ¶ms.new_text); - if new_content == response.content { + let new_content = content.replace(¶ms.old_text, ¶ms.new_text); + if new_content == content { return Err(anyhow::anyhow!("The old_text was not found in the content")); } - delegate - .write_text_file(WriteTextFileParams { - path: params.abs_path, - content: new_content, - }) + thread + .update(cx, |threads, cx| { + threads.write_text_file(params.abs_path, new_content, cx) + })? .await?; Ok(()) @@ -253,44 +237,65 @@ impl ClaudeMcpServer { fn handle_permissions_tool_call( params: PermissionToolParams, - delegate: AcpClientDelegate, - tool_id_map: Rc>>, + thread: Entity, cx: &AsyncApp, ) -> Task> { - cx.foreground_executor().spawn(async move { + cx.spawn(async move |cx| { let claude_tool = ClaudeTool::infer(¶ms.tool_name, params.input.clone()); - let tool_call_id = match params.tool_use_id { - Some(tool_use_id) => tool_id_map - .borrow() - .get(&tool_use_id) - .cloned() - .context("Tool call ID not found")?, + let tool_call_id = + acp::ToolCallId(params.tool_use_id.context("Tool ID required")?.into()); - None => delegate.push_tool_call(claude_tool.as_acp()).await?.id, - }; + let allow_option_id = acp::PermissionOptionId("allow".into()); + let reject_option_id = acp::PermissionOptionId("reject".into()); - let outcome = delegate - .request_existing_tool_call_confirmation( - tool_call_id, - claude_tool.confirmation(None), - ) + let chosen_option = thread + .update(cx, |thread, cx| { + thread.request_tool_call_permission( + claude_tool.as_acp(tool_call_id), + vec![ + acp::PermissionOption { + id: allow_option_id.clone(), + label: "Allow".into(), + kind: acp::PermissionOptionKind::AllowOnce, + }, + acp::PermissionOption { + id: reject_option_id, + label: "Reject".into(), + kind: acp::PermissionOptionKind::RejectOnce, + }, + ], + cx, + ) + })? .await?; - match outcome { - acp::ToolCallConfirmationOutcome::Allow - | acp::ToolCallConfirmationOutcome::AlwaysAllow - | acp::ToolCallConfirmationOutcome::AlwaysAllowMcpServer - | acp::ToolCallConfirmationOutcome::AlwaysAllowTool => Ok(PermissionToolResponse { + if chosen_option == allow_option_id { + Ok(PermissionToolResponse { behavior: PermissionToolBehavior::Allow, updated_input: params.input, - }), - acp::ToolCallConfirmationOutcome::Reject - | acp::ToolCallConfirmationOutcome::Cancel => Ok(PermissionToolResponse { + }) + } else { + Ok(PermissionToolResponse { behavior: PermissionToolBehavior::Deny, updated_input: params.input, - }), + }) } }) } } + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub struct McpConfig { + pub mcp_servers: HashMap, +} + +#[derive(Serialize, Clone)] +#[serde(rename_all = "camelCase")] +pub struct McpServerConfig { + pub command: PathBuf, + pub args: Vec, + #[serde(skip_serializing_if = "Option::is_none")] + pub env: Option>, +} diff --git a/crates/agent_servers/src/claude/tools.rs b/crates/agent_servers/src/claude/tools.rs index 75a26ee230..ed25f9af7f 100644 --- a/crates/agent_servers/src/claude/tools.rs +++ b/crates/agent_servers/src/claude/tools.rs @@ -1,6 +1,6 @@ use std::path::PathBuf; -use agentic_coding_protocol::{self as acp, PushToolCallParams, ToolCallLocation}; +use agent_client_protocol as acp; use itertools::Itertools; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; @@ -115,51 +115,36 @@ impl ClaudeTool { Self::Other { name, .. } => name.clone(), } } - - pub fn content(&self) -> Option { + pub fn content(&self) -> Vec { match &self { - Self::Other { input, .. } => Some(acp::ToolCallContent::Markdown { - markdown: format!( + Self::Other { input, .. } => vec![ + format!( "```json\n{}```", serde_json::to_string_pretty(&input).unwrap_or("{}".to_string()) - ), - }), - Self::Task(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.prompt.clone(), - }), - Self::NotebookRead(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.notebook_path.display().to_string(), - }), - Self::NotebookEdit(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.new_source.clone(), - }), - Self::Terminal(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: format!( + ) + .into(), + ], + Self::Task(Some(params)) => vec![params.prompt.clone().into()], + Self::NotebookRead(Some(params)) => { + vec![params.notebook_path.display().to_string().into()] + } + Self::NotebookEdit(Some(params)) => vec![params.new_source.clone().into()], + Self::Terminal(Some(params)) => vec![ + format!( "`{}`\n\n{}", params.command, params.description.as_deref().unwrap_or_default() - ), - }), - Self::ReadFile(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.abs_path.display().to_string(), - }), - Self::Ls(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.path.display().to_string(), - }), - Self::Glob(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.to_string(), - }), - Self::Grep(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: format!("`{params}`"), - }), - Self::WebFetch(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.prompt.clone(), - }), - Self::WebSearch(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.to_string(), - }), - Self::TodoWrite(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params + ) + .into(), + ], + Self::ReadFile(Some(params)) => vec![params.abs_path.display().to_string().into()], + Self::Ls(Some(params)) => vec![params.path.display().to_string().into()], + Self::Glob(Some(params)) => vec![params.to_string().into()], + Self::Grep(Some(params)) => vec![format!("`{params}`").into()], + Self::WebFetch(Some(params)) => vec![params.prompt.clone().into()], + Self::WebSearch(Some(params)) => vec![params.to_string().into()], + Self::TodoWrite(Some(params)) => vec![ + params .todos .iter() .map(|todo| { @@ -174,34 +159,39 @@ impl ClaudeTool { todo.content ) }) - .join("\n"), - }), - Self::ExitPlanMode(Some(params)) => Some(acp::ToolCallContent::Markdown { - markdown: params.plan.clone(), - }), - Self::Edit(Some(params)) => Some(acp::ToolCallContent::Diff { + .join("\n") + .into(), + ], + Self::ExitPlanMode(Some(params)) => vec![params.plan.clone().into()], + Self::Edit(Some(params)) => vec![acp::ToolCallContent::Diff { diff: acp::Diff { path: params.abs_path.clone(), old_text: Some(params.old_text.clone()), new_text: params.new_text.clone(), }, - }), - Self::Write(Some(params)) => Some(acp::ToolCallContent::Diff { + }], + Self::Write(Some(params)) => vec![acp::ToolCallContent::Diff { diff: acp::Diff { path: params.file_path.clone(), old_text: None, new_text: params.content.clone(), }, - }), + }], Self::MultiEdit(Some(params)) => { // todo: show multiple edits in a multibuffer? - params.edits.first().map(|edit| acp::ToolCallContent::Diff { - diff: acp::Diff { - path: params.file_path.clone(), - old_text: Some(edit.old_string.clone()), - new_text: edit.new_string.clone(), - }, - }) + params + .edits + .first() + .map(|edit| { + vec![acp::ToolCallContent::Diff { + diff: acp::Diff { + path: params.file_path.clone(), + old_text: Some(edit.old_string.clone()), + new_text: edit.new_string.clone(), + }, + }] + }) + .unwrap_or_default() } Self::Task(None) | Self::NotebookRead(None) @@ -217,181 +207,80 @@ impl ClaudeTool { | Self::ExitPlanMode(None) | Self::Edit(None) | Self::Write(None) - | Self::MultiEdit(None) => None, + | Self::MultiEdit(None) => vec![], } } - pub fn icon(&self) -> acp::Icon { + pub fn kind(&self) -> acp::ToolKind { match self { - Self::Task(_) => acp::Icon::Hammer, - Self::NotebookRead(_) => acp::Icon::FileSearch, - Self::NotebookEdit(_) => acp::Icon::Pencil, - Self::Edit(_) => acp::Icon::Pencil, - Self::MultiEdit(_) => acp::Icon::Pencil, - Self::Write(_) => acp::Icon::Pencil, - Self::ReadFile(_) => acp::Icon::FileSearch, - Self::Ls(_) => acp::Icon::Folder, - Self::Glob(_) => acp::Icon::FileSearch, - Self::Grep(_) => acp::Icon::Regex, - Self::Terminal(_) => acp::Icon::Terminal, - Self::WebSearch(_) => acp::Icon::Globe, - Self::WebFetch(_) => acp::Icon::Globe, - Self::TodoWrite(_) => acp::Icon::LightBulb, - Self::ExitPlanMode(_) => acp::Icon::Hammer, - Self::Other { .. } => acp::Icon::Hammer, - } - } - - pub fn confirmation(&self, description: Option) -> acp::ToolCallConfirmation { - match &self { - Self::Edit(_) | Self::Write(_) | Self::NotebookEdit(_) | Self::MultiEdit(_) => { - acp::ToolCallConfirmation::Edit { description } - } - Self::WebFetch(params) => acp::ToolCallConfirmation::Fetch { - urls: params - .as_ref() - .map(|p| vec![p.url.clone()]) - .unwrap_or_default(), - description, - }, - Self::Terminal(Some(BashToolParams { - description, - command, - .. - })) => acp::ToolCallConfirmation::Execute { - command: command.clone(), - root_command: command.clone(), - description: description.clone(), - }, - Self::ExitPlanMode(Some(params)) => acp::ToolCallConfirmation::Other { - description: if let Some(description) = description { - format!("{description} {}", params.plan) - } else { - params.plan.clone() - }, - }, - Self::Task(Some(params)) => acp::ToolCallConfirmation::Other { - description: if let Some(description) = description { - format!("{description} {}", params.description) - } else { - params.description.clone() - }, - }, - Self::Ls(Some(LsToolParams { path, .. })) - | Self::ReadFile(Some(ReadToolParams { abs_path: path, .. })) => { - let path = path.display(); - acp::ToolCallConfirmation::Other { - description: if let Some(description) = description { - format!("{description} {path}") - } else { - path.to_string() - }, - } - } - Self::NotebookRead(Some(NotebookReadToolParams { notebook_path, .. })) => { - let path = notebook_path.display(); - acp::ToolCallConfirmation::Other { - description: if let Some(description) = description { - format!("{description} {path}") - } else { - path.to_string() - }, - } - } - Self::Glob(Some(params)) => acp::ToolCallConfirmation::Other { - description: if let Some(description) = description { - format!("{description} {params}") - } else { - params.to_string() - }, - }, - Self::Grep(Some(params)) => acp::ToolCallConfirmation::Other { - description: if let Some(description) = description { - format!("{description} {params}") - } else { - params.to_string() - }, - }, - Self::WebSearch(Some(params)) => acp::ToolCallConfirmation::Other { - description: if let Some(description) = description { - format!("{description} {params}") - } else { - params.to_string() - }, - }, - Self::TodoWrite(Some(params)) => { - let params = params.todos.iter().map(|todo| &todo.content).join(", "); - acp::ToolCallConfirmation::Other { - description: if let Some(description) = description { - format!("{description} {params}") - } else { - params - }, - } - } - Self::Terminal(None) - | Self::Task(None) - | Self::NotebookRead(None) - | Self::ExitPlanMode(None) - | Self::Ls(None) - | Self::Glob(None) - | Self::Grep(None) - | Self::ReadFile(None) - | Self::WebSearch(None) - | Self::TodoWrite(None) - | Self::Other { .. } => acp::ToolCallConfirmation::Other { - description: description.unwrap_or("".to_string()), - }, + Self::Task(_) => acp::ToolKind::Think, + Self::NotebookRead(_) => acp::ToolKind::Read, + Self::NotebookEdit(_) => acp::ToolKind::Edit, + Self::Edit(_) => acp::ToolKind::Edit, + Self::MultiEdit(_) => acp::ToolKind::Edit, + Self::Write(_) => acp::ToolKind::Edit, + Self::ReadFile(_) => acp::ToolKind::Read, + Self::Ls(_) => acp::ToolKind::Search, + Self::Glob(_) => acp::ToolKind::Search, + Self::Grep(_) => acp::ToolKind::Search, + Self::Terminal(_) => acp::ToolKind::Execute, + Self::WebSearch(_) => acp::ToolKind::Search, + Self::WebFetch(_) => acp::ToolKind::Fetch, + Self::TodoWrite(_) => acp::ToolKind::Think, + Self::ExitPlanMode(_) => acp::ToolKind::Think, + Self::Other { .. } => acp::ToolKind::Other, } } pub fn locations(&self) -> Vec { match &self { - Self::Edit(Some(EditToolParams { abs_path, .. })) => vec![ToolCallLocation { + Self::Edit(Some(EditToolParams { abs_path, .. })) => vec![acp::ToolCallLocation { path: abs_path.clone(), line: None, }], Self::MultiEdit(Some(MultiEditToolParams { file_path, .. })) => { - vec![ToolCallLocation { + vec![acp::ToolCallLocation { + path: file_path.clone(), + line: None, + }] + } + Self::Write(Some(WriteToolParams { file_path, .. })) => { + vec![acp::ToolCallLocation { path: file_path.clone(), line: None, }] } - Self::Write(Some(WriteToolParams { file_path, .. })) => vec![ToolCallLocation { - path: file_path.clone(), - line: None, - }], Self::ReadFile(Some(ReadToolParams { abs_path, offset, .. - })) => vec![ToolCallLocation { + })) => vec![acp::ToolCallLocation { path: abs_path.clone(), line: *offset, }], Self::NotebookRead(Some(NotebookReadToolParams { notebook_path, .. })) => { - vec![ToolCallLocation { + vec![acp::ToolCallLocation { path: notebook_path.clone(), line: None, }] } Self::NotebookEdit(Some(NotebookEditToolParams { notebook_path, .. })) => { - vec![ToolCallLocation { + vec![acp::ToolCallLocation { path: notebook_path.clone(), line: None, }] } Self::Glob(Some(GlobToolParams { path: Some(path), .. - })) => vec![ToolCallLocation { + })) => vec![acp::ToolCallLocation { path: path.clone(), line: None, }], - Self::Ls(Some(LsToolParams { path, .. })) => vec![ToolCallLocation { + Self::Ls(Some(LsToolParams { path, .. })) => vec![acp::ToolCallLocation { path: path.clone(), line: None, }], Self::Grep(Some(GrepToolParams { path: Some(path), .. - })) => vec![ToolCallLocation { + })) => vec![acp::ToolCallLocation { path: PathBuf::from(path), line: None, }], @@ -414,11 +303,13 @@ impl ClaudeTool { } } - pub fn as_acp(&self) -> PushToolCallParams { - PushToolCallParams { + pub fn as_acp(&self, id: acp::ToolCallId) -> acp::ToolCall { + acp::ToolCall { + id, + kind: self.kind(), + status: acp::ToolCallStatus::InProgress, label: self.label(), content: self.content(), - icon: self.icon(), locations: self.locations(), } } diff --git a/crates/agent_servers/src/e2e_tests.rs b/crates/agent_servers/src/e2e_tests.rs index 12f74cb13e..9bc6fd60fe 100644 --- a/crates/agent_servers/src/e2e_tests.rs +++ b/crates/agent_servers/src/e2e_tests.rs @@ -1,10 +1,9 @@ use std::{path::Path, sync::Arc, time::Duration}; use crate::{AgentServer, AgentServerSettings, AllAgentServersSettings}; -use acp_thread::{ - AcpThread, AgentThreadEntry, ToolCall, ToolCallConfirmation, ToolCallContent, ToolCallStatus, -}; -use agentic_coding_protocol as acp; +use acp_thread::{AcpThread, AgentThreadEntry, ToolCall, ToolCallStatus}; +use agent_client_protocol as acp; + use futures::{FutureExt, StreamExt, channel::mpsc, select}; use gpui::{Entity, TestAppContext}; use indoc::indoc; @@ -54,19 +53,25 @@ pub async fn test_path_mentions(server: impl AgentServer + 'static, cx: &mut Tes thread .update(cx, |thread, cx| { thread.send( - acp::SendUserMessageParams { - chunks: vec![ - acp::UserMessageChunk::Text { - text: "Read the file ".into(), - }, - acp::UserMessageChunk::Path { - path: Path::new("foo.rs").into(), - }, - acp::UserMessageChunk::Text { - text: " and tell me what the content of the println! is".into(), - }, - ], - }, + vec![ + acp::ContentBlock::Text(acp::TextContent { + text: "Read the file ".into(), + annotations: None, + }), + acp::ContentBlock::ResourceLink(acp::ResourceLink { + uri: "foo.rs".into(), + name: "foo.rs".into(), + annotations: None, + description: None, + mime_type: None, + size: None, + title: None, + }), + acp::ContentBlock::Text(acp::TextContent { + text: " and tell me what the content of the println! is".into(), + annotations: None, + }), + ], cx, ) }) @@ -161,11 +166,8 @@ pub async fn test_tool_call_with_confirmation( let tool_call_id = thread.read_with(cx, |thread, _cx| { let AgentThreadEntry::ToolCall(ToolCall { id, - status: - ToolCallStatus::WaitingForConfirmation { - confirmation: ToolCallConfirmation::Execute { root_command, .. }, - .. - }, + content, + status: ToolCallStatus::WaitingForConfirmation { .. }, .. }) = &thread .entries() @@ -176,13 +178,18 @@ pub async fn test_tool_call_with_confirmation( panic!(); }; - assert!(root_command.contains("touch")); + assert!(content.iter().any(|c| c.to_markdown(_cx).contains("touch"))); - *id + id.clone() }); thread.update(cx, |thread, cx| { - thread.authorize_tool_call(tool_call_id, acp::ToolCallConfirmationOutcome::Allow, cx); + thread.authorize_tool_call( + tool_call_id, + acp::PermissionOptionId("0".into()), + acp::PermissionOptionKind::AllowOnce, + cx, + ); assert!(thread.entries().iter().any(|entry| matches!( entry, @@ -197,7 +204,7 @@ pub async fn test_tool_call_with_confirmation( thread.read_with(cx, |thread, cx| { let AgentThreadEntry::ToolCall(ToolCall { - content: Some(ToolCallContent::Markdown { markdown }), + content, status: ToolCallStatus::Allowed { .. }, .. }) = thread @@ -209,13 +216,10 @@ pub async fn test_tool_call_with_confirmation( panic!(); }; - markdown.read_with(cx, |md, _cx| { - assert!( - md.source().contains("Hello"), - r#"Expected '{}' to contain "Hello""#, - md.source() - ); - }); + assert!( + content.iter().any(|c| c.to_markdown(cx).contains("Hello")), + "Expected content to contain 'Hello'" + ); }); } @@ -249,26 +253,20 @@ pub async fn test_cancel(server: impl AgentServer + 'static, cx: &mut TestAppCon thread.read_with(cx, |thread, _cx| { let AgentThreadEntry::ToolCall(ToolCall { id, - status: - ToolCallStatus::WaitingForConfirmation { - confirmation: ToolCallConfirmation::Execute { root_command, .. }, - .. - }, + content, + status: ToolCallStatus::WaitingForConfirmation { .. }, .. }) = &thread.entries()[first_tool_call_ix] else { panic!("{:?}", thread.entries()[1]); }; - assert!(root_command.contains("touch")); + assert!(content.iter().any(|c| c.to_markdown(_cx).contains("touch"))); - *id + id.clone() }); - thread - .update(cx, |thread, cx| thread.cancel(cx)) - .await - .unwrap(); + let _ = thread.update(cx, |thread, cx| thread.cancel(cx)); full_turn.await.unwrap(); thread.read_with(cx, |thread, _| { let AgentThreadEntry::ToolCall(ToolCall { @@ -369,15 +367,16 @@ pub async fn new_test_thread( current_dir: impl AsRef, cx: &mut TestAppContext, ) -> Entity { - let thread = cx - .update(|cx| server.new_thread(current_dir.as_ref(), &project, cx)) + let connection = cx + .update(|cx| server.connect(current_dir.as_ref(), &project, cx)) .await .unwrap(); - thread - .update(cx, |thread, _| thread.initialize()) + let thread = connection + .new_thread(project.clone(), current_dir.as_ref(), &mut cx.to_async()) .await .unwrap(); + thread } diff --git a/crates/agent_servers/src/gemini.rs b/crates/agent_servers/src/gemini.rs index 8ad147cbff..47b965cdad 100644 --- a/crates/agent_servers/src/gemini.rs +++ b/crates/agent_servers/src/gemini.rs @@ -1,9 +1,17 @@ -use crate::stdio_agent_server::StdioAgentServer; -use crate::{AgentServerCommand, AgentServerVersion}; +use anyhow::anyhow; +use std::cell::RefCell; +use std::path::Path; +use std::rc::Rc; +use util::ResultExt as _; + +use crate::{AgentServer, AgentServerCommand, AgentServerVersion}; +use acp_thread::{AgentConnection, LoadError, OldAcpAgentConnection, OldAcpClientDelegate}; +use agentic_coding_protocol as acp_old; use anyhow::{Context as _, Result}; -use gpui::{AsyncApp, Entity}; +use gpui::{AppContext as _, AsyncApp, Entity, Task, WeakEntity}; use project::Project; use settings::SettingsStore; +use ui::App; use crate::AllAgentServersSettings; @@ -12,7 +20,7 @@ pub struct Gemini; const ACP_ARG: &str = "--experimental-acp"; -impl StdioAgentServer for Gemini { +impl AgentServer for Gemini { fn name(&self) -> &'static str { "Gemini" } @@ -25,14 +33,88 @@ impl StdioAgentServer for Gemini { "Ask questions, edit files, run commands.\nBe specific for the best results." } - fn supports_always_allow(&self) -> bool { - true - } - fn logo(&self) -> ui::IconName { ui::IconName::AiGemini } + fn connect( + &self, + root_dir: &Path, + project: &Entity, + cx: &mut App, + ) -> Task>> { + let root_dir = root_dir.to_path_buf(); + let project = project.clone(); + let this = self.clone(); + let name = self.name(); + + cx.spawn(async move |cx| { + let command = this.command(&project, cx).await?; + + let mut child = util::command::new_smol_command(&command.path) + .args(command.args.iter()) + .current_dir(root_dir) + .stdin(std::process::Stdio::piped()) + .stdout(std::process::Stdio::piped()) + .stderr(std::process::Stdio::inherit()) + .kill_on_drop(true) + .spawn()?; + + let stdin = child.stdin.take().unwrap(); + let stdout = child.stdout.take().unwrap(); + + let foreground_executor = cx.foreground_executor().clone(); + + let thread_rc = Rc::new(RefCell::new(WeakEntity::new_invalid())); + + let (connection, io_fut) = acp_old::AgentConnection::connect_to_agent( + OldAcpClientDelegate::new(thread_rc.clone(), cx.clone()), + stdin, + stdout, + move |fut| foreground_executor.spawn(fut).detach(), + ); + + let io_task = cx.background_spawn(async move { + io_fut.await.log_err(); + }); + + let child_status = cx.background_spawn(async move { + let result = match child.status().await { + Err(e) => Err(anyhow!(e)), + Ok(result) if result.success() => Ok(()), + Ok(result) => { + if let Some(AgentServerVersion::Unsupported { + error_message, + upgrade_message, + upgrade_command, + }) = this.version(&command).await.log_err() + { + Err(anyhow!(LoadError::Unsupported { + error_message, + upgrade_message, + upgrade_command + })) + } else { + Err(anyhow!(LoadError::Exited(result.code().unwrap_or(-127)))) + } + } + }; + drop(io_task); + result + }); + + let connection: Rc = Rc::new(OldAcpAgentConnection { + name, + connection, + child_status, + }); + + Ok(connection) + }) + } +} + +impl Gemini { async fn command( &self, project: &Entity, diff --git a/crates/agent_servers/src/stdio_agent_server.rs b/crates/agent_servers/src/stdio_agent_server.rs deleted file mode 100644 index e60dd39de4..0000000000 --- a/crates/agent_servers/src/stdio_agent_server.rs +++ /dev/null @@ -1,119 +0,0 @@ -use crate::{AgentServer, AgentServerCommand, AgentServerVersion}; -use acp_thread::{AcpClientDelegate, AcpThread, LoadError}; -use agentic_coding_protocol as acp; -use anyhow::{Result, anyhow}; -use gpui::{App, AsyncApp, Entity, Task, prelude::*}; -use project::Project; -use std::path::Path; -use util::ResultExt; - -pub trait StdioAgentServer: Send + Clone { - fn logo(&self) -> ui::IconName; - fn name(&self) -> &'static str; - fn empty_state_headline(&self) -> &'static str; - fn empty_state_message(&self) -> &'static str; - fn supports_always_allow(&self) -> bool; - - fn command( - &self, - project: &Entity, - cx: &mut AsyncApp, - ) -> impl Future>; - - fn version( - &self, - command: &AgentServerCommand, - ) -> impl Future> + Send; -} - -impl AgentServer for T { - fn name(&self) -> &'static str { - self.name() - } - - fn empty_state_headline(&self) -> &'static str { - self.empty_state_headline() - } - - fn empty_state_message(&self) -> &'static str { - self.empty_state_message() - } - - fn logo(&self) -> ui::IconName { - self.logo() - } - - fn supports_always_allow(&self) -> bool { - self.supports_always_allow() - } - - fn new_thread( - &self, - root_dir: &Path, - project: &Entity, - cx: &mut App, - ) -> Task>> { - let root_dir = root_dir.to_path_buf(); - let project = project.clone(); - let this = self.clone(); - let title = self.name().into(); - - cx.spawn(async move |cx| { - let command = this.command(&project, cx).await?; - - let mut child = util::command::new_smol_command(&command.path) - .args(command.args.iter()) - .current_dir(root_dir) - .stdin(std::process::Stdio::piped()) - .stdout(std::process::Stdio::piped()) - .stderr(std::process::Stdio::inherit()) - .kill_on_drop(true) - .spawn()?; - - let stdin = child.stdin.take().unwrap(); - let stdout = child.stdout.take().unwrap(); - - cx.new(|cx| { - let foreground_executor = cx.foreground_executor().clone(); - - let (connection, io_fut) = acp::AgentConnection::connect_to_agent( - AcpClientDelegate::new(cx.entity().downgrade(), cx.to_async()), - stdin, - stdout, - move |fut| foreground_executor.spawn(fut).detach(), - ); - - let io_task = cx.background_spawn(async move { - io_fut.await.log_err(); - }); - - let child_status = cx.background_spawn(async move { - let result = match child.status().await { - Err(e) => Err(anyhow!(e)), - Ok(result) if result.success() => Ok(()), - Ok(result) => { - if let Some(AgentServerVersion::Unsupported { - error_message, - upgrade_message, - upgrade_command, - }) = this.version(&command).await.log_err() - { - Err(anyhow!(LoadError::Unsupported { - error_message, - upgrade_message, - upgrade_command - })) - } else { - Err(anyhow!(LoadError::Exited(result.code().unwrap_or(-127)))) - } - } - }; - drop(io_task); - result - }); - - AcpThread::new(connection, title, Some(child_status), project.clone(), cx) - }) - }) - } -} diff --git a/crates/agent_ui/Cargo.toml b/crates/agent_ui/Cargo.toml index 7d3b84e42e..fbd53e8d09 100644 --- a/crates/agent_ui/Cargo.toml +++ b/crates/agent_ui/Cargo.toml @@ -17,10 +17,10 @@ test-support = ["gpui/test-support", "language/test-support"] [dependencies] acp_thread.workspace = true +agent-client-protocol.workspace = true agent.workspace = true -agentic-coding-protocol.workspace = true -agent_settings.workspace = true agent_servers.workspace = true +agent_settings.workspace = true ai_onboarding.workspace = true anyhow.workspace = true assistant_context.workspace = true diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index 95f4f81205..7f5de9db5f 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -1,4 +1,4 @@ -use acp_thread::Plan; +use acp_thread::{AgentConnection, Plan}; use agent_servers::AgentServer; use std::cell::RefCell; use std::collections::BTreeMap; @@ -7,7 +7,7 @@ use std::rc::Rc; use std::sync::Arc; use std::time::Duration; -use agentic_coding_protocol::{self as acp}; +use agent_client_protocol as acp; use assistant_tool::ActionLog; use buffer_diff::BufferDiff; use collections::{HashMap, HashSet}; @@ -16,7 +16,6 @@ use editor::{ EditorStyle, MinimapVisibility, MultiBuffer, PathKey, }; use file_icons::FileIcons; -use futures::channel::oneshot; use gpui::{ Action, Animation, AnimationExt, App, BorderStyle, EdgesRefinement, Empty, Entity, EntityId, FocusHandle, Focusable, Hsla, Length, ListOffset, ListState, SharedString, StyleRefinement, @@ -39,8 +38,7 @@ use zed_actions::agent::{Chat, NextHistoryMessage, PreviousHistoryMessage}; use ::acp_thread::{ AcpThread, AcpThreadEvent, AgentThreadEntry, AssistantMessage, AssistantMessageChunk, Diff, - LoadError, MentionPath, ThreadStatus, ToolCall, ToolCallConfirmation, ToolCallContent, - ToolCallId, ToolCallStatus, + LoadError, MentionPath, ThreadStatus, ToolCall, ToolCallContent, ToolCallStatus, }; use crate::acp::completion_provider::{ContextPickerCompletionProvider, MentionSet}; @@ -64,12 +62,13 @@ pub struct AcpThreadView { last_error: Option>, list_state: ListState, auth_task: Option>, - expanded_tool_calls: HashSet, + expanded_tool_calls: HashSet, expanded_thinking_blocks: HashSet<(usize, usize)>, edits_expanded: bool, plan_expanded: bool, editor_expanded: bool, - message_history: Rc>>, + message_history: Rc>>>, + _cancel_task: Option>, } enum ThreadState { @@ -82,22 +81,16 @@ enum ThreadState { }, LoadError(LoadError), Unauthenticated { - thread: Entity, + connection: Rc, }, } -struct AlwaysAllowOption { - id: &'static str, - label: SharedString, - outcome: acp::ToolCallConfirmationOutcome, -} - impl AcpThreadView { pub fn new( agent: Rc, workspace: WeakEntity, project: Entity, - message_history: Rc>>, + message_history: Rc>>>, min_lines: usize, max_lines: Option, window: &mut Window, @@ -191,6 +184,7 @@ impl AcpThreadView { plan_expanded: false, editor_expanded: false, message_history, + _cancel_task: None, } } @@ -208,9 +202,9 @@ impl AcpThreadView { .map(|worktree| worktree.read(cx).abs_path()) .unwrap_or_else(|| paths::home_dir().as_path().into()); - let task = agent.new_thread(&root_dir, &project, cx); + let connect_task = agent.connect(&root_dir, &project, cx); let load_task = cx.spawn_in(window, async move |this, cx| { - let thread = match task.await { + let connection = match connect_task.await { Ok(thread) => thread, Err(err) => { this.update(cx, |this, cx| { @@ -222,48 +216,30 @@ impl AcpThreadView { } }; - let init_response = async { - let resp = thread - .read_with(cx, |thread, _cx| thread.initialize())? - .await?; - anyhow::Ok(resp) - }; - - let result = match init_response.await { + let result = match connection + .clone() + .new_thread(project.clone(), &root_dir, cx) + .await + { Err(e) => { let mut cx = cx.clone(); - if e.downcast_ref::().is_some() { - let child_status = thread - .update(&mut cx, |thread, _| thread.child_status()) - .ok() - .flatten(); - if let Some(child_status) = child_status { - match child_status.await { - Ok(_) => Err(e), - Err(e) => Err(e), - } - } else { - Err(e) - } + if e.downcast_ref::().is_some() { + this.update(&mut cx, |this, cx| { + this.thread_state = ThreadState::Unauthenticated { connection }; + cx.notify(); + }) + .ok(); + return; } else { Err(e) } } - Ok(response) => { - if !response.is_authenticated { - this.update(cx, |this, _| { - this.thread_state = ThreadState::Unauthenticated { thread }; - }) - .ok(); - return; - }; - Ok(()) - } + Ok(session_id) => Ok(session_id), }; this.update_in(cx, |this, window, cx| { match result { - Ok(()) => { + Ok(thread) => { let thread_subscription = cx.subscribe_in(&thread, window, Self::handle_thread_event); @@ -305,10 +281,10 @@ impl AcpThreadView { pub fn thread(&self) -> Option<&Entity> { match &self.thread_state { - ThreadState::Ready { thread, .. } | ThreadState::Unauthenticated { thread } => { - Some(thread) - } - ThreadState::Loading { .. } | ThreadState::LoadError(..) => None, + ThreadState::Ready { thread, .. } => Some(thread), + ThreadState::Unauthenticated { .. } + | ThreadState::Loading { .. } + | ThreadState::LoadError(..) => None, } } @@ -325,7 +301,7 @@ impl AcpThreadView { self.last_error.take(); if let Some(thread) = self.thread() { - thread.update(cx, |thread, cx| thread.cancel(cx)).detach(); + self._cancel_task = Some(thread.update(cx, |thread, cx| thread.cancel(cx))); } } @@ -362,7 +338,7 @@ impl AcpThreadView { self.last_error.take(); let mut ix = 0; - let mut chunks: Vec = Vec::new(); + let mut chunks: Vec = Vec::new(); let project = self.project.clone(); self.message_editor.update(cx, |editor, cx| { let text = editor.text(cx); @@ -374,12 +350,19 @@ impl AcpThreadView { { let crease_range = crease.range().to_offset(&snapshot.buffer_snapshot); if crease_range.start > ix { - chunks.push(acp::UserMessageChunk::Text { - text: text[ix..crease_range.start].to_string(), - }); + chunks.push(text[ix..crease_range.start].into()); } if let Some(abs_path) = project.read(cx).absolute_path(&project_path, cx) { - chunks.push(acp::UserMessageChunk::Path { path: abs_path }); + let path_str = abs_path.display().to_string(); + chunks.push(acp::ContentBlock::ResourceLink(acp::ResourceLink { + uri: path_str.clone(), + name: path_str, + annotations: None, + description: None, + mime_type: None, + size: None, + title: None, + })); } ix = crease_range.end; } @@ -388,9 +371,7 @@ impl AcpThreadView { if ix < text.len() { let last_chunk = text[ix..].trim(); if !last_chunk.is_empty() { - chunks.push(acp::UserMessageChunk::Text { - text: last_chunk.into(), - }); + chunks.push(last_chunk.into()); } } }) @@ -401,8 +382,7 @@ impl AcpThreadView { } let Some(thread) = self.thread() else { return }; - let message = acp::SendUserMessageParams { chunks }; - let task = thread.update(cx, |thread, cx| thread.send(message.clone(), cx)); + let task = thread.update(cx, |thread, cx| thread.send(chunks.clone(), cx)); cx.spawn(async move |this, cx| { let result = task.await; @@ -424,7 +404,7 @@ impl AcpThreadView { editor.remove_creases(mention_set.lock().drain(), cx) }); - self.message_history.borrow_mut().push(message); + self.message_history.borrow_mut().push(chunks); } fn previous_history_message( @@ -490,7 +470,7 @@ impl AcpThreadView { message_editor: Entity, mention_set: Arc>, project: Entity, - message: Option<&acp::SendUserMessageParams>, + message: Option<&Vec>, window: &mut Window, cx: &mut Context, ) -> bool { @@ -503,18 +483,19 @@ impl AcpThreadView { let mut text = String::new(); let mut mentions = Vec::new(); - for chunk in &message.chunks { + for chunk in message { match chunk { - acp::UserMessageChunk::Text { text: chunk } => { - text.push_str(&chunk); + acp::ContentBlock::Text(text_content) => { + text.push_str(&text_content.text); } - acp::UserMessageChunk::Path { path } => { + acp::ContentBlock::ResourceLink(resource_link) => { + let path = Path::new(&resource_link.uri); let start = text.len(); - let content = MentionPath::new(path).to_string(); + let content = MentionPath::new(&path).to_string(); text.push_str(&content); let end = text.len(); if let Some(project_path) = - project.read(cx).project_path_for_absolute_path(path, cx) + project.read(cx).project_path_for_absolute_path(&path, cx) { let filename: SharedString = path .file_name() @@ -525,6 +506,9 @@ impl AcpThreadView { mentions.push((start..end, project_path, filename)); } } + acp::ContentBlock::Image(_) + | acp::ContentBlock::Audio(_) + | acp::ContentBlock::Resource(_) => {} } } @@ -590,71 +574,79 @@ impl AcpThreadView { window: &mut Window, cx: &mut Context, ) { - let Some(multibuffer) = self.entry_diff_multibuffer(entry_ix, cx) else { + let Some(multibuffers) = self.entry_diff_multibuffers(entry_ix, cx) else { return; }; - if self.diff_editors.contains_key(&multibuffer.entity_id()) { - return; - } + let multibuffers = multibuffers.collect::>(); - let editor = cx.new(|cx| { - let mut editor = Editor::new( - EditorMode::Full { - scale_ui_elements_with_buffer_font_size: false, - show_active_line_background: false, - sized_by_content: true, - }, - multibuffer.clone(), - None, - window, - cx, - ); - editor.set_show_gutter(false, cx); - editor.disable_inline_diagnostics(); - editor.disable_expand_excerpt_buttons(cx); - editor.set_show_vertical_scrollbar(false, cx); - editor.set_minimap_visibility(MinimapVisibility::Disabled, window, cx); - editor.set_soft_wrap_mode(SoftWrap::None, cx); - editor.scroll_manager.set_forbid_vertical_scroll(true); - editor.set_show_indent_guides(false, cx); - editor.set_read_only(true); - editor.set_show_breakpoints(false, cx); - editor.set_show_code_actions(false, cx); - editor.set_show_git_diff_gutter(false, cx); - editor.set_expand_all_diff_hunks(cx); - editor.set_text_style_refinement(TextStyleRefinement { - font_size: Some( - TextSize::Small - .rems(cx) - .to_pixels(ThemeSettings::get_global(cx).agent_font_size(cx)) - .into(), - ), - ..Default::default() + for multibuffer in multibuffers { + if self.diff_editors.contains_key(&multibuffer.entity_id()) { + return; + } + + let editor = cx.new(|cx| { + let mut editor = Editor::new( + EditorMode::Full { + scale_ui_elements_with_buffer_font_size: false, + show_active_line_background: false, + sized_by_content: true, + }, + multibuffer.clone(), + None, + window, + cx, + ); + editor.set_show_gutter(false, cx); + editor.disable_inline_diagnostics(); + editor.disable_expand_excerpt_buttons(cx); + editor.set_show_vertical_scrollbar(false, cx); + editor.set_minimap_visibility(MinimapVisibility::Disabled, window, cx); + editor.set_soft_wrap_mode(SoftWrap::None, cx); + editor.scroll_manager.set_forbid_vertical_scroll(true); + editor.set_show_indent_guides(false, cx); + editor.set_read_only(true); + editor.set_show_breakpoints(false, cx); + editor.set_show_code_actions(false, cx); + editor.set_show_git_diff_gutter(false, cx); + editor.set_expand_all_diff_hunks(cx); + editor.set_text_style_refinement(TextStyleRefinement { + font_size: Some( + TextSize::Small + .rems(cx) + .to_pixels(ThemeSettings::get_global(cx).agent_font_size(cx)) + .into(), + ), + ..Default::default() + }); + editor }); - editor - }); - let entity_id = multibuffer.entity_id(); - cx.observe_release(&multibuffer, move |this, _, _| { - this.diff_editors.remove(&entity_id); - }) - .detach(); + let entity_id = multibuffer.entity_id(); + cx.observe_release(&multibuffer, move |this, _, _| { + this.diff_editors.remove(&entity_id); + }) + .detach(); - self.diff_editors.insert(entity_id, editor); + self.diff_editors.insert(entity_id, editor); + } } - fn entry_diff_multibuffer(&self, entry_ix: usize, cx: &App) -> Option> { + fn entry_diff_multibuffers( + &self, + entry_ix: usize, + cx: &App, + ) -> Option>> { let entry = self.thread()?.read(cx).entries().get(entry_ix)?; - entry.diff().map(|diff| diff.multibuffer.clone()) + Some(entry.diffs().map(|diff| diff.multibuffer.clone())) } fn authenticate(&mut self, window: &mut Window, cx: &mut Context) { - let Some(thread) = self.thread().cloned() else { + let ThreadState::Unauthenticated { ref connection } = self.thread_state else { return; }; self.last_error.take(); - let authenticate = thread.read(cx).authenticate(); + let authenticate = connection.authenticate(cx); self.auth_task = Some(cx.spawn_in(window, { let project = self.project.clone(); let agent = self.agent.clone(); @@ -684,15 +676,16 @@ impl AcpThreadView { fn authorize_tool_call( &mut self, - id: ToolCallId, - outcome: acp::ToolCallConfirmationOutcome, + tool_call_id: acp::ToolCallId, + option_id: acp::PermissionOptionId, + option_kind: acp::PermissionOptionKind, cx: &mut Context, ) { let Some(thread) = self.thread() else { return; }; thread.update(cx, |thread, cx| { - thread.authorize_tool_call(id, outcome, cx); + thread.authorize_tool_call(tool_call_id, option_id, option_kind, cx); }); cx.notify(); } @@ -719,10 +712,12 @@ impl AcpThreadView { .border_1() .border_color(cx.theme().colors().border) .text_xs() - .child(self.render_markdown( - message.content.clone(), - user_message_markdown_style(window, cx), - )), + .children(message.content.markdown().map(|md| { + self.render_markdown( + md.clone(), + user_message_markdown_style(window, cx), + ) + })), ) .into_any(), AgentThreadEntry::AssistantMessage(AssistantMessage { chunks }) => { @@ -730,20 +725,28 @@ impl AcpThreadView { let message_body = v_flex() .w_full() .gap_2p5() - .children(chunks.iter().enumerate().map(|(chunk_ix, chunk)| { - match chunk { - AssistantMessageChunk::Text { chunk } => self - .render_markdown(chunk.clone(), style.clone()) - .into_any_element(), - AssistantMessageChunk::Thought { chunk } => self.render_thinking_block( - index, - chunk_ix, - chunk.clone(), - window, - cx, - ), - } - })) + .children(chunks.iter().enumerate().filter_map( + |(chunk_ix, chunk)| match chunk { + AssistantMessageChunk::Message { block } => { + block.markdown().map(|md| { + self.render_markdown(md.clone(), style.clone()) + .into_any_element() + }) + } + AssistantMessageChunk::Thought { block } => { + block.markdown().map(|md| { + self.render_thinking_block( + index, + chunk_ix, + md.clone(), + window, + cx, + ) + .into_any_element() + }) + } + }, + )) .into_any(); v_flex() @@ -871,7 +874,7 @@ impl AcpThreadView { let status_icon = match &tool_call.status { ToolCallStatus::WaitingForConfirmation { .. } => None, ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Running, + status: acp::ToolCallStatus::InProgress, .. } => Some( Icon::new(IconName::ArrowCircle) @@ -885,13 +888,13 @@ impl AcpThreadView { .into_any(), ), ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Finished, + status: acp::ToolCallStatus::Completed, .. } => None, ToolCallStatus::Rejected | ToolCallStatus::Canceled | ToolCallStatus::Allowed { - status: acp::ToolCallStatus::Error, + status: acp::ToolCallStatus::Failed, .. } => Some( Icon::new(IconName::X) @@ -909,34 +912,9 @@ impl AcpThreadView { .any(|content| matches!(content, ToolCallContent::Diff { .. })), }; - let is_collapsible = tool_call.content.is_some() && !needs_confirmation; + let is_collapsible = !tool_call.content.is_empty() && !needs_confirmation; let is_open = !is_collapsible || self.expanded_tool_calls.contains(&tool_call.id); - let content = if is_open { - match &tool_call.status { - ToolCallStatus::WaitingForConfirmation { confirmation, .. } => { - Some(self.render_tool_call_confirmation( - tool_call.id, - confirmation, - tool_call.content.as_ref(), - window, - cx, - )) - } - ToolCallStatus::Allowed { .. } | ToolCallStatus::Canceled => { - tool_call.content.as_ref().map(|content| { - div() - .py_1p5() - .child(self.render_tool_call_content(content, window, cx)) - .into_any_element() - }) - } - ToolCallStatus::Rejected => None, - } - } else { - None - }; - v_flex() .when(needs_confirmation, |this| { this.rounded_lg() @@ -976,9 +954,17 @@ impl AcpThreadView { }) .gap_1p5() .child( - Icon::new(tool_call.icon) - .size(IconSize::Small) - .color(Color::Muted), + Icon::new(match tool_call.kind { + acp::ToolKind::Read => IconName::ToolRead, + acp::ToolKind::Edit => IconName::ToolPencil, + acp::ToolKind::Search => IconName::ToolSearch, + acp::ToolKind::Execute => IconName::ToolTerminal, + acp::ToolKind::Think => IconName::ToolBulb, + acp::ToolKind::Fetch => IconName::ToolWeb, + acp::ToolKind::Other => IconName::ToolHammer, + }) + .size(IconSize::Small) + .color(Color::Muted), ) .child(if tool_call.locations.len() == 1 { let name = tool_call.locations[0] @@ -1023,16 +1009,16 @@ impl AcpThreadView { .gap_0p5() .when(is_collapsible, |this| { this.child( - Disclosure::new(("expand", tool_call.id.0), is_open) + Disclosure::new(("expand", entry_ix), is_open) .opened_icon(IconName::ChevronUp) .closed_icon(IconName::ChevronDown) .on_click(cx.listener({ - let id = tool_call.id; + let id = tool_call.id.clone(); move |this: &mut Self, _, _, cx: &mut Context| { if is_open { this.expanded_tool_calls.remove(&id); } else { - this.expanded_tool_calls.insert(id); + this.expanded_tool_calls.insert(id.clone()); } cx.notify(); } @@ -1042,12 +1028,12 @@ impl AcpThreadView { .children(status_icon), ) .on_click(cx.listener({ - let id = tool_call.id; + let id = tool_call.id.clone(); move |this: &mut Self, _, _, cx: &mut Context| { if is_open { this.expanded_tool_calls.remove(&id); } else { - this.expanded_tool_calls.insert(id); + this.expanded_tool_calls.insert(id.clone()); } cx.notify(); } @@ -1055,7 +1041,7 @@ impl AcpThreadView { ) .when(is_open, |this| { this.child( - div() + v_flex() .text_xs() .when(is_collapsible, |this| { this.mt_1() @@ -1064,7 +1050,44 @@ impl AcpThreadView { .bg(cx.theme().colors().editor_background) .rounded_lg() }) - .children(content), + .map(|this| { + if is_open { + match &tool_call.status { + ToolCallStatus::WaitingForConfirmation { options, .. } => this + .children(tool_call.content.iter().map(|content| { + div() + .py_1p5() + .child( + self.render_tool_call_content( + content, window, cx, + ), + ) + .into_any_element() + })) + .child(self.render_permission_buttons( + options, + entry_ix, + tool_call.id.clone(), + cx, + )), + ToolCallStatus::Allowed { .. } | ToolCallStatus::Canceled => { + this.children(tool_call.content.iter().map(|content| { + div() + .py_1p5() + .child( + self.render_tool_call_content( + content, window, cx, + ), + ) + .into_any_element() + })) + } + ToolCallStatus::Rejected => this, + } + } else { + this + } + }), ) }) } @@ -1076,14 +1099,20 @@ impl AcpThreadView { cx: &Context, ) -> AnyElement { match content { - ToolCallContent::Markdown { markdown } => { - div() - .p_2() - .child(self.render_markdown( - markdown.clone(), - default_markdown_style(false, window, cx), - )) - .into_any_element() + ToolCallContent::ContentBlock { content } => { + if let Some(md) = content.markdown() { + div() + .p_2() + .child( + self.render_markdown( + md.clone(), + default_markdown_style(false, window, cx), + ), + ) + .into_any_element() + } else { + Empty.into_any_element() + } } ToolCallContent::Diff { diff: Diff { multibuffer, .. }, @@ -1092,223 +1121,53 @@ impl AcpThreadView { } } - fn render_tool_call_confirmation( + fn render_permission_buttons( &self, - tool_call_id: ToolCallId, - confirmation: &ToolCallConfirmation, - content: Option<&ToolCallContent>, - window: &Window, - cx: &Context, - ) -> AnyElement { - let confirmation_container = v_flex().mt_1().py_1p5(); - - match confirmation { - ToolCallConfirmation::Edit { description } => confirmation_container - .child( - div() - .px_2() - .children(description.clone().map(|description| { - self.render_markdown( - description, - default_markdown_style(false, window, cx), - ) - })), - ) - .children(content.map(|content| self.render_tool_call_content(content, window, cx))) - .child(self.render_confirmation_buttons( - &[AlwaysAllowOption { - id: "always_allow", - label: "Always Allow Edits".into(), - outcome: acp::ToolCallConfirmationOutcome::AlwaysAllow, - }], - tool_call_id, - cx, - )) - .into_any(), - ToolCallConfirmation::Execute { - command, - root_command, - description, - } => confirmation_container - .child(v_flex().px_2().pb_1p5().child(command.clone()).children( - description.clone().map(|description| { - self.render_markdown(description, default_markdown_style(false, window, cx)) - .on_url_click({ - let workspace = self.workspace.clone(); - move |text, window, cx| { - Self::open_link(text, &workspace, window, cx); - } - }) - }), - )) - .children(content.map(|content| self.render_tool_call_content(content, window, cx))) - .child(self.render_confirmation_buttons( - &[AlwaysAllowOption { - id: "always_allow", - label: format!("Always Allow {root_command}").into(), - outcome: acp::ToolCallConfirmationOutcome::AlwaysAllow, - }], - tool_call_id, - cx, - )) - .into_any(), - ToolCallConfirmation::Mcp { - server_name, - tool_name: _, - tool_display_name, - description, - } => confirmation_container - .child( - v_flex() - .px_2() - .pb_1p5() - .child(format!("{server_name} - {tool_display_name}")) - .children(description.clone().map(|description| { - self.render_markdown( - description, - default_markdown_style(false, window, cx), - ) - })), - ) - .children(content.map(|content| self.render_tool_call_content(content, window, cx))) - .child(self.render_confirmation_buttons( - &[ - AlwaysAllowOption { - id: "always_allow_server", - label: format!("Always Allow {server_name}").into(), - outcome: acp::ToolCallConfirmationOutcome::AlwaysAllowMcpServer, - }, - AlwaysAllowOption { - id: "always_allow_tool", - label: format!("Always Allow {tool_display_name}").into(), - outcome: acp::ToolCallConfirmationOutcome::AlwaysAllowTool, - }, - ], - tool_call_id, - cx, - )) - .into_any(), - ToolCallConfirmation::Fetch { description, urls } => confirmation_container - .child( - v_flex() - .px_2() - .pb_1p5() - .gap_1() - .children(urls.iter().map(|url| { - h_flex().child( - Button::new(url.clone(), url) - .icon(IconName::ArrowUpRight) - .icon_color(Color::Muted) - .icon_size(IconSize::XSmall) - .on_click({ - let url = url.clone(); - move |_, _, cx| cx.open_url(&url) - }), - ) - })) - .children(description.clone().map(|description| { - self.render_markdown( - description, - default_markdown_style(false, window, cx), - ) - })), - ) - .children(content.map(|content| self.render_tool_call_content(content, window, cx))) - .child(self.render_confirmation_buttons( - &[AlwaysAllowOption { - id: "always_allow", - label: "Always Allow".into(), - outcome: acp::ToolCallConfirmationOutcome::AlwaysAllow, - }], - tool_call_id, - cx, - )) - .into_any(), - ToolCallConfirmation::Other { description } => confirmation_container - .child(v_flex().px_2().pb_1p5().child(self.render_markdown( - description.clone(), - default_markdown_style(false, window, cx), - ))) - .children(content.map(|content| self.render_tool_call_content(content, window, cx))) - .child(self.render_confirmation_buttons( - &[AlwaysAllowOption { - id: "always_allow", - label: "Always Allow".into(), - outcome: acp::ToolCallConfirmationOutcome::AlwaysAllow, - }], - tool_call_id, - cx, - )) - .into_any(), - } - } - - fn render_confirmation_buttons( - &self, - always_allow_options: &[AlwaysAllowOption], - tool_call_id: ToolCallId, + options: &[acp::PermissionOption], + entry_ix: usize, + tool_call_id: acp::ToolCallId, cx: &Context, ) -> Div { h_flex() - .pt_1p5() + .py_1p5() .px_1p5() .gap_1() .justify_end() .border_t_1() .border_color(self.tool_card_border_color(cx)) - .when(self.agent.supports_always_allow(), |this| { - this.children(always_allow_options.into_iter().map(|always_allow_option| { - let outcome = always_allow_option.outcome; - Button::new( - (always_allow_option.id, tool_call_id.0), - always_allow_option.label.clone(), - ) - .icon(IconName::CheckDouble) + .children(options.iter().map(|option| { + let option_id = SharedString::from(option.id.0.clone()); + Button::new((option_id, entry_ix), option.label.clone()) + .map(|this| match option.kind { + acp::PermissionOptionKind::AllowOnce => { + this.icon(IconName::Check).icon_color(Color::Success) + } + acp::PermissionOptionKind::AllowAlways => { + this.icon(IconName::CheckDouble).icon_color(Color::Success) + } + acp::PermissionOptionKind::RejectOnce => { + this.icon(IconName::X).icon_color(Color::Error) + } + acp::PermissionOptionKind::RejectAlways => { + this.icon(IconName::X).icon_color(Color::Error) + } + }) .icon_position(IconPosition::Start) .icon_size(IconSize::XSmall) - .icon_color(Color::Success) .on_click(cx.listener({ - let id = tool_call_id; + let tool_call_id = tool_call_id.clone(); + let option_id = option.id.clone(); + let option_kind = option.kind; move |this, _, _, cx| { - this.authorize_tool_call(id, outcome, cx); + this.authorize_tool_call( + tool_call_id.clone(), + option_id.clone(), + option_kind, + cx, + ); } })) - })) - }) - .child( - Button::new(("allow", tool_call_id.0), "Allow") - .icon(IconName::Check) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Success) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::Allow, - cx, - ); - } - })), - ) - .child( - Button::new(("reject", tool_call_id.0), "Reject") - .icon(IconName::X) - .icon_position(IconPosition::Start) - .icon_size(IconSize::XSmall) - .icon_color(Color::Error) - .on_click(cx.listener({ - let id = tool_call_id; - move |this, _, _, cx| { - this.authorize_tool_call( - id, - acp::ToolCallConfirmationOutcome::Reject, - cx, - ); - } - })), - ) + })) } fn render_diff_editor(&self, multibuffer: &Entity) -> AnyElement { @@ -2245,12 +2104,11 @@ impl AcpThreadView { .languages .language_for_name("Markdown"); - let (thread_summary, markdown) = match &self.thread_state { - ThreadState::Ready { thread, .. } | ThreadState::Unauthenticated { thread } => { - let thread = thread.read(cx); - (thread.title().to_string(), thread.to_markdown(cx)) - } - ThreadState::Loading { .. } | ThreadState::LoadError(..) => return Task::ready(Ok(())), + let (thread_summary, markdown) = if let Some(thread) = self.thread() { + let thread = thread.read(cx); + (thread.title().to_string(), thread.to_markdown(cx)) + } else { + return Task::ready(Ok(())); }; window.spawn(cx, async move |cx| { diff --git a/crates/agent_ui/src/agent_diff.rs b/crates/agent_ui/src/agent_diff.rs index e69664ce88..ec0a11f86b 100644 --- a/crates/agent_ui/src/agent_diff.rs +++ b/crates/agent_ui/src/agent_diff.rs @@ -1506,8 +1506,7 @@ impl AgentDiff { .read(cx) .entries() .last() - .and_then(|entry| entry.diff()) - .is_some() + .map_or(false, |entry| entry.diffs().next().is_some()) { self.update_reviewing_editors(workspace, window, cx); } @@ -1517,8 +1516,7 @@ impl AgentDiff { .read(cx) .entries() .get(*ix) - .and_then(|entry| entry.diff()) - .is_some() + .map_or(false, |entry| entry.diffs().next().is_some()) { self.update_reviewing_editors(workspace, window, cx); } diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index a0250816a0..4b3db4bc1d 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -440,7 +440,7 @@ pub struct AgentPanel { local_timezone: UtcOffset, active_view: ActiveView, acp_message_history: - Rc>>, + Rc>>>, previous_view: Option, history_store: Entity, history: Entity, diff --git a/crates/context_server/src/client.rs b/crates/context_server/src/client.rs index 6b24d9b136..8c5e7da0f1 100644 --- a/crates/context_server/src/client.rs +++ b/crates/context_server/src/client.rs @@ -1,6 +1,6 @@ use anyhow::{Context as _, Result, anyhow}; use collections::HashMap; -use futures::{FutureExt, StreamExt, channel::oneshot, select}; +use futures::{FutureExt, StreamExt, channel::oneshot, future, select}; use gpui::{AppContext as _, AsyncApp, BackgroundExecutor, Task}; use parking_lot::Mutex; use postage::barrier; @@ -10,15 +10,19 @@ use smol::channel; use std::{ fmt, path::PathBuf, + pin::pin, sync::{ Arc, atomic::{AtomicI32, Ordering::SeqCst}, }, time::{Duration, Instant}, }; -use util::TryFutureExt; +use util::{ResultExt, TryFutureExt}; -use crate::transport::{StdioTransport, Transport}; +use crate::{ + transport::{StdioTransport, Transport}, + types::{CancelledParams, ClientNotification, Notification as _, notifications::Cancelled}, +}; const JSON_RPC_VERSION: &str = "2.0"; const REQUEST_TIMEOUT: Duration = Duration::from_secs(60); @@ -32,6 +36,7 @@ pub const INTERNAL_ERROR: i32 = -32603; type ResponseHandler = Box)>; type NotificationHandler = Box; +type RequestHandler = Box; #[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)] #[serde(untagged)] @@ -78,6 +83,15 @@ pub struct Request<'a, T> { pub params: T, } +#[derive(Serialize, Deserialize)] +pub struct AnyRequest<'a> { + pub jsonrpc: &'a str, + pub id: RequestId, + pub method: &'a str, + #[serde(skip_serializing_if = "is_null_value")] + pub params: Option<&'a RawValue>, +} + #[derive(Serialize, Deserialize)] struct AnyResponse<'a> { jsonrpc: &'a str, @@ -176,15 +190,23 @@ impl Client { Arc::new(Mutex::new(HashMap::<_, NotificationHandler>::default())); let response_handlers = Arc::new(Mutex::new(Some(HashMap::<_, ResponseHandler>::default()))); + let request_handlers = Arc::new(Mutex::new(HashMap::<_, RequestHandler>::default())); let receive_input_task = cx.spawn({ let notification_handlers = notification_handlers.clone(); let response_handlers = response_handlers.clone(); + let request_handlers = request_handlers.clone(); let transport = transport.clone(); async move |cx| { - Self::handle_input(transport, notification_handlers, response_handlers, cx) - .log_err() - .await + Self::handle_input( + transport, + notification_handlers, + request_handlers, + response_handlers, + cx, + ) + .log_err() + .await } }); let receive_err_task = cx.spawn({ @@ -230,13 +252,24 @@ impl Client { async fn handle_input( transport: Arc, notification_handlers: Arc>>, + request_handlers: Arc>>, response_handlers: Arc>>>, cx: &mut AsyncApp, ) -> anyhow::Result<()> { let mut receiver = transport.receive(); while let Some(message) = receiver.next().await { - if let Ok(response) = serde_json::from_str::(&message) { + log::trace!("recv: {}", &message); + if let Ok(request) = serde_json::from_str::(&message) { + let mut request_handlers = request_handlers.lock(); + if let Some(handler) = request_handlers.get_mut(request.method) { + handler( + request.id, + request.params.unwrap_or(RawValue::NULL), + cx.clone(), + ); + } + } else if let Ok(response) = serde_json::from_str::(&message) { if let Some(handlers) = response_handlers.lock().as_mut() { if let Some(handler) = handlers.remove(&response.id) { handler(Ok(message.to_string())); @@ -247,6 +280,8 @@ impl Client { if let Some(handler) = notification_handlers.get_mut(notification.method.as_str()) { handler(notification.params.unwrap_or(Value::Null), cx.clone()); } + } else { + log::error!("Unhandled JSON from context_server: {}", message); } } @@ -294,6 +329,24 @@ impl Client { &self, method: &str, params: impl Serialize, + ) -> Result { + self.request_impl(method, params, None).await + } + + pub async fn cancellable_request( + &self, + method: &str, + params: impl Serialize, + cancel_rx: oneshot::Receiver<()>, + ) -> Result { + self.request_impl(method, params, Some(cancel_rx)).await + } + + pub async fn request_impl( + &self, + method: &str, + params: impl Serialize, + cancel_rx: Option>, ) -> Result { let id = self.next_id.fetch_add(1, SeqCst); let request = serde_json::to_string(&Request { @@ -330,6 +383,16 @@ impl Client { send?; let mut timeout = executor.timer(REQUEST_TIMEOUT).fuse(); + let mut cancel_fut = pin!( + match cancel_rx { + Some(rx) => future::Either::Left(async { + rx.await.log_err(); + }), + None => future::Either::Right(future::pending()), + } + .fuse() + ); + select! { response = rx.fuse() => { let elapsed = started.elapsed(); @@ -348,6 +411,16 @@ impl Client { Err(_) => anyhow::bail!("cancelled") } } + _ = cancel_fut => { + self.notify( + Cancelled::METHOD, + ClientNotification::Cancelled(CancelledParams { + request_id: RequestId::Int(id), + reason: None + }) + ).log_err(); + anyhow::bail!("Request cancelled") + } _ = timeout => { log::error!("cancelled csp request task for {method:?} id {id} which took over {:?}", REQUEST_TIMEOUT); anyhow::bail!("Context server request timeout"); diff --git a/crates/context_server/src/protocol.rs b/crates/context_server/src/protocol.rs index d8bbac60d6..7263f502fa 100644 --- a/crates/context_server/src/protocol.rs +++ b/crates/context_server/src/protocol.rs @@ -6,6 +6,9 @@ //! of messages. use anyhow::Result; +use futures::channel::oneshot; +use gpui::AsyncApp; +use serde_json::Value; use crate::client::Client; use crate::types::{self, Notification, Request}; @@ -95,7 +98,24 @@ impl InitializedContextServerProtocol { self.inner.request(T::METHOD, params).await } + pub async fn cancellable_request( + &self, + params: T::Params, + cancel_rx: oneshot::Receiver<()>, + ) -> Result { + self.inner + .cancellable_request(T::METHOD, params, cancel_rx) + .await + } + pub fn notify(&self, params: T::Params) -> Result<()> { self.inner.notify(T::METHOD, params) } + + pub fn on_notification(&self, method: &'static str, f: F) + where + F: 'static + Send + FnMut(Value, AsyncApp), + { + self.inner.on_notification(method, f); + } } diff --git a/crates/context_server/src/types.rs b/crates/context_server/src/types.rs index 4a6fdcabd3..f92c86aa3c 100644 --- a/crates/context_server/src/types.rs +++ b/crates/context_server/src/types.rs @@ -3,6 +3,8 @@ use serde::de::DeserializeOwned; use serde::{Deserialize, Serialize}; use url::Url; +use crate::client::RequestId; + pub const LATEST_PROTOCOL_VERSION: &str = "2025-03-26"; pub const VERSION_2024_11_05: &str = "2024-11-05"; @@ -100,6 +102,7 @@ pub mod notifications { notification!("notifications/initialized", Initialized, ()); notification!("notifications/progress", Progress, ProgressParams); notification!("notifications/message", Message, MessageParams); + notification!("notifications/cancelled", Cancelled, CancelledParams); notification!( "notifications/resources/updated", ResourcesUpdated, @@ -617,11 +620,14 @@ pub enum ClientNotification { Initialized, Progress(ProgressParams), RootsListChanged, - Cancelled { - request_id: String, - #[serde(skip_serializing_if = "Option::is_none")] - reason: Option, - }, + Cancelled(CancelledParams), +} + +#[derive(Debug, Serialize, Deserialize)] +pub struct CancelledParams { + pub request_id: RequestId, + #[serde(skip_serializing_if = "Option::is_none")] + pub reason: Option, } #[derive(Debug, Serialize, Deserialize)] From 1f7ff956bcef31f93db4b9841737c0bc893bafc9 Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Thu, 24 Jul 2025 14:29:28 -0400 Subject: [PATCH 0196/1052] Fix environment loading with nushell (#35002) Closes https://github.com/zed-industries/zed/issues/34739 I believe this is a regression introduced here: - https://github.com/zed-industries/zed/pull/33599 Release Notes: - Fixed a regression with loading environment variables in nushell --- crates/util/src/shell_env.rs | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/crates/util/src/shell_env.rs b/crates/util/src/shell_env.rs index 21f6096f19..ed6c8a23cc 100644 --- a/crates/util/src/shell_env.rs +++ b/crates/util/src/shell_env.rs @@ -18,10 +18,13 @@ pub fn capture(directory: &std::path::Path) -> Result format!(">[1={}]", ENV_OUTPUT_FD), // `[1=0]` - _ => format!(">&{}", ENV_OUTPUT_FD), // `>&0` + const FD_STDIN: std::os::fd::RawFd = 0; + const FD_STDOUT: std::os::fd::RawFd = 1; + + let (fd_num, redir) = match shell_name { + Some("rc") => (FD_STDIN, format!(">[1={}]", FD_STDIN)), // `[1=0]` + Some("nu") => (FD_STDOUT, "".to_string()), + _ => (FD_STDIN, format!(">&{}", FD_STDIN)), // `>&0` }; command.stdin(Stdio::null()); command.stdout(Stdio::piped()); @@ -48,7 +51,7 @@ pub fn capture(directory: &std::path::Path) -> Result Date: Thu, 24 Jul 2025 11:44:26 -0700 Subject: [PATCH 0197/1052] Increase the number of parallel request handlers per connection (#35046) Discussed this with @ConradIrwin. The problem we're having with collab is that a bunch of LSP requests take a really long time to resolve, particularly `RefreshCodeLens`. But Those requests are sharing a limited amount of concurrency that we've allocated for all message traffic on one connection. That said, there's not _that_ many concurrent requests made at any one time. The burst traffic seems to top out in the low hundreds for these requests. So let's just expand the amount of space in the queue to accommodate these long-running requests while we work on upgrading our cloud infrastructure. Release Notes: - N/A Co-authored-by: finn --- crates/collab/src/rpc.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs index 0735b08e89..5c5de2f36e 100644 --- a/crates/collab/src/rpc.rs +++ b/crates/collab/src/rpc.rs @@ -829,7 +829,7 @@ impl Server { // This arrangement ensures we will attempt to process earlier messages first, but fall // back to processing messages arrived later in the spirit of making progress. let mut foreground_message_handlers = FuturesUnordered::new(); - let concurrent_handlers = Arc::new(Semaphore::new(256)); + let concurrent_handlers = Arc::new(Semaphore::new(512)); loop { let next_message = async { let permit = concurrent_handlers.clone().acquire_owned().await.unwrap(); From 707df516647f07c05e0c04e67ee032279b3d8afa Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Thu, 24 Jul 2025 15:39:13 -0400 Subject: [PATCH 0198/1052] Fix environment loading with tcsh (#35054) Closes https://github.com/zed-industries/zed/issues/34973 Fixes an issue where environment variables were not loaded when the user's shell was tcsh and instead a file named `0` was dumped in the current working directory with a copy of your environment variables as json. Follow-up to: - https://github.com/zed-industries/zed/pull/35002 - https://github.com/zed-industries/zed/pull/33599 Release Notes: - Fixed a regression with loading environment variables in nushell --- crates/util/src/shell_env.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/util/src/shell_env.rs b/crates/util/src/shell_env.rs index ed6c8a23cc..d737999e45 100644 --- a/crates/util/src/shell_env.rs +++ b/crates/util/src/shell_env.rs @@ -23,7 +23,7 @@ pub fn capture(directory: &std::path::Path) -> Result (FD_STDIN, format!(">[1={}]", FD_STDIN)), // `[1=0]` - Some("nu") => (FD_STDOUT, "".to_string()), + Some("nu") | Some("tcsh") => (FD_STDOUT, "".to_string()), _ => (FD_STDIN, format!(">&{}", FD_STDIN)), // `>&0` }; command.stdin(Stdio::null()); From 66acc2698aa39468ea9a0beecc8892cc57f1a91f Mon Sep 17 00:00:00 2001 From: Zachary Hamm Date: Thu, 24 Jul 2025 17:25:21 -0500 Subject: [PATCH 0199/1052] git_hosting_providers: Support GitHub remote URLs that start with a slash (#34134) Remote URLs like `git@github.com:/zed-industries/zed` are valid git remotes, but currently Zed does not parse them correctly. The result is invalid "permalink" generation, and presumably other bugs anywhere that git remote urls are required for the current repository. This ensures Zed will parse those URLs correctly. Release Notes: - Improved support for GitHub remote urls where the username/organization is preceded by an extra `/` to match the behavior of `git`, `gh` and `github.com`. Co-authored-by: Peter Tripp --- .../src/providers/github.rs | 22 ++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/crates/git_hosting_providers/src/providers/github.rs b/crates/git_hosting_providers/src/providers/github.rs index 649b2f30ae..30f8d058a7 100644 --- a/crates/git_hosting_providers/src/providers/github.rs +++ b/crates/git_hosting_providers/src/providers/github.rs @@ -159,7 +159,11 @@ impl GitHostingProvider for Github { } let mut path_segments = url.path_segments()?; - let owner = path_segments.next()?; + let mut owner = path_segments.next()?; + if owner.is_empty() { + owner = path_segments.next()?; + } + let repo = path_segments.next()?.trim_end_matches(".git"); Some(ParsedGitRemote { @@ -244,6 +248,22 @@ mod tests { use super::*; + #[test] + fn test_remote_url_with_root_slash() { + let remote_url = "git@github.com:/zed-industries/zed"; + let parsed_remote = Github::public_instance() + .parse_remote_url(remote_url) + .unwrap(); + + assert_eq!( + parsed_remote, + ParsedGitRemote { + owner: "zed-industries".into(), + repo: "zed".into(), + } + ); + } + #[test] fn test_invalid_self_hosted_remote_url() { let remote_url = "git@github.com:zed-industries/zed.git"; From f78a1123873526bb112183033641d9077b47981c Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Fri, 25 Jul 2025 05:13:09 +0530 Subject: [PATCH 0200/1052] gpui: Add `scroll_to_item_with_offset` to `UniformListScrollState` (#35064) Previously we had `ScrollStrategy::ToPosition(usize)` which lets you define the offset where you want to scroll that item to. This is the same as `ScrollStrategy::Top` but imagine some space reserved at the top. This PR removes `ScrollStrategy::ToPosition` in favor of `scroll_to_item_with_offset` which is the method to do the same. The reason to add this method is that now not just `ScrollStrategy::Top` but `ScrollStrategy::Center` can also uses this offset to center the item in the remaining unreserved space. ```rs // Before scroll_handle.scroll_to_item(index, ScrollStrategy::ToPosition(offset)); // After scroll_handle.scroll_to_item_with_offset(index, ScrollStrategy::Top, offset); // New! Centers item skipping first x items scroll_handle.scroll_to_item_with_offset(index, ScrollStrategy::Center, offset); ``` This will be useful for follow up PR. Release Notes: - N/A --- crates/gpui/src/elements/uniform_list.rs | 64 ++++++++++++++++------- crates/project_panel/src/project_panel.rs | 5 +- 2 files changed, 45 insertions(+), 24 deletions(-) diff --git a/crates/gpui/src/elements/uniform_list.rs b/crates/gpui/src/elements/uniform_list.rs index e80656a078..cdf90d4eb8 100644 --- a/crates/gpui/src/elements/uniform_list.rs +++ b/crates/gpui/src/elements/uniform_list.rs @@ -88,15 +88,24 @@ pub enum ScrollStrategy { /// May not be possible if there's not enough list items above the item scrolled to: /// in this case, the element will be placed at the closest possible position. Center, - /// Scrolls the element to be at the given item index from the top of the viewport. - ToPosition(usize), +} + +#[derive(Clone, Copy, Debug)] +#[allow(missing_docs)] +pub struct DeferredScrollToItem { + /// The item index to scroll to + pub item_index: usize, + /// The scroll strategy to use + pub strategy: ScrollStrategy, + /// The offset in number of items + pub offset: usize, } #[derive(Clone, Debug, Default)] #[allow(missing_docs)] pub struct UniformListScrollState { pub base_handle: ScrollHandle, - pub deferred_scroll_to_item: Option<(usize, ScrollStrategy)>, + pub deferred_scroll_to_item: Option, /// Size of the item, captured during last layout. pub last_item_size: Option, /// Whether the list was vertically flipped during last layout. @@ -126,7 +135,24 @@ impl UniformListScrollHandle { /// Scroll the list to the given item index. pub fn scroll_to_item(&self, ix: usize, strategy: ScrollStrategy) { - self.0.borrow_mut().deferred_scroll_to_item = Some((ix, strategy)); + self.0.borrow_mut().deferred_scroll_to_item = Some(DeferredScrollToItem { + item_index: ix, + strategy, + offset: 0, + }); + } + + /// Scroll the list to the given item index with an offset. + /// + /// For ScrollStrategy::Top, the item will be placed at the offset position from the top. + /// + /// For ScrollStrategy::Center, the item will be centered between offset and the last visible item. + pub fn scroll_to_item_with_offset(&self, ix: usize, strategy: ScrollStrategy, offset: usize) { + self.0.borrow_mut().deferred_scroll_to_item = Some(DeferredScrollToItem { + item_index: ix, + strategy, + offset, + }); } /// Check if the list is flipped vertically. @@ -139,7 +165,8 @@ impl UniformListScrollHandle { pub fn logical_scroll_top_index(&self) -> usize { let this = self.0.borrow(); this.deferred_scroll_to_item - .map(|(ix, _)| ix) + .as_ref() + .map(|deferred| deferred.item_index) .unwrap_or_else(|| this.base_handle.logical_scroll_top().0) } @@ -320,7 +347,8 @@ impl Element for UniformList { scroll_offset.x = Pixels::ZERO; } - if let Some((mut ix, scroll_strategy)) = shared_scroll_to_item { + if let Some(deferred_scroll) = shared_scroll_to_item { + let mut ix = deferred_scroll.item_index; if y_flipped { ix = self.item_count.saturating_sub(ix + 1); } @@ -329,23 +357,28 @@ impl Element for UniformList { let item_top = item_height * ix + padding.top; let item_bottom = item_top + item_height; let scroll_top = -updated_scroll_offset.y; + let offset_pixels = item_height * deferred_scroll.offset; let mut scrolled_to_top = false; - if item_top < scroll_top + padding.top { + + if item_top < scroll_top + padding.top + offset_pixels { scrolled_to_top = true; - updated_scroll_offset.y = -(item_top) + padding.top; + updated_scroll_offset.y = -(item_top) + padding.top + offset_pixels; } else if item_bottom > scroll_top + list_height - padding.bottom { scrolled_to_top = true; updated_scroll_offset.y = -(item_bottom - list_height) - padding.bottom; } - match scroll_strategy { + match deferred_scroll.strategy { ScrollStrategy::Top => {} ScrollStrategy::Center => { if scrolled_to_top { let item_center = item_top + item_height / 2.0; - let target_scroll_top = item_center - list_height / 2.0; - if item_top < scroll_top + let viewport_height = list_height - offset_pixels; + let viewport_center = offset_pixels + viewport_height / 2.0; + let target_scroll_top = item_center - viewport_center; + + if item_top < scroll_top + offset_pixels || item_bottom > scroll_top + list_height { updated_scroll_offset.y = -target_scroll_top @@ -355,15 +388,6 @@ impl Element for UniformList { } } } - ScrollStrategy::ToPosition(sticky_index) => { - let target_y_in_viewport = item_height * sticky_index; - let target_scroll_top = item_top - target_y_in_viewport; - let max_scroll_top = - (content_height - list_height).max(Pixels::ZERO); - let new_scroll_top = - target_scroll_top.clamp(Pixels::ZERO, max_scroll_top); - updated_scroll_offset.y = -new_scroll_top; - } } scroll_offset = *updated_scroll_offset } diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs index 76be97e393..dd680981fc 100644 --- a/crates/project_panel/src/project_panel.rs +++ b/crates/project_panel/src/project_panel.rs @@ -4207,10 +4207,7 @@ impl ProjectPanel { this.marked_entries.clear(); if is_sticky { if let Some((_, _, index)) = this.index_for_entry(entry_id, worktree_id) { - let strategy = sticky_index - .map(ScrollStrategy::ToPosition) - .unwrap_or(ScrollStrategy::Top); - this.scroll_handle.scroll_to_item(index, strategy); + this.scroll_handle.scroll_to_item_with_offset(index, ScrollStrategy::Top, sticky_index.unwrap_or(0)); cx.notify(); // move down by 1px so that clicked item // don't count as sticky anymore From 4ee52433ae606b095a9054162060e59d33874e16 Mon Sep 17 00:00:00 2001 From: Daniel Sauble Date: Thu, 24 Jul 2025 17:00:59 -0700 Subject: [PATCH 0201/1052] Do not subtract gutter margin twice from the editor width (#34564) Closes #33176 In auto-height layouts, horizontal autoscroll can occur right before soft wrapping is triggered. This seems to be caused by gutter margin being subtracted twice from the editor width. If we subtract gutter width only once, the horizontal autoscroll behavior goes away. Before: https://github.com/user-attachments/assets/03b6687e-3c0e-4b34-8e07-a228bcc6f798 After: https://github.com/user-attachments/assets/84e54088-b5bd-4259-a193-d9fcf32cd3a7 Release Notes: - Fixes issue with auto-height layouts where horizontal autoscroll is triggered right before text wraps --------- Co-authored-by: MrSubidubi --- crates/editor/src/element.rs | 62 +++++++++++------------------------- 1 file changed, 18 insertions(+), 44 deletions(-) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index 5fd6b028f4..7e77f113ac 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -7944,17 +7944,11 @@ impl Element for EditorElement { right: right_margin, }; - // Offset the content_bounds from the text_bounds by the gutter margin (which - // is roughly half a character wide) to make hit testing work more like how we want. - let content_offset = point(editor_margins.gutter.margin, Pixels::ZERO); - - let editor_content_width = editor_width - content_offset.x; - snapshot = self.editor.update(cx, |editor, cx| { editor.last_bounds = Some(bounds); editor.gutter_dimensions = gutter_dimensions; editor.set_visible_line_count(bounds.size.height / line_height, window, cx); - editor.set_visible_column_count(editor_content_width / em_advance); + editor.set_visible_column_count(editor_width / em_advance); if matches!( editor.mode, @@ -7966,10 +7960,10 @@ impl Element for EditorElement { let wrap_width = match editor.soft_wrap_mode(cx) { SoftWrap::GitDiff => None, SoftWrap::None => Some(wrap_width_for(MAX_LINE_LEN as u32 / 2)), - SoftWrap::EditorWidth => Some(editor_content_width), + SoftWrap::EditorWidth => Some(editor_width), SoftWrap::Column(column) => Some(wrap_width_for(column)), SoftWrap::Bounded(column) => { - Some(editor_content_width.min(wrap_width_for(column))) + Some(editor_width.min(wrap_width_for(column))) } }; @@ -7994,13 +7988,12 @@ impl Element for EditorElement { HitboxBehavior::Normal, ); + // Offset the content_bounds from the text_bounds by the gutter margin (which + // is roughly half a character wide) to make hit testing work more like how we want. + let content_offset = point(editor_margins.gutter.margin, Pixels::ZERO); let content_origin = text_hitbox.origin + content_offset; - let editor_text_bounds = - Bounds::from_corners(content_origin, bounds.bottom_right()); - - let height_in_lines = editor_text_bounds.size.height / line_height; - + let height_in_lines = bounds.size.height / line_height; let max_row = snapshot.max_point().row().as_f32(); // The max scroll position for the top of the window @@ -8384,7 +8377,6 @@ impl Element for EditorElement { glyph_grid_cell, size(longest_line_width, max_row.as_f32() * line_height), longest_line_blame_width, - editor_width, EditorSettings::get_global(cx), ); @@ -8456,7 +8448,7 @@ impl Element for EditorElement { MultiBufferRow(end_anchor.to_point(&snapshot.buffer_snapshot).row); let scroll_max = point( - ((scroll_width - editor_content_width) / em_advance).max(0.0), + ((scroll_width - editor_width) / em_advance).max(0.0), max_scroll_top, ); @@ -8468,7 +8460,7 @@ impl Element for EditorElement { if needs_horizontal_autoscroll.0 && let Some(new_scroll_position) = editor.autoscroll_horizontally( start_row, - editor_content_width, + editor_width, scroll_width, em_advance, &line_layouts, @@ -9049,7 +9041,6 @@ impl ScrollbarLayoutInformation { glyph_grid_cell: Size, document_size: Size, longest_line_blame_width: Pixels, - editor_width: Pixels, settings: &EditorSettings, ) -> Self { let vertical_overscroll = match settings.scroll_beyond_last_line { @@ -9060,19 +9051,11 @@ impl ScrollbarLayoutInformation { } }; - let right_margin = if document_size.width + longest_line_blame_width >= editor_width { - glyph_grid_cell.width - } else { - px(0.0) - }; - - let overscroll = size(right_margin + longest_line_blame_width, vertical_overscroll); - - let scroll_range = document_size + overscroll; + let overscroll = size(longest_line_blame_width, vertical_overscroll); ScrollbarLayoutInformation { editor_bounds, - scroll_range, + scroll_range: document_size + overscroll, glyph_grid_cell, } } @@ -9177,7 +9160,7 @@ struct EditorScrollbars { impl EditorScrollbars { pub fn from_scrollbar_axes( - settings_visibility: ScrollbarAxes, + show_scrollbar: ScrollbarAxes, layout_information: &ScrollbarLayoutInformation, content_offset: gpui::Point, scroll_position: gpui::Point, @@ -9215,22 +9198,13 @@ impl EditorScrollbars { }; let mut create_scrollbar_layout = |axis| { - settings_visibility - .along(axis) + let viewport_size = viewport_size.along(axis); + let scroll_range = scroll_range.along(axis); + + // We always want a vertical scrollbar track for scrollbar diagnostic visibility. + (show_scrollbar.along(axis) + && (axis == ScrollbarAxis::Vertical || scroll_range > viewport_size)) .then(|| { - ( - viewport_size.along(axis) - content_offset.along(axis), - scroll_range.along(axis), - ) - }) - .filter(|(viewport_size, scroll_range)| { - // The scrollbar should only be rendered if the content does - // not entirely fit into the editor - // However, this only applies to the horizontal scrollbar, as information about the - // vertical scrollbar layout is always needed for scrollbar diagnostics. - axis != ScrollbarAxis::Horizontal || viewport_size < scroll_range - }) - .map(|(viewport_size, scroll_range)| { ScrollbarLayout::new( window.insert_hitbox(scrollbar_bounds_for(axis), HitboxBehavior::Normal), viewport_size, From 6e4f7470413ab709f766793cd23c0aa65700cf99 Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Fri, 25 Jul 2025 06:21:38 +0530 Subject: [PATCH 0202/1052] project_panel: Fix autoscroll to treat entries behind sticky items as out of viewport (#35067) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closes #34831 Autoscroll centers items only if they’re out of viewport. Before this PR, entry behind sticky items was not considered out of viewport, and hence actions like `reveal in project panel` or focusing buffer would not autoscroll that entry into the view in that case. This PR fixes that by using recently added `scroll_to_item_with_offset` in https://github.com/zed-industries/zed/pull/35064. Release Notes: - Fixed issue where `pane: reveal in project panel` action was not working if the entry was behind sticky items. --- crates/project_panel/src/project_panel.rs | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs index dd680981fc..05e6bfe4df 100644 --- a/crates/project_panel/src/project_panel.rs +++ b/crates/project_panel/src/project_panel.rs @@ -114,6 +114,7 @@ pub struct ProjectPanel { mouse_down: bool, hover_expand_task: Option>, previous_drag_position: Option>, + sticky_items_count: usize, } struct DragTargetEntry { @@ -572,6 +573,9 @@ impl ProjectPanel { if project_panel_settings.hide_root != new_settings.hide_root { this.update_visible_entries(None, cx); } + if project_panel_settings.sticky_scroll && !new_settings.sticky_scroll { + this.sticky_items_count = 0; + } project_panel_settings = new_settings; this.update_diagnostics(cx); cx.notify(); @@ -615,6 +619,7 @@ impl ProjectPanel { mouse_down: false, hover_expand_task: None, previous_drag_position: None, + sticky_items_count: 0, }; this.update_visible_entries(None, cx); @@ -2267,8 +2272,11 @@ impl ProjectPanel { fn autoscroll(&mut self, cx: &mut Context) { if let Some((_, _, index)) = self.selection.and_then(|s| self.index_for_selection(s)) { - self.scroll_handle - .scroll_to_item(index, ScrollStrategy::Center); + self.scroll_handle.scroll_to_item_with_offset( + index, + ScrollStrategy::Center, + self.sticky_items_count, + ); cx.notify(); } } @@ -5344,7 +5352,10 @@ impl Render for ProjectPanel { items }, |this, marker_entry, window, cx| { - this.render_sticky_entries(marker_entry, window, cx) + let sticky_entries = + this.render_sticky_entries(marker_entry, window, cx); + this.sticky_items_count = sticky_entries.len(); + sticky_entries }, ); list.with_decoration(if show_indent_guides { From a0f2019b6f031c0933022797932f8ca90871cfb4 Mon Sep 17 00:00:00 2001 From: morgankrey Date: Thu, 24 Jul 2025 19:18:40 -0600 Subject: [PATCH 0203/1052] Add sales tax to docs (#35059) Release Notes: - N/A --- docs/src/ai/billing.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/docs/src/ai/billing.md b/docs/src/ai/billing.md index c49bacd883..e8587e1fef 100644 --- a/docs/src/ai/billing.md +++ b/docs/src/ai/billing.md @@ -25,3 +25,12 @@ From Stripe’s secure portal, you can download all current and historical invoi You can update your payment method, company name, address, and tax information through the billing portal. Please note that changes to billing information will **only** affect future invoices — **we cannot modify historical invoices**. + +## Sales Tax {#sales-tax} + +Zed partners with [Sphere](https://www.getsphere.com/) to calculate indirect tax rate for invoices, based on customer location and the product being sold. Tax is listed as a separate line item on invoices, based preferentially on your billing address, followed by the card issue country known to Stripe. + +If you have a VAT/GST ID, you can add it at [zed.dev/account](https://zed.dev/account) by clicking "Manage" on your subscription. Check the box that denotes you as a business. + +Please note that changes to VAT/GST IDs and address will **only** affect future invoices — **we cannot modify historical invoices**. +Questions or issues can be directed to billing-support@zed.dev. From b446d66be780c5b73f5b429033055e950edf27e2 Mon Sep 17 00:00:00 2001 From: morgankrey Date: Thu, 24 Jul 2025 19:25:39 -0600 Subject: [PATCH 0204/1052] Telemetry docs cleanup (#35060) Release Notes: - N/A --- docs/src/telemetry.md | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/docs/src/telemetry.md b/docs/src/telemetry.md index 20018b920a..7f5994be0c 100644 --- a/docs/src/telemetry.md +++ b/docs/src/telemetry.md @@ -22,8 +22,9 @@ The telemetry settings can also be configured via the welcome screen, which can Telemetry is sent from the application to our servers. Data is proxied through our servers to enable us to easily switch analytics services. We currently use: - [Axiom](https://axiom.co): Cloud-monitoring service - stores diagnostic events -- [Snowflake](https://snowflake.com): Business Intelligence platform - stores both diagnostic and metric events -- [Metabase](https://www.metabase.com): Dashboards - dashboards built around data pulled from Snowflake +- [Snowflake](https://snowflake.com): Data warehouse - stores both diagnostic and metric events +- [Hex](https://www.hex.tech): Dashboards and data exploration - accesses data stored in Snowflake +- [Amplitude](https://www.amplitude.com): Dashboards and data exploration - accesses data stored in Snowflake ## Types of Telemetry @@ -33,7 +34,7 @@ Diagnostic events include debug information (stack traces) from crash reports. R You can see what data is sent when a panic occurs by inspecting the `Panic` struct in [crates/telemetry_events/src/telemetry_events.rs](https://github.com/zed-industries/zed/blob/main/crates/telemetry_events/src/telemetry_events.rs) in the Zed repo. You can find additional information in the [Debugging Crashes](./development/debugging-crashes.md) documentation. -### Usage Data (Metrics) {#metrics} +### Client-Side Usage Data {#client-metrics} To improve Zed and understand how it is being used in the wild, Zed optionally collects usage data like the following: @@ -50,6 +51,12 @@ You can audit the metrics data that Zed has reported by running the command {#ac You can see the full list of the event types and exactly the data sent for each by inspecting the `Event` enum and the associated structs in [crates/telemetry_events/src/telemetry_events.rs](https://github.com/zed-industries/zed/blob/main/crates/telemetry_events/src/telemetry_events.rs) in the Zed repository. +### Server-Side Usage Data {#metrics} + +When using Zed's hosted services, we may collect, generate, and Process data to allow us to support users and improve our hosted offering. Examples include metadata around rate limiting and billing metrics/token usage. Zed does not persistently store user content or use user content to evaluate and/or improve our AI features, unless it is explicitly shared with Zed, and we have a zero-data retention agreement with Anthropic. + +You can see more about our stance on data collection (and that any prompt data shared with Zed is explicitly opt-in) at [AI Improvement](./ai/ai-improvement.md). + ## Concerns and Questions If you have concerns about telemetry, please feel free to [open an issue](https://github.com/zed-industries/zed/issues/new/choose). From 15c9da4ea4e740faa22cf7c740bed666fdf9ff4a Mon Sep 17 00:00:00 2001 From: Agus Zubiaga Date: Thu, 24 Jul 2025 23:19:20 -0300 Subject: [PATCH 0205/1052] Add ability to register tools in `McpServer` (#35068) Makes it easier to add tools to a server by implementing a trait Release Notes: - N/A --- crates/agent_servers/src/claude.rs | 11 +- crates/agent_servers/src/claude/mcp_server.rs | 418 +++++++++--------- crates/context_server/src/listener.rs | 217 ++++++++- crates/context_server/src/types.rs | 6 +- 4 files changed, 408 insertions(+), 244 deletions(-) diff --git a/crates/agent_servers/src/claude.rs b/crates/agent_servers/src/claude.rs index 5f35b4af73..d63d8c43cf 100644 --- a/crates/agent_servers/src/claude.rs +++ b/crates/agent_servers/src/claude.rs @@ -2,6 +2,7 @@ mod mcp_server; pub mod tools; use collections::HashMap; +use context_server::listener::McpServerTool; use project::Project; use settings::SettingsStore; use smol::process::Child; @@ -332,10 +333,16 @@ async fn spawn_claude( &format!( "mcp__{}__{}", mcp_server::SERVER_NAME, - mcp_server::PERMISSION_TOOL + mcp_server::PermissionTool::NAME, ), "--allowedTools", - "mcp__zed__Read,mcp__zed__Edit", + &format!( + "mcp__{}__{},mcp__{}__{}", + mcp_server::SERVER_NAME, + mcp_server::EditTool::NAME, + mcp_server::SERVER_NAME, + mcp_server::ReadTool::NAME + ), "--disallowedTools", "Read,Edit", ]) diff --git a/crates/agent_servers/src/claude/mcp_server.rs b/crates/agent_servers/src/claude/mcp_server.rs index 0a39a02931..4272a972dc 100644 --- a/crates/agent_servers/src/claude/mcp_server.rs +++ b/crates/agent_servers/src/claude/mcp_server.rs @@ -1,49 +1,24 @@ use std::path::PathBuf; +use crate::claude::tools::{ClaudeTool, EditToolParams, ReadToolParams}; use acp_thread::AcpThread; use agent_client_protocol as acp; use anyhow::{Context, Result}; use collections::HashMap; +use context_server::listener::{McpServerTool, ToolResponse}; use context_server::types::{ - CallToolParams, CallToolResponse, Implementation, InitializeParams, InitializeResponse, - ListToolsResponse, ProtocolVersion, ServerCapabilities, Tool, ToolAnnotations, - ToolResponseContent, ToolsCapabilities, requests, + Implementation, InitializeParams, InitializeResponse, ProtocolVersion, ServerCapabilities, + ToolAnnotations, ToolResponseContent, ToolsCapabilities, requests, }; -use gpui::{App, AsyncApp, Entity, Task, WeakEntity}; +use gpui::{App, AsyncApp, Task, WeakEntity}; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; -use crate::claude::tools::{ClaudeTool, EditToolParams, ReadToolParams}; - pub struct ClaudeZedMcpServer { server: context_server::listener::McpServer, } pub const SERVER_NAME: &str = "zed"; -pub const READ_TOOL: &str = "Read"; -pub const EDIT_TOOL: &str = "Edit"; -pub const PERMISSION_TOOL: &str = "Confirmation"; - -#[derive(Deserialize, JsonSchema, Debug)] -struct PermissionToolParams { - tool_name: String, - input: serde_json::Value, - tool_use_id: Option, -} - -#[derive(Serialize)] -#[serde(rename_all = "camelCase")] -struct PermissionToolResponse { - behavior: PermissionToolBehavior, - updated_input: serde_json::Value, -} - -#[derive(Serialize)] -#[serde(rename_all = "snake_case")] -enum PermissionToolBehavior { - Allow, - Deny, -} impl ClaudeZedMcpServer { pub async fn new( @@ -52,9 +27,15 @@ impl ClaudeZedMcpServer { ) -> Result { let mut mcp_server = context_server::listener::McpServer::new(cx).await?; mcp_server.handle_request::(Self::handle_initialize); - mcp_server.handle_request::(Self::handle_list_tools); - mcp_server.handle_request::(move |request, cx| { - Self::handle_call_tool(request, thread_rx.clone(), cx) + + mcp_server.add_tool(PermissionTool { + thread_rx: thread_rx.clone(), + }); + mcp_server.add_tool(ReadTool { + thread_rx: thread_rx.clone(), + }); + mcp_server.add_tool(EditTool { + thread_rx: thread_rx.clone(), }); Ok(Self { server: mcp_server }) @@ -96,193 +77,6 @@ impl ClaudeZedMcpServer { }) }) } - - fn handle_list_tools(_: (), cx: &App) -> Task> { - cx.foreground_executor().spawn(async move { - Ok(ListToolsResponse { - tools: vec![ - Tool { - name: PERMISSION_TOOL.into(), - input_schema: schemars::schema_for!(PermissionToolParams).into(), - description: None, - annotations: None, - }, - Tool { - name: READ_TOOL.into(), - input_schema: schemars::schema_for!(ReadToolParams).into(), - description: Some("Read the contents of a file. In sessions with mcp__zed__Read always use it instead of Read as it contains the most up-to-date contents.".to_string()), - annotations: Some(ToolAnnotations { - title: Some("Read file".to_string()), - read_only_hint: Some(true), - destructive_hint: Some(false), - open_world_hint: Some(false), - // if time passes the contents might change, but it's not going to do anything different - // true or false seem too strong, let's try a none. - idempotent_hint: None, - }), - }, - Tool { - name: EDIT_TOOL.into(), - input_schema: schemars::schema_for!(EditToolParams).into(), - description: Some("Edits a file. In sessions with mcp__zed__Edit always use it instead of Edit as it will show the diff to the user better.".to_string()), - annotations: Some(ToolAnnotations { - title: Some("Edit file".to_string()), - read_only_hint: Some(false), - destructive_hint: Some(false), - open_world_hint: Some(false), - idempotent_hint: Some(false), - }), - }, - ], - next_cursor: None, - meta: None, - }) - }) - } - - fn handle_call_tool( - request: CallToolParams, - mut thread_rx: watch::Receiver>, - cx: &App, - ) -> Task> { - cx.spawn(async move |cx| { - let Some(thread) = thread_rx.recv().await?.upgrade() else { - anyhow::bail!("Thread closed"); - }; - - if request.name.as_str() == PERMISSION_TOOL { - let input = - serde_json::from_value(request.arguments.context("Arguments required")?)?; - - let result = Self::handle_permissions_tool_call(input, thread, cx).await?; - Ok(CallToolResponse { - content: vec![ToolResponseContent::Text { - text: serde_json::to_string(&result)?, - }], - is_error: None, - meta: None, - }) - } else if request.name.as_str() == READ_TOOL { - let input = - serde_json::from_value(request.arguments.context("Arguments required")?)?; - - let content = Self::handle_read_tool_call(input, thread, cx).await?; - Ok(CallToolResponse { - content, - is_error: None, - meta: None, - }) - } else if request.name.as_str() == EDIT_TOOL { - let input = - serde_json::from_value(request.arguments.context("Arguments required")?)?; - - Self::handle_edit_tool_call(input, thread, cx).await?; - Ok(CallToolResponse { - content: vec![], - is_error: None, - meta: None, - }) - } else { - anyhow::bail!("Unsupported tool"); - } - }) - } - - fn handle_read_tool_call( - ReadToolParams { - abs_path, - offset, - limit, - }: ReadToolParams, - thread: Entity, - cx: &AsyncApp, - ) -> Task>> { - cx.spawn(async move |cx| { - let content = thread - .update(cx, |thread, cx| { - thread.read_text_file(abs_path, offset, limit, false, cx) - })? - .await?; - - Ok(vec![ToolResponseContent::Text { text: content }]) - }) - } - - fn handle_edit_tool_call( - params: EditToolParams, - thread: Entity, - cx: &AsyncApp, - ) -> Task> { - cx.spawn(async move |cx| { - let content = thread - .update(cx, |threads, cx| { - threads.read_text_file(params.abs_path.clone(), None, None, true, cx) - })? - .await?; - - let new_content = content.replace(¶ms.old_text, ¶ms.new_text); - if new_content == content { - return Err(anyhow::anyhow!("The old_text was not found in the content")); - } - - thread - .update(cx, |threads, cx| { - threads.write_text_file(params.abs_path, new_content, cx) - })? - .await?; - - Ok(()) - }) - } - - fn handle_permissions_tool_call( - params: PermissionToolParams, - thread: Entity, - cx: &AsyncApp, - ) -> Task> { - cx.spawn(async move |cx| { - let claude_tool = ClaudeTool::infer(¶ms.tool_name, params.input.clone()); - - let tool_call_id = - acp::ToolCallId(params.tool_use_id.context("Tool ID required")?.into()); - - let allow_option_id = acp::PermissionOptionId("allow".into()); - let reject_option_id = acp::PermissionOptionId("reject".into()); - - let chosen_option = thread - .update(cx, |thread, cx| { - thread.request_tool_call_permission( - claude_tool.as_acp(tool_call_id), - vec![ - acp::PermissionOption { - id: allow_option_id.clone(), - label: "Allow".into(), - kind: acp::PermissionOptionKind::AllowOnce, - }, - acp::PermissionOption { - id: reject_option_id, - label: "Reject".into(), - kind: acp::PermissionOptionKind::RejectOnce, - }, - ], - cx, - ) - })? - .await?; - - if chosen_option == allow_option_id { - Ok(PermissionToolResponse { - behavior: PermissionToolBehavior::Allow, - updated_input: params.input, - }) - } else { - Ok(PermissionToolResponse { - behavior: PermissionToolBehavior::Deny, - updated_input: params.input, - }) - } - }) - } } #[derive(Serialize)] @@ -299,3 +93,187 @@ pub struct McpServerConfig { #[serde(skip_serializing_if = "Option::is_none")] pub env: Option>, } + +// Tools + +#[derive(Clone)] +pub struct PermissionTool { + thread_rx: watch::Receiver>, +} + +#[derive(Deserialize, JsonSchema, Debug)] +pub struct PermissionToolParams { + tool_name: String, + input: serde_json::Value, + tool_use_id: Option, +} + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub struct PermissionToolResponse { + behavior: PermissionToolBehavior, + updated_input: serde_json::Value, +} + +#[derive(Serialize)] +#[serde(rename_all = "snake_case")] +enum PermissionToolBehavior { + Allow, + Deny, +} + +impl McpServerTool for PermissionTool { + type Input = PermissionToolParams; + const NAME: &'static str = "Confirmation"; + + fn description(&self) -> &'static str { + "Request permission for tool calls" + } + + async fn run(&self, input: Self::Input, cx: &mut AsyncApp) -> Result { + let mut thread_rx = self.thread_rx.clone(); + let Some(thread) = thread_rx.recv().await?.upgrade() else { + anyhow::bail!("Thread closed"); + }; + + let claude_tool = ClaudeTool::infer(&input.tool_name, input.input.clone()); + let tool_call_id = acp::ToolCallId(input.tool_use_id.context("Tool ID required")?.into()); + let allow_option_id = acp::PermissionOptionId("allow".into()); + let reject_option_id = acp::PermissionOptionId("reject".into()); + + let chosen_option = thread + .update(cx, |thread, cx| { + thread.request_tool_call_permission( + claude_tool.as_acp(tool_call_id), + vec![ + acp::PermissionOption { + id: allow_option_id.clone(), + label: "Allow".into(), + kind: acp::PermissionOptionKind::AllowOnce, + }, + acp::PermissionOption { + id: reject_option_id.clone(), + label: "Reject".into(), + kind: acp::PermissionOptionKind::RejectOnce, + }, + ], + cx, + ) + })? + .await?; + + let response = if chosen_option == allow_option_id { + PermissionToolResponse { + behavior: PermissionToolBehavior::Allow, + updated_input: input.input, + } + } else { + PermissionToolResponse { + behavior: PermissionToolBehavior::Deny, + updated_input: input.input, + } + }; + + Ok(ToolResponse { + content: vec![ToolResponseContent::Text { + text: serde_json::to_string(&response)?, + }], + structured_content: None, + }) + } +} + +#[derive(Clone)] +pub struct ReadTool { + thread_rx: watch::Receiver>, +} + +impl McpServerTool for ReadTool { + type Input = ReadToolParams; + const NAME: &'static str = "Read"; + + fn description(&self) -> &'static str { + "Read the contents of a file. In sessions with mcp__zed__Read always use it instead of Read as it contains the most up-to-date contents." + } + + fn annotations(&self) -> ToolAnnotations { + ToolAnnotations { + title: Some("Read file".to_string()), + read_only_hint: Some(true), + destructive_hint: Some(false), + open_world_hint: Some(false), + idempotent_hint: None, + } + } + + async fn run(&self, input: Self::Input, cx: &mut AsyncApp) -> Result { + let mut thread_rx = self.thread_rx.clone(); + let Some(thread) = thread_rx.recv().await?.upgrade() else { + anyhow::bail!("Thread closed"); + }; + + let content = thread + .update(cx, |thread, cx| { + thread.read_text_file(input.abs_path, input.offset, input.limit, false, cx) + })? + .await?; + + Ok(ToolResponse { + content: vec![ToolResponseContent::Text { text: content }], + structured_content: None, + }) + } +} + +#[derive(Clone)] +pub struct EditTool { + thread_rx: watch::Receiver>, +} + +impl McpServerTool for EditTool { + type Input = EditToolParams; + const NAME: &'static str = "Edit"; + + fn description(&self) -> &'static str { + "Edits a file. In sessions with mcp__zed__Edit always use it instead of Edit as it will show the diff to the user better." + } + + fn annotations(&self) -> ToolAnnotations { + ToolAnnotations { + title: Some("Edit file".to_string()), + read_only_hint: Some(false), + destructive_hint: Some(false), + open_world_hint: Some(false), + idempotent_hint: Some(false), + } + } + + async fn run(&self, input: Self::Input, cx: &mut AsyncApp) -> Result { + let mut thread_rx = self.thread_rx.clone(); + let Some(thread) = thread_rx.recv().await?.upgrade() else { + anyhow::bail!("Thread closed"); + }; + + let content = thread + .update(cx, |thread, cx| { + thread.read_text_file(input.abs_path.clone(), None, None, true, cx) + })? + .await?; + + let new_content = content.replace(&input.old_text, &input.new_text); + if new_content == content { + return Err(anyhow::anyhow!("The old_text was not found in the content")); + } + + thread + .update(cx, |thread, cx| { + thread.write_text_file(input.abs_path, new_content, cx) + })? + .await?; + + Ok(ToolResponse { + content: vec![], + structured_content: None, + }) + } +} diff --git a/crates/context_server/src/listener.rs b/crates/context_server/src/listener.rs index 9295ad979c..087395a961 100644 --- a/crates/context_server/src/listener.rs +++ b/crates/context_server/src/listener.rs @@ -9,6 +9,8 @@ use futures::{ }; use gpui::{App, AppContext, AsyncApp, Task}; use net::async_net::{UnixListener, UnixStream}; +use schemars::JsonSchema; +use serde::de::DeserializeOwned; use serde_json::{json, value::RawValue}; use smol::stream::StreamExt; use std::{ @@ -20,16 +22,28 @@ use util::ResultExt; use crate::{ client::{CspResult, RequestId, Response}, - types::Request, + types::{ + CallToolParams, CallToolResponse, ListToolsResponse, Request, Tool, ToolAnnotations, + ToolResponseContent, + requests::{CallTool, ListTools}, + }, }; pub struct McpServer { socket_path: PathBuf, - handlers: Rc>>, + tools: Rc>>, + handlers: Rc>>, _server_task: Task<()>, } -type McpHandler = Box>, &App) -> Task>; +struct RegisteredTool { + tool: Tool, + handler: ToolHandler, +} + +type ToolHandler = + Box, &mut AsyncApp) -> Task>>; +type RequestHandler = Box>, &App) -> Task>; impl McpServer { pub fn new(cx: &AsyncApp) -> Task> { @@ -43,12 +57,14 @@ impl McpServer { cx.spawn(async move |cx| { let (temp_dir, socket_path, listener) = task.await?; + let tools = Rc::new(RefCell::new(HashMap::default())); let handlers = Rc::new(RefCell::new(HashMap::default())); let server_task = cx.spawn({ + let tools = tools.clone(); let handlers = handlers.clone(); async move |cx| { while let Ok((stream, _)) = listener.accept().await { - Self::serve_connection(stream, handlers.clone(), cx); + Self::serve_connection(stream, tools.clone(), handlers.clone(), cx); } drop(temp_dir) } @@ -56,11 +72,40 @@ impl McpServer { Ok(Self { socket_path, _server_task: server_task, - handlers: handlers.clone(), + tools, + handlers: handlers, }) }) } + pub fn add_tool(&mut self, tool: T) { + let registered_tool = RegisteredTool { + tool: Tool { + name: T::NAME.into(), + description: Some(tool.description().into()), + input_schema: schemars::schema_for!(T::Input).into(), + annotations: Some(tool.annotations()), + }, + handler: Box::new({ + let tool = tool.clone(); + move |input_value, cx| { + let input = match input_value { + Some(input) => serde_json::from_value(input), + None => serde_json::from_value(serde_json::Value::Null), + }; + + let tool = tool.clone(); + match input { + Ok(input) => cx.spawn(async move |cx| tool.run(input, cx).await), + Err(err) => Task::ready(Err(err.into())), + } + } + }), + }; + + self.tools.borrow_mut().insert(T::NAME, registered_tool); + } + pub fn handle_request( &mut self, f: impl Fn(R::Params, &App) -> Task> + 'static, @@ -120,7 +165,8 @@ impl McpServer { fn serve_connection( stream: UnixStream, - handlers: Rc>>, + tools: Rc>>, + handlers: Rc>>, cx: &mut AsyncApp, ) { let (read, write) = smol::io::split(stream); @@ -135,7 +181,13 @@ impl McpServer { let Some(request_id) = request.id.clone() else { continue; }; - if let Some(handler) = handlers.borrow().get(&request.method.as_ref()) { + + if request.method == CallTool::METHOD { + Self::handle_call_tool(request_id, request.params, &tools, &outgoing_tx, cx) + .await; + } else if request.method == ListTools::METHOD { + Self::handle_list_tools(request.id.unwrap(), &tools, &outgoing_tx); + } else if let Some(handler) = handlers.borrow().get(&request.method.as_ref()) { let outgoing_tx = outgoing_tx.clone(); if let Some(task) = cx @@ -149,25 +201,122 @@ impl McpServer { .detach(); } } else { - outgoing_tx - .unbounded_send( - serde_json::to_string(&Response::<()> { - jsonrpc: "2.0", - id: request.id.unwrap(), - value: CspResult::Error(Some(crate::client::Error { - message: format!("unhandled method {}", request.method), - code: -32601, - })), - }) - .unwrap(), - ) - .ok(); + Self::send_err( + request_id, + format!("unhandled method {}", request.method), + &outgoing_tx, + ); } } }) .detach(); } + fn handle_list_tools( + request_id: RequestId, + tools: &Rc>>, + outgoing_tx: &UnboundedSender, + ) { + let response = ListToolsResponse { + tools: tools.borrow().values().map(|t| t.tool.clone()).collect(), + next_cursor: None, + meta: None, + }; + + outgoing_tx + .unbounded_send( + serde_json::to_string(&Response { + jsonrpc: "2.0", + id: request_id, + value: CspResult::Ok(Some(response)), + }) + .unwrap_or_default(), + ) + .ok(); + } + + async fn handle_call_tool( + request_id: RequestId, + params: Option>, + tools: &Rc>>, + outgoing_tx: &UnboundedSender, + cx: &mut AsyncApp, + ) { + let result: Result = match params.as_ref() { + Some(params) => serde_json::from_str(params.get()), + None => serde_json::from_value(serde_json::Value::Null), + }; + + match result { + Ok(params) => { + if let Some(tool) = tools.borrow().get(¶ms.name.as_ref()) { + let outgoing_tx = outgoing_tx.clone(); + + let task = (tool.handler)(params.arguments, cx); + cx.spawn(async move |_| { + let response = match task.await { + Ok(result) => CallToolResponse { + content: result.content, + is_error: Some(false), + meta: None, + structured_content: result.structured_content, + }, + Err(err) => CallToolResponse { + content: vec![ToolResponseContent::Text { + text: err.to_string(), + }], + is_error: Some(true), + meta: None, + structured_content: None, + }, + }; + + outgoing_tx + .unbounded_send( + serde_json::to_string(&Response { + jsonrpc: "2.0", + id: request_id, + value: CspResult::Ok(Some(response)), + }) + .unwrap_or_default(), + ) + .ok(); + }) + .detach(); + } else { + Self::send_err( + request_id, + format!("Tool not found: {}", params.name), + &outgoing_tx, + ); + } + } + Err(err) => { + Self::send_err(request_id, err.to_string(), &outgoing_tx); + } + } + } + + fn send_err( + request_id: RequestId, + message: impl Into, + outgoing_tx: &UnboundedSender, + ) { + outgoing_tx + .unbounded_send( + serde_json::to_string(&Response::<()> { + jsonrpc: "2.0", + id: request_id, + value: CspResult::Error(Some(crate::client::Error { + message: message.into(), + code: -32601, + })), + }) + .unwrap(), + ) + .ok(); + } + async fn handle_io( mut outgoing_rx: UnboundedReceiver, incoming_tx: UnboundedSender, @@ -216,6 +365,34 @@ impl McpServer { } } +pub trait McpServerTool { + type Input: DeserializeOwned + JsonSchema; + const NAME: &'static str; + + fn description(&self) -> &'static str; + + fn annotations(&self) -> ToolAnnotations { + ToolAnnotations { + title: None, + read_only_hint: None, + destructive_hint: None, + idempotent_hint: None, + open_world_hint: None, + } + } + + fn run( + &self, + input: Self::Input, + cx: &mut AsyncApp, + ) -> impl Future>; +} + +pub struct ToolResponse { + pub content: Vec, + pub structured_content: Option, +} + #[derive(Serialize, Deserialize)] struct RawRequest { #[serde(skip_serializing_if = "Option::is_none")] diff --git a/crates/context_server/src/types.rs b/crates/context_server/src/types.rs index f92c86aa3c..c95d9008bc 100644 --- a/crates/context_server/src/types.rs +++ b/crates/context_server/src/types.rs @@ -495,7 +495,7 @@ pub struct RootsCapabilities { pub list_changed: Option, } -#[derive(Debug, Serialize, Deserialize)] +#[derive(Clone, Debug, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub struct Tool { pub name: String, @@ -506,7 +506,7 @@ pub struct Tool { pub annotations: Option, } -#[derive(Debug, Serialize, Deserialize)] +#[derive(Clone, Debug, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub struct ToolAnnotations { /// A human-readable title for the tool. @@ -679,6 +679,8 @@ pub struct CallToolResponse { pub is_error: Option, #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")] pub meta: Option>, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub structured_content: Option, } #[derive(Debug, Serialize, Deserialize)] From af0c909924d5b5b46432847fce2afb4bc8d78ee2 Mon Sep 17 00:00:00 2001 From: Agus Zubiaga Date: Thu, 24 Jul 2025 23:57:18 -0300 Subject: [PATCH 0206/1052] McpServerTool output schema (#35069) Add an `Output` associated type to `McpServerTool`, so that we can include its schema in `tools/list`. Release Notes: - N/A --- crates/agent_servers/src/claude/mcp_server.rs | 30 +++++++++++--- crates/context_server/src/listener.rs | 40 +++++++++++++++---- crates/context_server/src/types.rs | 2 + 3 files changed, 59 insertions(+), 13 deletions(-) diff --git a/crates/agent_servers/src/claude/mcp_server.rs b/crates/agent_servers/src/claude/mcp_server.rs index 4272a972dc..a320a6d37f 100644 --- a/crates/agent_servers/src/claude/mcp_server.rs +++ b/crates/agent_servers/src/claude/mcp_server.rs @@ -124,13 +124,19 @@ enum PermissionToolBehavior { impl McpServerTool for PermissionTool { type Input = PermissionToolParams; + type Output = (); + const NAME: &'static str = "Confirmation"; fn description(&self) -> &'static str { "Request permission for tool calls" } - async fn run(&self, input: Self::Input, cx: &mut AsyncApp) -> Result { + async fn run( + &self, + input: Self::Input, + cx: &mut AsyncApp, + ) -> Result> { let mut thread_rx = self.thread_rx.clone(); let Some(thread) = thread_rx.recv().await?.upgrade() else { anyhow::bail!("Thread closed"); @@ -178,7 +184,7 @@ impl McpServerTool for PermissionTool { content: vec![ToolResponseContent::Text { text: serde_json::to_string(&response)?, }], - structured_content: None, + structured_content: (), }) } } @@ -190,6 +196,8 @@ pub struct ReadTool { impl McpServerTool for ReadTool { type Input = ReadToolParams; + type Output = (); + const NAME: &'static str = "Read"; fn description(&self) -> &'static str { @@ -206,7 +214,11 @@ impl McpServerTool for ReadTool { } } - async fn run(&self, input: Self::Input, cx: &mut AsyncApp) -> Result { + async fn run( + &self, + input: Self::Input, + cx: &mut AsyncApp, + ) -> Result> { let mut thread_rx = self.thread_rx.clone(); let Some(thread) = thread_rx.recv().await?.upgrade() else { anyhow::bail!("Thread closed"); @@ -220,7 +232,7 @@ impl McpServerTool for ReadTool { Ok(ToolResponse { content: vec![ToolResponseContent::Text { text: content }], - structured_content: None, + structured_content: (), }) } } @@ -232,6 +244,8 @@ pub struct EditTool { impl McpServerTool for EditTool { type Input = EditToolParams; + type Output = (); + const NAME: &'static str = "Edit"; fn description(&self) -> &'static str { @@ -248,7 +262,11 @@ impl McpServerTool for EditTool { } } - async fn run(&self, input: Self::Input, cx: &mut AsyncApp) -> Result { + async fn run( + &self, + input: Self::Input, + cx: &mut AsyncApp, + ) -> Result> { let mut thread_rx = self.thread_rx.clone(); let Some(thread) = thread_rx.recv().await?.upgrade() else { anyhow::bail!("Thread closed"); @@ -273,7 +291,7 @@ impl McpServerTool for EditTool { Ok(ToolResponse { content: vec![], - structured_content: None, + structured_content: (), }) } } diff --git a/crates/context_server/src/listener.rs b/crates/context_server/src/listener.rs index 087395a961..192f530816 100644 --- a/crates/context_server/src/listener.rs +++ b/crates/context_server/src/listener.rs @@ -41,8 +41,12 @@ struct RegisteredTool { handler: ToolHandler, } -type ToolHandler = - Box, &mut AsyncApp) -> Task>>; +type ToolHandler = Box< + dyn Fn( + Option, + &mut AsyncApp, + ) -> Task>>, +>; type RequestHandler = Box>, &App) -> Task>; impl McpServer { @@ -79,11 +83,19 @@ impl McpServer { } pub fn add_tool(&mut self, tool: T) { + let output_schema = schemars::schema_for!(T::Output); + let unit_schema = schemars::schema_for!(()); + let registered_tool = RegisteredTool { tool: Tool { name: T::NAME.into(), description: Some(tool.description().into()), input_schema: schemars::schema_for!(T::Input).into(), + output_schema: if output_schema == unit_schema { + None + } else { + Some(output_schema.into()) + }, annotations: Some(tool.annotations()), }, handler: Box::new({ @@ -96,7 +108,15 @@ impl McpServer { let tool = tool.clone(); match input { - Ok(input) => cx.spawn(async move |cx| tool.run(input, cx).await), + Ok(input) => cx.spawn(async move |cx| { + let output = tool.run(input, cx).await?; + + Ok(ToolResponse { + content: output.content, + structured_content: serde_json::to_value(output.structured_content) + .unwrap_or_default(), + }) + }), Err(err) => Task::ready(Err(err.into())), } } @@ -259,7 +279,11 @@ impl McpServer { content: result.content, is_error: Some(false), meta: None, - structured_content: result.structured_content, + structured_content: if result.structured_content.is_null() { + None + } else { + Some(result.structured_content) + }, }, Err(err) => CallToolResponse { content: vec![ToolResponseContent::Text { @@ -367,6 +391,8 @@ impl McpServer { pub trait McpServerTool { type Input: DeserializeOwned + JsonSchema; + type Output: Serialize + JsonSchema; + const NAME: &'static str; fn description(&self) -> &'static str; @@ -385,12 +411,12 @@ pub trait McpServerTool { &self, input: Self::Input, cx: &mut AsyncApp, - ) -> impl Future>; + ) -> impl Future>>; } -pub struct ToolResponse { +pub struct ToolResponse { pub content: Vec, - pub structured_content: Option, + pub structured_content: T, } #[derive(Serialize, Deserialize)] diff --git a/crates/context_server/src/types.rs b/crates/context_server/src/types.rs index c95d9008bc..cd97ff95bc 100644 --- a/crates/context_server/src/types.rs +++ b/crates/context_server/src/types.rs @@ -502,6 +502,8 @@ pub struct Tool { #[serde(skip_serializing_if = "Option::is_none")] pub description: Option, pub input_schema: serde_json::Value, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub output_schema: Option, #[serde(skip_serializing_if = "Option::is_none")] pub annotations: Option, } From 631f9a1b31c16b53e65126163094622f54669960 Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Fri, 25 Jul 2025 13:18:19 +0200 Subject: [PATCH 0207/1052] worktree: Improve performance with large # of repositories (#35052) In this PR we've reworked how git status updates are processed. Most notable change is moving the processing into a background thread (and splitting it across multiple background workers). We believe it is safe to do so, as worktree events are not deterministic (fs updates are not guaranteed to come in any order etc), so I've figured that git store should not be overly order-reliant anyways. Note that this PR does not solve perf issues wholesale - other parts of the system are still slow to process stuff (which I plan to nuke soon). Related to #34302 Release Notes: - Improved Zed's performance in projects with large # of repositories --------- Co-authored-by: Anthony Eid --- crates/project/src/git_store.rs | 132 ++++++++++++++---- crates/project/src/git_store/git_traversal.rs | 48 +++++-- 2 files changed, 142 insertions(+), 38 deletions(-) diff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rs index eb16446daf..d131b6dd41 100644 --- a/crates/project/src/git_store.rs +++ b/crates/project/src/git_store.rs @@ -14,9 +14,10 @@ use collections::HashMap; pub use conflict_set::{ConflictRegion, ConflictSet, ConflictSetSnapshot, ConflictSetUpdate}; use fs::Fs; use futures::{ - FutureExt, StreamExt as _, + FutureExt, StreamExt, channel::{mpsc, oneshot}, future::{self, Shared}, + stream::FuturesOrdered, }; use git::{ BuildPermalinkParams, GitHostingProviderRegistry, WORK_DIRECTORY_REPO_PATH, @@ -63,8 +64,8 @@ use sum_tree::{Edit, SumTree, TreeSet}; use text::{Bias, BufferId}; use util::{ResultExt, debug_panic, post_inc}; use worktree::{ - File, PathKey, PathProgress, PathSummary, PathTarget, UpdatedGitRepositoriesSet, - UpdatedGitRepository, Worktree, + File, PathChange, PathKey, PathProgress, PathSummary, PathTarget, ProjectEntryId, + UpdatedGitRepositoriesSet, UpdatedGitRepository, Worktree, }; pub struct GitStore { @@ -1083,27 +1084,26 @@ impl GitStore { match event { WorktreeStoreEvent::WorktreeUpdatedEntries(worktree_id, updated_entries) => { - let mut paths_by_git_repo = HashMap::<_, Vec<_>>::default(); - for (relative_path, _, _) in updated_entries.iter() { - let Some((repo, repo_path)) = self.repository_and_path_for_project_path( - &(*worktree_id, relative_path.clone()).into(), - cx, - ) else { - continue; - }; - paths_by_git_repo.entry(repo).or_default().push(repo_path) - } - - for (repo, paths) in paths_by_git_repo { - repo.update(cx, |repo, cx| { - repo.paths_changed( - paths, - downstream - .as_ref() - .map(|downstream| downstream.updates_tx.clone()), - cx, - ); - }); + if let Some(worktree) = self + .worktree_store + .read(cx) + .worktree_for_id(*worktree_id, cx) + { + let paths_by_git_repo = + self.process_updated_entries(&worktree, updated_entries, cx); + let downstream = downstream + .as_ref() + .map(|downstream| downstream.updates_tx.clone()); + cx.spawn(async move |_, cx| { + let paths_by_git_repo = paths_by_git_repo.await; + for (repo, paths) in paths_by_git_repo { + repo.update(cx, |repo, cx| { + repo.paths_changed(paths, downstream.clone(), cx); + }) + .ok(); + } + }) + .detach(); } } WorktreeStoreEvent::WorktreeUpdatedGitRepositories(worktree_id, changed_repos) => { @@ -2191,6 +2191,80 @@ impl GitStore { .map(|(id, repo)| (*id, repo.read(cx).snapshot.clone())) .collect() } + + fn process_updated_entries( + &self, + worktree: &Entity, + updated_entries: &[(Arc, ProjectEntryId, PathChange)], + cx: &mut App, + ) -> Task, Vec>> { + let mut repo_paths = self + .repositories + .values() + .map(|repo| (repo.read(cx).work_directory_abs_path.clone(), repo.clone())) + .collect::>(); + let mut entries: Vec<_> = updated_entries + .iter() + .map(|(path, _, _)| path.clone()) + .collect(); + entries.sort(); + let worktree = worktree.read(cx); + + let entries = entries + .into_iter() + .filter_map(|path| worktree.absolutize(&path).ok()) + .collect::>(); + + let executor = cx.background_executor().clone(); + cx.background_executor().spawn(async move { + repo_paths.sort_by(|lhs, rhs| lhs.0.cmp(&rhs.0)); + let mut paths_by_git_repo = HashMap::<_, Vec<_>>::default(); + let mut tasks = FuturesOrdered::new(); + for (repo_path, repo) in repo_paths.into_iter().rev() { + let entries = entries.clone(); + let task = executor.spawn(async move { + // Find all repository paths that belong to this repo + let mut ix = entries.partition_point(|path| path < &*repo_path); + if ix == entries.len() { + return None; + }; + + let mut paths = vec![]; + // All paths prefixed by a given repo will constitute a continuous range. + while let Some(path) = entries.get(ix) + && let Some(repo_path) = + RepositorySnapshot::abs_path_to_repo_path_inner(&repo_path, &path) + { + paths.push((repo_path, ix)); + ix += 1; + } + Some((repo, paths)) + }); + tasks.push_back(task); + } + + // Now, let's filter out the "duplicate" entries that were processed by multiple distinct repos. + let mut path_was_used = vec![false; entries.len()]; + let tasks = tasks.collect::>().await; + // Process tasks from the back: iterating backwards allows us to see more-specific paths first. + // We always want to assign a path to it's innermost repository. + for t in tasks { + let Some((repo, paths)) = t else { + continue; + }; + let entry = paths_by_git_repo.entry(repo).or_default(); + for (repo_path, ix) in paths { + if path_was_used[ix] { + continue; + } + path_was_used[ix] = true; + entry.push(repo_path); + } + } + + paths_by_git_repo + }) + } } impl BufferGitState { @@ -2660,8 +2734,16 @@ impl RepositorySnapshot { } pub fn abs_path_to_repo_path(&self, abs_path: &Path) -> Option { + Self::abs_path_to_repo_path_inner(&self.work_directory_abs_path, abs_path) + } + + #[inline] + fn abs_path_to_repo_path_inner( + work_directory_abs_path: &Path, + abs_path: &Path, + ) -> Option { abs_path - .strip_prefix(&self.work_directory_abs_path) + .strip_prefix(&work_directory_abs_path) .map(RepoPath::from) .ok() } diff --git a/crates/project/src/git_store/git_traversal.rs b/crates/project/src/git_store/git_traversal.rs index cd173d5714..777042cb02 100644 --- a/crates/project/src/git_store/git_traversal.rs +++ b/crates/project/src/git_store/git_traversal.rs @@ -1,6 +1,6 @@ use collections::HashMap; -use git::status::GitSummary; -use std::{ops::Deref, path::Path}; +use git::{repository::RepoPath, status::GitSummary}; +use std::{collections::BTreeMap, ops::Deref, path::Path}; use sum_tree::Cursor; use text::Bias; use worktree::{Entry, PathProgress, PathTarget, Traversal}; @@ -11,7 +11,7 @@ use super::{RepositoryId, RepositorySnapshot, StatusEntry}; pub struct GitTraversal<'a> { traversal: Traversal<'a>, current_entry_summary: Option, - repo_snapshots: &'a HashMap, + repo_root_to_snapshot: BTreeMap<&'a Path, &'a RepositorySnapshot>, repo_location: Option<(RepositoryId, Cursor<'a, StatusEntry, PathProgress<'a>>)>, } @@ -20,16 +20,46 @@ impl<'a> GitTraversal<'a> { repo_snapshots: &'a HashMap, traversal: Traversal<'a>, ) -> GitTraversal<'a> { + let repo_root_to_snapshot = repo_snapshots + .values() + .map(|snapshot| (&*snapshot.work_directory_abs_path, snapshot)) + .collect(); let mut this = GitTraversal { traversal, - repo_snapshots, current_entry_summary: None, repo_location: None, + repo_root_to_snapshot, }; this.synchronize_statuses(true); this } + fn repo_root_for_path(&self, path: &Path) -> Option<(&'a RepositorySnapshot, RepoPath)> { + // We might need to perform a range search multiple times, as there may be a nested repository inbetween + // the target and our path. E.g: + // /our_root_repo/ + // .git/ + // other_repo/ + // .git/ + // our_query.txt + let mut query = path.ancestors(); + while let Some(query) = query.next() { + let (_, snapshot) = self + .repo_root_to_snapshot + .range(Path::new("")..=query) + .last()?; + + let stripped = snapshot + .abs_path_to_repo_path(path) + .map(|repo_path| (*snapshot, repo_path)); + if stripped.is_some() { + return stripped; + } + } + + None + } + fn synchronize_statuses(&mut self, reset: bool) { self.current_entry_summary = None; @@ -42,15 +72,7 @@ impl<'a> GitTraversal<'a> { return; }; - let Some((repo, repo_path)) = self - .repo_snapshots - .values() - .filter_map(|repo_snapshot| { - let repo_path = repo_snapshot.abs_path_to_repo_path(&abs_path)?; - Some((repo_snapshot, repo_path)) - }) - .max_by_key(|(repo, _)| repo.work_directory_abs_path.clone()) - else { + let Some((repo, repo_path)) = self.repo_root_for_path(&abs_path) else { self.repo_location = None; return; }; From 57b463fd0df7785d1695ae126e86c88542969be3 Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Fri, 25 Jul 2025 14:23:52 +0200 Subject: [PATCH 0208/1052] typescript: Fix handling of jest/vitest tests with regex characters in name (#35090) Closes #35065 Release Notes: - JavaScript/TypeScript tasks: Fixed handling of Vitest/Jest tests with regex-specific characters in their name. --- crates/languages/src/typescript.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/languages/src/typescript.rs b/crates/languages/src/typescript.rs index 34b9c3224e..fb51544841 100644 --- a/crates/languages/src/typescript.rs +++ b/crates/languages/src/typescript.rs @@ -512,7 +512,7 @@ fn eslint_server_binary_arguments(server_path: &Path) -> Vec { fn replace_test_name_parameters(test_name: &str) -> String { let pattern = regex::Regex::new(r"(%|\$)[0-9a-zA-Z]+").unwrap(); - pattern.replace_all(test_name, "(.+?)").to_string() + regex::escape(&pattern.replace_all(test_name, "(.+?)")) } pub struct TypeScriptLspAdapter { From 9071341a1da9b0c9e3a88616e58646a4928c5414 Mon Sep 17 00:00:00 2001 From: Julia Ryan Date: Fri, 25 Jul 2025 07:40:26 -0500 Subject: [PATCH 0209/1052] Add TestCrash action (#35088) This triggers a crash that avoids our panic-handler, which is useful for testing that our crash reporting works even when you don't get a panic. Release Notes: - N/A --- crates/zed/src/zed.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs index 57534c8cd5..0a90f89fa4 100644 --- a/crates/zed/src/zed.rs +++ b/crates/zed/src/zed.rs @@ -111,6 +111,8 @@ actions!( Zoom, /// Triggers a test panic for debugging. TestPanic, + /// Triggers a hard crash for debugging. + TestCrash, ] ); @@ -126,6 +128,14 @@ pub fn init(cx: &mut App) { cx.on_action(|_: &RestoreBanner, cx| title_bar::restore_banner(cx)); if ReleaseChannel::global(cx) == ReleaseChannel::Dev || cx.has_flag::() { cx.on_action(|_: &TestPanic, _| panic!("Ran the TestPanic action")); + cx.on_action(|_: &TestCrash, _| { + unsafe extern "C" { + fn puts(s: *const i8); + } + unsafe { + puts(0xabad1d3a as *const i8); + } + }); } cx.on_action(|_: &OpenLog, cx| { with_active_or_new_workspace(cx, |workspace, window, cx| { From a2408f353ba27b42abdfd3c1d13d9344566779d7 Mon Sep 17 00:00:00 2001 From: Julia Ryan Date: Fri, 25 Jul 2025 08:12:55 -0500 Subject: [PATCH 0210/1052] Don't separately rebuild crates for the build platform (#35084) macos: - `cargo build`: 1838 -> 1400 - `cargo build -r`1891 -> 1400 linux: - `cargo build`: 1893 -> 1455 - `cargo build -r`: 1893 -> 1455 windows: - `cargo build`: 1830 -> 1392 - `cargo build -r`: 1880 -> 1392 We definitely want this change for debug builds, for release builds it's _possible_ that it pessimizes the critical path, but we'll see if it impacts CI times before merging. Release Notes: - N/A --------- Co-authored-by: Rahul Butani --- Cargo.toml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/Cargo.toml b/Cargo.toml index 9062950127..ea01003f36 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -720,6 +720,11 @@ workspace-hack = { path = "tooling/workspace-hack" } split-debuginfo = "unpacked" codegen-units = 16 +# mirror configuration for crates compiled for the build platform +# (without this cargo will compile ~400 crates twice) +[profile.dev.build-override] +codegen-units = 16 + [profile.dev.package] taffy = { opt-level = 3 } cranelift-codegen = { opt-level = 3 } From f21ba9e2c6789fadd3a59f88e0eb1ff4e1f919db Mon Sep 17 00:00:00 2001 From: Umesh Yadav <23421535+imumesh18@users.noreply.github.com> Date: Fri, 25 Jul 2025 19:06:43 +0530 Subject: [PATCH 0211/1052] lmstudio: Propagate actual error message from server (#34538) Discovered in this issue: #34513 Previously, we were propagating deserialization errors to users when using LMStudio, instead of the actual error message sent from the LMStudio server. This change will help users understand why their request failed while streaming responses. Release Notes: - lmsudio: Display specific backend error messaging on failure rather than generic ones --------- Signed-off-by: Umesh Yadav Co-authored-by: Peter Tripp --- crates/lmstudio/src/lmstudio.rs | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/crates/lmstudio/src/lmstudio.rs b/crates/lmstudio/src/lmstudio.rs index a5477994ff..43c78115cd 100644 --- a/crates/lmstudio/src/lmstudio.rs +++ b/crates/lmstudio/src/lmstudio.rs @@ -1,4 +1,4 @@ -use anyhow::{Context as _, Result}; +use anyhow::{Context as _, Result, anyhow}; use futures::{AsyncBufReadExt, AsyncReadExt, StreamExt, io::BufReader, stream::BoxStream}; use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest, http}; use serde::{Deserialize, Serialize}; @@ -275,11 +275,16 @@ impl Capabilities { } } +#[derive(Serialize, Deserialize, Debug)] +pub struct LmStudioError { + pub message: String, +} + #[derive(Serialize, Deserialize, Debug)] #[serde(untagged)] pub enum ResponseStreamResult { Ok(ResponseStreamEvent), - Err { error: String }, + Err { error: LmStudioError }, } #[derive(Serialize, Deserialize, Debug)] @@ -392,7 +397,6 @@ pub async fn stream_chat_completion( let mut response = client.send(request).await?; if response.status().is_success() { let reader = BufReader::new(response.into_body()); - Ok(reader .lines() .filter_map(|line| async move { @@ -402,18 +406,16 @@ pub async fn stream_chat_completion( if line == "[DONE]" { None } else { - let result = serde_json::from_str(&line) - .context("Unable to parse chat completions response"); - if let Err(ref e) = result { - eprintln!("Error parsing line: {e}\nLine content: '{line}'"); + match serde_json::from_str(line) { + Ok(ResponseStreamResult::Ok(response)) => Some(Ok(response)), + Ok(ResponseStreamResult::Err { error, .. }) => { + Some(Err(anyhow!(error.message))) + } + Err(error) => Some(Err(anyhow!(error))), } - Some(result) } } - Err(e) => { - eprintln!("Error reading line: {e}"); - Some(Err(e.into())) - } + Err(error) => Some(Err(anyhow!(error))), } }) .boxed()) From 5de544eb4bf7841889da94c43b5f00d12398b2ef Mon Sep 17 00:00:00 2001 From: etimvr <80552426+etimvr@users.noreply.github.com> Date: Fri, 25 Jul 2025 20:58:05 +0700 Subject: [PATCH 0212/1052] Fix unnecessary Ollama model loading (#35032) Closes https://github.com/zed-industries/zed/issues/35031 Similar solution as in https://github.com/zed-industries/zed/pull/30589 Release Notes: - Fix unnecessary ollama model loading --- crates/language_models/src/provider/ollama.rs | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/crates/language_models/src/provider/ollama.rs b/crates/language_models/src/provider/ollama.rs index dc81e8be18..c20ea0ee1e 100644 --- a/crates/language_models/src/provider/ollama.rs +++ b/crates/language_models/src/provider/ollama.rs @@ -192,12 +192,16 @@ impl LanguageModelProvider for OllamaLanguageModelProvider { IconName::AiOllama } - fn default_model(&self, cx: &App) -> Option> { - self.provided_models(cx).into_iter().next() + fn default_model(&self, _: &App) -> Option> { + // We shouldn't try to select default model, because it might lead to a load call for an unloaded model. + // In a constrained environment where user might not have enough resources it'll be a bad UX to select something + // to load by default. + None } - fn default_fast_model(&self, cx: &App) -> Option> { - self.default_model(cx) + fn default_fast_model(&self, _: &App) -> Option> { + // See explanation for default_model. + None } fn provided_models(&self, cx: &App) -> Vec> { From 0e9d955e9bf25383f637bc7d4e3a385f43d30e09 Mon Sep 17 00:00:00 2001 From: Justin Su Date: Fri, 25 Jul 2025 10:53:57 -0400 Subject: [PATCH 0213/1052] Hide Copilot commands when AI functionality is disabled (#35055) Follow-up of https://github.com/zed-industries/zed/pull/34896 Related to https://github.com/zed-industries/zed/issues/31346 cc @rtfeldman Release Notes: - Hide copilot commands when AI functionality is disabled --- crates/agent_ui/src/agent_ui.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rs index cac0f1adac..6ae78585de 100644 --- a/crates/agent_ui/src/agent_ui.rs +++ b/crates/agent_ui/src/agent_ui.rs @@ -262,7 +262,9 @@ fn update_command_palette_filter(cx: &mut App) { if disable_ai { filter.hide_namespace("agent"); filter.hide_namespace("assistant"); + filter.hide_namespace("copilot"); filter.hide_namespace("zed_predict_onboarding"); + filter.hide_namespace("edit_prediction"); use editor::actions::{ @@ -282,6 +284,7 @@ fn update_command_palette_filter(cx: &mut App) { } else { filter.show_namespace("agent"); filter.show_namespace("assistant"); + filter.show_namespace("copilot"); filter.show_namespace("zed_predict_onboarding"); filter.show_namespace("edit_prediction"); From 985350f9e8fcaea66750c8b4a99d07a0ef0f39cf Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Fri, 25 Jul 2025 17:39:50 +0200 Subject: [PATCH 0214/1052] terminal: Support ~ in cwd field of task definitions (#35097) Closes #35022 Release Notes: - Fixed `~` not being expanded correctly in `cwd` field of task definitions. --- crates/project/src/terminals.rs | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/crates/project/src/terminals.rs b/crates/project/src/terminals.rs index 8cfbdff311..973d4e8811 100644 --- a/crates/project/src/terminals.rs +++ b/crates/project/src/terminals.rs @@ -213,17 +213,24 @@ impl Project { cx: &mut Context, ) -> Result> { let this = &mut *self; + let ssh_details = this.ssh_details(cx); let path: Option> = match &kind { TerminalKind::Shell(path) => path.as_ref().map(|path| Arc::from(path.as_ref())), TerminalKind::Task(spawn_task) => { if let Some(cwd) = &spawn_task.cwd { - Some(Arc::from(cwd.as_ref())) + if ssh_details.is_some() { + Some(Arc::from(cwd.as_ref())) + } else { + let cwd = cwd.to_string_lossy(); + let tilde_substituted = shellexpand::tilde(&cwd); + Some(Arc::from(Path::new(tilde_substituted.as_ref()))) + } } else { this.active_project_directory(cx) } } }; - let ssh_details = this.ssh_details(cx); + let is_ssh_terminal = ssh_details.is_some(); let mut settings_location = None; From abb3ed1ed1bee71a8fd0c5e805f4020a9aa20ab6 Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Fri, 25 Jul 2025 17:48:09 +0200 Subject: [PATCH 0215/1052] git: Fix commit modal contents being searchable (#35099) Fixes #35093 Release Notes: - Fixed Git commit editor being searchable. --- crates/git_ui/src/git_panel.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index 061833a6c7..a8d1da7daf 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -380,6 +380,9 @@ pub(crate) fn commit_message_editor( window: &mut Window, cx: &mut Context, ) -> Editor { + project.update(cx, |this, cx| { + this.mark_buffer_as_non_searchable(commit_message_buffer.read(cx).remote_id(), cx); + }); let buffer = cx.new(|cx| MultiBuffer::singleton(commit_message_buffer, cx)); let max_lines = if in_panel { MAX_PANEL_EDITOR_LINES } else { 18 }; let mut commit_editor = Editor::new( From 993d5753d5997ca0766626dc225771aac76031f7 Mon Sep 17 00:00:00 2001 From: Haojian Wu Date: Fri, 25 Jul 2025 18:14:44 +0200 Subject: [PATCH 0216/1052] docs: Add a missing "," in the C/C++ debugger configuration (#35098) Release Notes: - N/A --- docs/src/languages/c.md | 2 +- docs/src/languages/cpp.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/src/languages/c.md b/docs/src/languages/c.md index 14a11c0d66..8db1bb6712 100644 --- a/docs/src/languages/c.md +++ b/docs/src/languages/c.md @@ -77,7 +77,7 @@ You can use CodeLLDB or GDB to debug native binaries. (Make sure that your build "command": "make", "args": ["-j8"], "cwd": "$ZED_WORKTREE_ROOT" - } + }, "program": "$ZED_WORKTREE_ROOT/build/prog", "request": "launch", "adapter": "CodeLLDB" diff --git a/docs/src/languages/cpp.md b/docs/src/languages/cpp.md index 1273bce2ac..e84bb6ea50 100644 --- a/docs/src/languages/cpp.md +++ b/docs/src/languages/cpp.md @@ -127,7 +127,7 @@ You can use CodeLLDB or GDB to debug native binaries. (Make sure that your build "command": "make", "args": ["-j8"], "cwd": "$ZED_WORKTREE_ROOT" - } + }, "program": "$ZED_WORKTREE_ROOT/build/prog", "request": "launch", "adapter": "CodeLLDB" From 2f812c339c1e1f01a3c04d38ca5190520df73c85 Mon Sep 17 00:00:00 2001 From: Umesh Yadav <23421535+imumesh18@users.noreply.github.com> Date: Fri, 25 Jul 2025 22:25:38 +0530 Subject: [PATCH 0217/1052] agent_ui: Fix delay when loading keybindings in the Agent panel settings (#34954) Fixes a annoying lag in agent settings panel where the keybindings would show up after a lag. Close to 1-2 secs. It was a simple fix previously we were not passing the focus handler to context menu which made the keybindings lookup slower compared to other parts like git panel and title bar profile dropdown. | Before | After | |--------|--------| | | | Release Notes: - Fix delay when loading keybindings in the Agent panel settings --- crates/agent_ui/src/agent_panel.rs | 116 +++++++++++++++-------------- 1 file changed, 60 insertions(+), 56 deletions(-) diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 4b3db4bc1d..43c1167af8 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -2016,65 +2016,69 @@ impl AgentPanel { ) .anchor(Corner::TopRight) .with_handle(self.agent_panel_menu_handle.clone()) - .menu(move |window, cx| { - Some(ContextMenu::build(window, cx, |mut menu, _window, _| { - if let Some(usage) = usage { + .menu({ + let focus_handle = focus_handle.clone(); + move |window, cx| { + Some(ContextMenu::build(window, cx, |mut menu, _window, _| { + menu = menu.context(focus_handle.clone()); + if let Some(usage) = usage { + menu = menu + .header_with_link("Prompt Usage", "Manage", account_url.clone()) + .custom_entry( + move |_window, cx| { + let used_percentage = match usage.limit { + UsageLimit::Limited(limit) => { + Some((usage.amount as f32 / limit as f32) * 100.) + } + UsageLimit::Unlimited => None, + }; + + h_flex() + .flex_1() + .gap_1p5() + .children(used_percentage.map(|percent| { + ProgressBar::new("usage", percent, 100., cx) + })) + .child( + Label::new(match usage.limit { + UsageLimit::Limited(limit) => { + format!("{} / {limit}", usage.amount) + } + UsageLimit::Unlimited => { + format!("{} / ∞", usage.amount) + } + }) + .size(LabelSize::Small) + .color(Color::Muted), + ) + .into_any_element() + }, + move |_, cx| cx.open_url(&zed_urls::account_url(cx)), + ) + .separator() + } + menu = menu - .header_with_link("Prompt Usage", "Manage", account_url.clone()) - .custom_entry( - move |_window, cx| { - let used_percentage = match usage.limit { - UsageLimit::Limited(limit) => { - Some((usage.amount as f32 / limit as f32) * 100.) - } - UsageLimit::Unlimited => None, - }; - - h_flex() - .flex_1() - .gap_1p5() - .children(used_percentage.map(|percent| { - ProgressBar::new("usage", percent, 100., cx) - })) - .child( - Label::new(match usage.limit { - UsageLimit::Limited(limit) => { - format!("{} / {limit}", usage.amount) - } - UsageLimit::Unlimited => { - format!("{} / ∞", usage.amount) - } - }) - .size(LabelSize::Small) - .color(Color::Muted), - ) - .into_any_element() - }, - move |_, cx| cx.open_url(&zed_urls::account_url(cx)), + .header("MCP Servers") + .action( + "View Server Extensions", + Box::new(zed_actions::Extensions { + category_filter: Some( + zed_actions::ExtensionCategoryFilter::ContextServers, + ), + id: None, + }), ) - .separator() - } + .action("Add Custom Server…", Box::new(AddContextServer)) + .separator(); - menu = menu - .header("MCP Servers") - .action( - "View Server Extensions", - Box::new(zed_actions::Extensions { - category_filter: Some( - zed_actions::ExtensionCategoryFilter::ContextServers, - ), - id: None, - }), - ) - .action("Add Custom Server…", Box::new(AddContextServer)) - .separator(); - - menu = menu - .action("Rules…", Box::new(OpenRulesLibrary::default())) - .action("Settings", Box::new(OpenConfiguration)) - .action(zoom_in_label, Box::new(ToggleZoom)); - menu - })) + menu = menu + .action("Rules…", Box::new(OpenRulesLibrary::default())) + .action("Settings", Box::new(OpenConfiguration)) + .action(zoom_in_label, Box::new(ToggleZoom)); + menu + })) + } }); h_flex() From cd5095872748ef2d56fa03b54e40b6aaa5ff7906 Mon Sep 17 00:00:00 2001 From: Kainoa Kanter Date: Fri, 25 Jul 2025 10:17:16 -0700 Subject: [PATCH 0218/1052] Add icon for SurrealQL files (#34855) Release Notes: - Added icon for SurrealQL (`.surql`) files --------- Co-authored-by: Danilo Leal --- assets/icons/file_icons/surrealql.svg | 3 +++ crates/theme/src/icon_theme.rs | 2 ++ 2 files changed, 5 insertions(+) create mode 100644 assets/icons/file_icons/surrealql.svg diff --git a/assets/icons/file_icons/surrealql.svg b/assets/icons/file_icons/surrealql.svg new file mode 100644 index 0000000000..076f93e808 --- /dev/null +++ b/assets/icons/file_icons/surrealql.svg @@ -0,0 +1,3 @@ + + + diff --git a/crates/theme/src/icon_theme.rs b/crates/theme/src/icon_theme.rs index 09f5df06b0..baa928d722 100644 --- a/crates/theme/src/icon_theme.rs +++ b/crates/theme/src/icon_theme.rs @@ -216,6 +216,7 @@ const FILE_SUFFIXES_BY_ICON_KEY: &[(&str, &[&str])] = &[ "stylelintrc.yml", ], ), + ("surrealql", &["surql"]), ("svelte", &["svelte"]), ("swift", &["swift"]), ("tcl", &["tcl"]), @@ -340,6 +341,7 @@ const FILE_ICONS: &[(&str, &str)] = &[ ("solidity", "icons/file_icons/file.svg"), ("storage", "icons/file_icons/database.svg"), ("stylelint", "icons/file_icons/javascript.svg"), + ("surrealql", "icons/file_icons/surrealql.svg"), ("svelte", "icons/file_icons/html.svg"), ("swift", "icons/file_icons/swift.svg"), ("tcl", "icons/file_icons/tcl.svg"), From 4abe14f94a30c0fc9c4e0e3ef14cae7609f7b429 Mon Sep 17 00:00:00 2001 From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com> Date: Fri, 25 Jul 2025 13:19:05 -0400 Subject: [PATCH 0219/1052] keymap ui: Resize columns on double click improvement (#35095) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This PR improves the behavior of resetting a column's size by double-clicking on its column handle. We now shrink/grow to the side that has more leftover/additional space. We also improved the below 1. dragging was a couple of pixels off to the left because we didn't take the column handle’s width into account. 2. Column dragging now has memory and will shift things to their exact position when reversing a drag before letting the drag handle go. 3. Improved our test infrastructure. 4. Double clicking on a column's header resizes the column Release Notes: - N/A --------- Co-authored-by: Ben Kunkle --- crates/settings_ui/Cargo.toml | 3 + crates/settings_ui/src/ui_components/table.rs | 637 +++++++++++++++--- 2 files changed, 546 insertions(+), 94 deletions(-) diff --git a/crates/settings_ui/Cargo.toml b/crates/settings_ui/Cargo.toml index 02327045fd..25f033469d 100644 --- a/crates/settings_ui/Cargo.toml +++ b/crates/settings_ui/Cargo.toml @@ -45,3 +45,6 @@ ui_input.workspace = true util.workspace = true workspace-hack.workspace = true workspace.workspace = true + +[dev-dependencies] +db = {"workspace"= true, "features" = ["test-support"]} diff --git a/crates/settings_ui/src/ui_components/table.rs b/crates/settings_ui/src/ui_components/table.rs index 69207f559b..65778c20eb 100644 --- a/crates/settings_ui/src/ui_components/table.rs +++ b/crates/settings_ui/src/ui_components/table.rs @@ -2,9 +2,9 @@ use std::{ops::Range, rc::Rc, time::Duration}; use editor::{EditorSettings, ShowScrollbar, scroll::ScrollbarAutoHide}; use gpui::{ - AbsoluteLength, AppContext, Axis, Context, DefiniteLength, DragMoveEvent, Entity, FocusHandle, - Length, ListHorizontalSizingBehavior, ListSizingBehavior, MouseButton, Point, Stateful, Task, - UniformListScrollHandle, WeakEntity, transparent_black, uniform_list, + AbsoluteLength, AppContext, Axis, Context, DefiniteLength, DragMoveEvent, Entity, EntityId, + FocusHandle, Length, ListHorizontalSizingBehavior, ListSizingBehavior, MouseButton, Point, + Stateful, Task, UniformListScrollHandle, WeakEntity, transparent_black, uniform_list, }; use itertools::intersperse_with; @@ -13,10 +13,12 @@ use ui::{ ActiveTheme as _, AnyElement, App, Button, ButtonCommon as _, ButtonStyle, Color, Component, ComponentScope, Div, ElementId, FixedWidth as _, FluentBuilder as _, Indicator, InteractiveElement, IntoElement, ParentElement, Pixels, RegisterComponent, RenderOnce, - Scrollbar, ScrollbarState, StatefulInteractiveElement, Styled, StyledExt as _, + Scrollbar, ScrollbarState, SharedString, StatefulInteractiveElement, Styled, StyledExt as _, StyledTypography, Window, div, example_group_with_title, h_flex, px, single_example, v_flex, }; +const RESIZE_COLUMN_WIDTH: f32 = 5.0; + #[derive(Debug)] struct DraggedColumn(usize); @@ -227,7 +229,7 @@ impl TableInteractionState { .id("column-resize-handle") .absolute() .left_neg_0p5() - .w(px(5.0)) + .w(px(RESIZE_COLUMN_WIDTH)) .h_full(); if resizable_columns @@ -478,6 +480,7 @@ impl ResizeBehavior { pub struct ColumnWidths { widths: [DefiniteLength; COLS], + visible_widths: [DefiniteLength; COLS], cached_bounds_width: Pixels, initialized: bool, } @@ -486,6 +489,7 @@ impl ColumnWidths { pub fn new(_: &mut App) -> Self { Self { widths: [DefiniteLength::default(); COLS], + visible_widths: [DefiniteLength::default(); COLS], cached_bounds_width: Default::default(), initialized: false, } @@ -512,46 +516,105 @@ impl ColumnWidths { let rem_size = window.rem_size(); let initial_sizes = initial_sizes.map(|length| Self::get_fraction(&length, bounds_width, rem_size)); - let mut widths = self + let widths = self .widths .map(|length| Self::get_fraction(&length, bounds_width, rem_size)); - let diff = initial_sizes[double_click_position] - widths[double_click_position]; + let updated_widths = Self::reset_to_initial_size( + double_click_position, + widths, + initial_sizes, + resize_behavior, + ); + self.widths = updated_widths.map(DefiniteLength::Fraction); + self.visible_widths = self.widths; + } - if diff > 0.0 { - let diff_remaining = self.propagate_resize_diff_right( - diff, - double_click_position, - &mut widths, - resize_behavior, - ); + fn reset_to_initial_size( + col_idx: usize, + mut widths: [f32; COLS], + initial_sizes: [f32; COLS], + resize_behavior: &[ResizeBehavior; COLS], + ) -> [f32; COLS] { + // RESET: + // Part 1: + // Figure out if we should shrink/grow the selected column + // Get diff which represents the change in column we want to make initial size delta curr_size = diff + // + // Part 2: We need to decide which side column we should move and where + // + // If we want to grow our column we should check the left/right columns diff to see what side + // has a greater delta than their initial size. Likewise, if we shrink our column we should check + // the left/right column diffs to see what side has the smallest delta. + // + // Part 3: resize + // + // col_idx represents the column handle to the right of an active column + // + // If growing and right has the greater delta { + // shift col_idx to the right + // } else if growing and left has the greater delta { + // shift col_idx - 1 to the left + // } else if shrinking and the right has the greater delta { + // shift + // } { + // + // } + // } + // + // if we need to shrink, then if the right + // - if diff_remaining > 0.0 && double_click_position > 0 { - self.propagate_resize_diff_left( - -diff_remaining, - double_click_position - 1, + // DRAGGING + // we get diff which represents the change in the _drag handle_ position + // -diff => dragging left -> + // grow the column to the right of the handle as much as we can shrink columns to the left of the handle + // +diff => dragging right -> growing handles column + // grow the column to the left of the handle as much as we can shrink columns to the right of the handle + // + + let diff = initial_sizes[col_idx] - widths[col_idx]; + + let left_diff = + initial_sizes[..col_idx].iter().sum::() - widths[..col_idx].iter().sum::(); + let right_diff = initial_sizes[col_idx + 1..].iter().sum::() + - widths[col_idx + 1..].iter().sum::(); + + let go_left_first = if diff < 0.0 { + left_diff > right_diff + } else { + left_diff < right_diff + }; + + if !go_left_first { + let diff_remaining = + Self::propagate_resize_diff(diff, col_idx, &mut widths, resize_behavior, 1); + + if diff_remaining != 0.0 && col_idx > 0 { + Self::propagate_resize_diff( + diff_remaining, + col_idx, &mut widths, resize_behavior, + -1, ); } - } else if double_click_position > 0 { - let diff_remaining = self.propagate_resize_diff_left( - diff, - double_click_position, - &mut widths, - resize_behavior, - ); + } else { + let diff_remaining = + Self::propagate_resize_diff(diff, col_idx, &mut widths, resize_behavior, -1); - if diff_remaining < 0.0 { - self.propagate_resize_diff_right( - -diff_remaining, - double_click_position, + if diff_remaining != 0.0 { + Self::propagate_resize_diff( + diff_remaining, + col_idx, &mut widths, resize_behavior, + 1, ); } } - self.widths = widths.map(DefiniteLength::Fraction); + + widths } fn on_drag_move( @@ -569,98 +632,102 @@ impl ColumnWidths { let bounds_width = bounds.right() - bounds.left(); let col_idx = drag_event.drag(cx).0; + let column_handle_width = Self::get_fraction( + &DefiniteLength::Absolute(AbsoluteLength::Pixels(px(RESIZE_COLUMN_WIDTH))), + bounds_width, + rem_size, + ); + let mut widths = self .widths .map(|length| Self::get_fraction(&length, bounds_width, rem_size)); for length in widths[0..=col_idx].iter() { - col_position += length; + col_position += length + column_handle_width; } let mut total_length_ratio = col_position; for length in widths[col_idx + 1..].iter() { total_length_ratio += length; } + total_length_ratio += (COLS - 1 - col_idx) as f32 * column_handle_width; let drag_fraction = (drag_position.x - bounds.left()) / bounds_width; let drag_fraction = drag_fraction * total_length_ratio; - let diff = drag_fraction - col_position; + let diff = drag_fraction - col_position - column_handle_width / 2.0; - let is_dragging_right = diff > 0.0; + Self::drag_column_handle(diff, col_idx, &mut widths, resize_behavior); - if is_dragging_right { - self.propagate_resize_diff_right(diff, col_idx, &mut widths, resize_behavior); - } else { - // Resize behavior should be improved in the future by also seeking to the right column when there's not enough space - self.propagate_resize_diff_left(diff, col_idx, &mut widths, resize_behavior); - } - self.widths = widths.map(DefiniteLength::Fraction); + self.visible_widths = widths.map(DefiniteLength::Fraction); } - fn propagate_resize_diff_right( - &self, + fn drag_column_handle( diff: f32, col_idx: usize, widths: &mut [f32; COLS], resize_behavior: &[ResizeBehavior; COLS], - ) -> f32 { - let mut diff_remaining = diff; - let mut curr_column = col_idx + 1; - - while diff_remaining > 0.0 && curr_column < COLS { - let Some(min_size) = resize_behavior[curr_column - 1].min_size() else { - curr_column += 1; - continue; - }; - - let mut curr_width = widths[curr_column] - diff_remaining; - - diff_remaining = 0.0; - if min_size > curr_width { - diff_remaining += min_size - curr_width; - curr_width = min_size; - } - widths[curr_column] = curr_width; - curr_column += 1; + ) { + // if diff > 0.0 then go right + if diff > 0.0 { + Self::propagate_resize_diff(diff, col_idx, widths, resize_behavior, 1); + } else { + Self::propagate_resize_diff(-diff, col_idx + 1, widths, resize_behavior, -1); } - - widths[col_idx] = widths[col_idx] + (diff - diff_remaining); - return diff_remaining; } - fn propagate_resize_diff_left( - &mut self, + fn propagate_resize_diff( diff: f32, - mut curr_column: usize, + col_idx: usize, widths: &mut [f32; COLS], resize_behavior: &[ResizeBehavior; COLS], + direction: i8, ) -> f32 { let mut diff_remaining = diff; - let col_idx = curr_column; - while diff_remaining < 0.0 { + if resize_behavior[col_idx].min_size().is_none() { + return diff; + } + + let step_right; + let step_left; + if direction < 0 { + step_right = 0; + step_left = 1; + } else { + step_right = 1; + step_left = 0; + } + if col_idx == 0 && direction < 0 { + return diff; + } + let mut curr_column = col_idx + step_right - step_left; + + while diff_remaining != 0.0 && curr_column < COLS { let Some(min_size) = resize_behavior[curr_column].min_size() else { if curr_column == 0 { break; } - curr_column -= 1; + curr_column -= step_left; + curr_column += step_right; continue; }; - let mut curr_width = widths[curr_column] + diff_remaining; - - diff_remaining = 0.0; - if curr_width < min_size { - diff_remaining = curr_width - min_size; - curr_width = min_size - } - + let curr_width = widths[curr_column] - diff_remaining; widths[curr_column] = curr_width; + + if min_size > curr_width { + diff_remaining = min_size - curr_width; + widths[curr_column] = min_size; + } else { + diff_remaining = 0.0; + break; + } if curr_column == 0 { break; } - curr_column -= 1; + curr_column -= step_left; + curr_column += step_right; } - widths[col_idx + 1] = widths[col_idx + 1] - (diff - diff_remaining); + widths[col_idx] = widths[col_idx] + (diff - diff_remaining); return diff_remaining; } @@ -686,7 +753,7 @@ impl TableWidths { fn lengths(&self, cx: &App) -> [Length; COLS] { self.current .as_ref() - .map(|entity| entity.read(cx).widths.map(Length::Definite)) + .map(|entity| entity.read(cx).visible_widths.map(Length::Definite)) .unwrap_or(self.initial.map(Length::Definite)) } } @@ -799,6 +866,7 @@ impl Table { if !widths.initialized { widths.initialized = true; widths.widths = table_widths.initial; + widths.visible_widths = widths.widths; } }) } @@ -888,11 +956,24 @@ pub fn render_row( pub fn render_header( headers: [impl IntoElement; COLS], table_context: TableRenderContext, + columns_widths: Option<( + WeakEntity>, + [ResizeBehavior; COLS], + [DefiniteLength; COLS], + )>, + entity_id: Option, cx: &mut App, ) -> impl IntoElement { let column_widths = table_context .column_widths .map_or([None; COLS], |widths| widths.map(Some)); + + let element_id = entity_id + .map(|entity| entity.to_string()) + .unwrap_or_default(); + + let shared_element_id: SharedString = format!("table-{}", element_id).into(); + div() .flex() .flex_row() @@ -902,12 +983,39 @@ pub fn render_header( .p_2() .border_b_1() .border_color(cx.theme().colors().border) - .children( - headers - .into_iter() - .zip(column_widths) - .map(|(h, width)| base_cell_style_text(width, cx).child(h)), - ) + .children(headers.into_iter().enumerate().zip(column_widths).map( + |((header_idx, h), width)| { + base_cell_style_text(width, cx) + .child(h) + .id(ElementId::NamedInteger( + shared_element_id.clone(), + header_idx as u64, + )) + .when_some( + columns_widths.as_ref().cloned(), + |this, (column_widths, resizables, initial_sizes)| { + if resizables[header_idx].is_resizable() { + this.on_click(move |event, window, cx| { + if event.down.click_count > 1 { + column_widths + .update(cx, |column, _| { + column.on_double_click( + header_idx, + &initial_sizes, + &resizables, + window, + ); + }) + .ok(); + } + }) + } else { + this + } + }, + ) + }, + )) } #[derive(Clone)] @@ -939,6 +1047,12 @@ impl RenderOnce for Table { .and_then(|widths| Some((widths.current.as_ref()?, widths.resizable))) .map(|(curr, resize_behavior)| (curr.downgrade(), resize_behavior)); + let current_widths_with_initial_sizes = self + .col_widths + .as_ref() + .and_then(|widths| Some((widths.current.as_ref()?, widths.resizable, widths.initial))) + .map(|(curr, resize_behavior, initial)| (curr.downgrade(), resize_behavior, initial)); + let scroll_track_size = px(16.); let h_scroll_offset = if interaction_state .as_ref() @@ -958,7 +1072,13 @@ impl RenderOnce for Table { .h_full() .v_flex() .when_some(self.headers.take(), |this, headers| { - this.child(render_header(headers, table_context.clone(), cx)) + this.child(render_header( + headers, + table_context.clone(), + current_widths_with_initial_sizes, + interaction_state.as_ref().map(Entity::entity_id), + cx, + )) }) .when_some(current_widths, { |this, (widths, resize_behavior)| { @@ -972,19 +1092,28 @@ impl RenderOnce for Table { .ok(); } }) - .on_children_prepainted(move |bounds, _, cx| { + .on_children_prepainted({ + let widths = widths.clone(); + move |bounds, _, cx| { + widths + .update(cx, |widths, _| { + // This works because all children x axis bounds are the same + widths.cached_bounds_width = + bounds[0].right() - bounds[0].left(); + }) + .ok(); + } + }) + .on_drop::(move |_, _, cx| { widths .update(cx, |widths, _| { - // This works because all children x axis bounds are the same - widths.cached_bounds_width = bounds[0].right() - bounds[0].left(); + widths.widths = widths.visible_widths; }) .ok(); + // Finish the resize operation }) } }) - .on_drop::(|_, _, _| { - // Finish the resize operation - }) .child( div() .flex_grow() @@ -1313,3 +1442,323 @@ impl Component for Table<3> { ) } } + +#[cfg(test)] +mod test { + use super::*; + + fn is_almost_eq(a: &[f32], b: &[f32]) -> bool { + a.len() == b.len() && a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-6) + } + + fn cols_to_str(cols: &[f32; COLS], total_size: f32) -> String { + cols.map(|f| "*".repeat(f32::round(f * total_size) as usize)) + .join("|") + } + + fn parse_resize_behavior( + input: &str, + total_size: f32, + ) -> [ResizeBehavior; COLS] { + let mut resize_behavior = [ResizeBehavior::None; COLS]; + let mut max_index = 0; + for (index, col) in input.split('|').enumerate() { + if col.starts_with('X') || col.is_empty() { + resize_behavior[index] = ResizeBehavior::None; + } else if col.starts_with('*') { + resize_behavior[index] = ResizeBehavior::MinSize(col.len() as f32 / total_size); + } else { + panic!("invalid test input: unrecognized resize behavior: {}", col); + } + max_index = index; + } + + if max_index + 1 != COLS { + panic!("invalid test input: too many columns"); + } + resize_behavior + } + + mod reset_column_size { + use super::*; + + fn parse(input: &str) -> ([f32; COLS], f32, Option) { + let mut widths = [f32::NAN; COLS]; + let mut column_index = None; + for (index, col) in input.split('|').enumerate() { + widths[index] = col.len() as f32; + if col.starts_with('X') { + column_index = Some(index); + } + } + + for w in widths { + assert!(w.is_finite(), "incorrect number of columns"); + } + let total = widths.iter().sum::(); + for width in &mut widths { + *width /= total; + } + (widths, total, column_index) + } + + #[track_caller] + fn check_reset_size( + initial_sizes: &str, + widths: &str, + expected: &str, + resize_behavior: &str, + ) { + let (initial_sizes, total_1, None) = parse::(initial_sizes) else { + panic!("invalid test input: initial sizes should not be marked"); + }; + let (widths, total_2, Some(column_index)) = parse::(widths) else { + panic!("invalid test input: widths should be marked"); + }; + assert_eq!( + total_1, total_2, + "invalid test input: total width not the same {total_1}, {total_2}" + ); + let (expected, total_3, None) = parse::(expected) else { + panic!("invalid test input: expected should not be marked: {expected:?}"); + }; + assert_eq!( + total_2, total_3, + "invalid test input: total width not the same" + ); + let resize_behavior = parse_resize_behavior::(resize_behavior, total_1); + let result = ColumnWidths::reset_to_initial_size( + column_index, + widths, + initial_sizes, + &resize_behavior, + ); + let is_eq = is_almost_eq(&result, &expected); + if !is_eq { + let result_str = cols_to_str(&result, total_1); + let expected_str = cols_to_str(&expected, total_1); + panic!( + "resize failed\ncomputed: {result_str}\nexpected: {expected_str}\n\ncomputed values: {result:?}\nexpected values: {expected:?}\n:minimum widths: {resize_behavior:?}" + ); + } + } + + macro_rules! check_reset_size { + (columns: $cols:expr, starting: $initial:expr, snapshot: $current:expr, expected: $expected:expr, resizing: $resizing:expr $(,)?) => { + check_reset_size::<$cols>($initial, $current, $expected, $resizing); + }; + ($name:ident, columns: $cols:expr, starting: $initial:expr, snapshot: $current:expr, expected: $expected:expr, minimums: $resizing:expr $(,)?) => { + #[test] + fn $name() { + check_reset_size::<$cols>($initial, $current, $expected, $resizing); + } + }; + } + + check_reset_size!( + basic_right, + columns: 5, + starting: "**|**|**|**|**", + snapshot: "**|**|X|***|**", + expected: "**|**|**|**|**", + minimums: "X|*|*|*|*", + ); + + check_reset_size!( + basic_left, + columns: 5, + starting: "**|**|**|**|**", + snapshot: "**|**|***|X|**", + expected: "**|**|**|**|**", + minimums: "X|*|*|*|**", + ); + + check_reset_size!( + squashed_left_reset_col2, + columns: 6, + starting: "*|***|**|**|****|*", + snapshot: "*|*|X|*|*|********", + expected: "*|*|**|*|*|*******", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + grow_cascading_right, + columns: 6, + starting: "*|***|****|**|***|*", + snapshot: "*|***|X|**|**|*****", + expected: "*|***|****|*|*|****", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + squashed_right_reset_col4, + columns: 6, + starting: "*|***|**|**|****|*", + snapshot: "*|********|*|*|X|*", + expected: "*|*****|*|*|****|*", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + reset_col6_right, + columns: 6, + starting: "*|***|**|***|***|**", + snapshot: "*|***|**|***|**|XXX", + expected: "*|***|**|***|***|**", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + reset_col6_left, + columns: 6, + starting: "*|***|**|***|***|**", + snapshot: "*|***|**|***|****|X", + expected: "*|***|**|***|***|**", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + last_column_grow_cascading, + columns: 6, + starting: "*|***|**|**|**|***", + snapshot: "*|*******|*|**|*|X", + expected: "*|******|*|*|*|***", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + goes_left_when_left_has_extreme_diff, + columns: 6, + starting: "*|***|****|**|**|***", + snapshot: "*|********|X|*|**|**", + expected: "*|*****|****|*|**|**", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + basic_shrink_right, + columns: 6, + starting: "**|**|**|**|**|**", + snapshot: "**|**|XXX|*|**|**", + expected: "**|**|**|**|**|**", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + shrink_should_go_left, + columns: 6, + starting: "*|***|**|*|*|*", + snapshot: "*|*|XXX|**|*|*", + expected: "*|**|**|**|*|*", + minimums: "X|*|*|*|*|*", + ); + + check_reset_size!( + shrink_should_go_right, + columns: 6, + starting: "*|***|**|**|**|*", + snapshot: "*|****|XXX|*|*|*", + expected: "*|****|**|**|*|*", + minimums: "X|*|*|*|*|*", + ); + } + + mod drag_handle { + use super::*; + + fn parse(input: &str) -> ([f32; COLS], f32, Option) { + let mut widths = [f32::NAN; COLS]; + let column_index = input.replace("*", "").find("I"); + for (index, col) in input.replace("I", "|").split('|').enumerate() { + widths[index] = col.len() as f32; + } + + for w in widths { + assert!(w.is_finite(), "incorrect number of columns"); + } + let total = widths.iter().sum::(); + for width in &mut widths { + *width /= total; + } + (widths, total, column_index) + } + + #[track_caller] + fn check( + distance: i32, + widths: &str, + expected: &str, + resize_behavior: &str, + ) { + let (mut widths, total_1, Some(column_index)) = parse::(widths) else { + panic!("invalid test input: widths should be marked"); + }; + let (expected, total_2, None) = parse::(expected) else { + panic!("invalid test input: expected should not be marked: {expected:?}"); + }; + assert_eq!( + total_1, total_2, + "invalid test input: total width not the same" + ); + let resize_behavior = parse_resize_behavior::(resize_behavior, total_1); + + let distance = distance as f32 / total_1; + + let result = ColumnWidths::drag_column_handle( + distance, + column_index, + &mut widths, + &resize_behavior, + ); + + let is_eq = is_almost_eq(&widths, &expected); + if !is_eq { + let result_str = cols_to_str(&widths, total_1); + let expected_str = cols_to_str(&expected, total_1); + panic!( + "resize failed\ncomputed: {result_str}\nexpected: {expected_str}\n\ncomputed values: {result:?}\nexpected values: {expected:?}\n:minimum widths: {resize_behavior:?}" + ); + } + } + + macro_rules! check { + (columns: $cols:expr, distance: $dist:expr, snapshot: $current:expr, expected: $expected:expr, resizing: $resizing:expr $(,)?) => { + check!($cols, $dist, $snapshot, $expected, $resizing); + }; + ($name:ident, columns: $cols:expr, distance: $dist:expr, snapshot: $current:expr, expected: $expected:expr, minimums: $resizing:expr $(,)?) => { + #[test] + fn $name() { + check::<$cols>($dist, $current, $expected, $resizing); + } + }; + } + + check!( + basic_right_drag, + columns: 3, + distance: 1, + snapshot: "**|**I**", + expected: "**|***|*", + minimums: "X|*|*", + ); + + check!( + drag_left_against_mins, + columns: 5, + distance: -1, + snapshot: "*|*|*|*I*******", + expected: "*|*|*|*|*******", + minimums: "X|*|*|*|*", + ); + + check!( + drag_left, + columns: 5, + distance: -2, + snapshot: "*|*|*|*****I***", + expected: "*|*|*|***|*****", + minimums: "X|*|*|*|*", + ); + } +} From ff67f18e0d334b4d5521f17412e0bd704452edaa Mon Sep 17 00:00:00 2001 From: Cole Miller Date: Fri, 25 Jul 2025 10:36:58 -0700 Subject: [PATCH 0220/1052] Bump livekit dep to try to fix flaky builds (#35103) Let's see if https://github.com/zed-industries/livekit-rust-sdks/pull/6 helps. Release Notes: - N/A --------- Signed-off-by: Cole Miller --- Cargo.lock | 22 +++++++++++++++------- crates/livekit_client/Cargo.toml | 4 ++-- 2 files changed, 17 insertions(+), 9 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 2c65131db0..82790da17f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7688,6 +7688,12 @@ version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" +[[package]] +name = "hex-literal" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bcaaec4551594c969335c98c903c1397853d4198408ea609190f420500f6be71" + [[package]] name = "hexf-parse" version = "0.2.1" @@ -9408,7 +9414,7 @@ dependencies = [ [[package]] name = "libwebrtc" version = "0.3.10" -source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4#d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4" +source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=2806c1554bb2e3627ea35089208a196e19f24847#2806c1554bb2e3627ea35089208a196e19f24847" dependencies = [ "cxx", "jni", @@ -9488,7 +9494,7 @@ checksum = "23fb14cb19457329c82206317a5663005a4d404783dc74f4252769b0d5f42856" [[package]] name = "livekit" version = "0.7.8" -source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4#d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4" +source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=2806c1554bb2e3627ea35089208a196e19f24847#2806c1554bb2e3627ea35089208a196e19f24847" dependencies = [ "chrono", "futures-util", @@ -9511,7 +9517,7 @@ dependencies = [ [[package]] name = "livekit-api" version = "0.4.2" -source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4#d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4" +source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=2806c1554bb2e3627ea35089208a196e19f24847#2806c1554bb2e3627ea35089208a196e19f24847" dependencies = [ "futures-util", "http 0.2.12", @@ -9535,7 +9541,7 @@ dependencies = [ [[package]] name = "livekit-protocol" version = "0.3.9" -source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4#d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4" +source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=2806c1554bb2e3627ea35089208a196e19f24847#2806c1554bb2e3627ea35089208a196e19f24847" dependencies = [ "futures-util", "livekit-runtime", @@ -9552,7 +9558,7 @@ dependencies = [ [[package]] name = "livekit-runtime" version = "0.4.0" -source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4#d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4" +source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=2806c1554bb2e3627ea35089208a196e19f24847#2806c1554bb2e3627ea35089208a196e19f24847" dependencies = [ "tokio", "tokio-stream", @@ -18539,7 +18545,7 @@ dependencies = [ [[package]] name = "webrtc-sys" version = "0.3.7" -source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4#d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4" +source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=2806c1554bb2e3627ea35089208a196e19f24847#2806c1554bb2e3627ea35089208a196e19f24847" dependencies = [ "cc", "cxx", @@ -18552,13 +18558,15 @@ dependencies = [ [[package]] name = "webrtc-sys-build" version = "0.3.6" -source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4#d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4" +source = "git+https://github.com/zed-industries/livekit-rust-sdks?rev=2806c1554bb2e3627ea35089208a196e19f24847#2806c1554bb2e3627ea35089208a196e19f24847" dependencies = [ "fs2", + "hex-literal", "regex", "reqwest 0.11.27", "scratch", "semver", + "sha2", "zip", ] diff --git a/crates/livekit_client/Cargo.toml b/crates/livekit_client/Cargo.toml index a0c11d46e6..c367e03bb7 100644 --- a/crates/livekit_client/Cargo.toml +++ b/crates/livekit_client/Cargo.toml @@ -40,8 +40,8 @@ util.workspace = true workspace-hack.workspace = true [target.'cfg(not(any(all(target_os = "windows", target_env = "gnu"), target_os = "freebsd")))'.dependencies] -libwebrtc = { rev = "d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4", git = "https://github.com/zed-industries/livekit-rust-sdks" } -livekit = { rev = "d2eade7a6b15d6dbdb38ba12a1ff7bf07fcebba4", git = "https://github.com/zed-industries/livekit-rust-sdks", features = [ +libwebrtc = { rev = "383e5377f8b7de1f8627ee16f0cf11c5293337bd", git = "https://github.com/zed-industries/livekit-rust-sdks" } +livekit = { rev = "383e5377f8b7de1f8627ee16f0cf11c5293337bd", git = "https://github.com/zed-industries/livekit-rust-sdks", features = [ "__rustls-tls" ] } From 0e7eea0d102cc39bdf1249db13dc9d5bb5ff9afd Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Fri, 25 Jul 2025 14:39:33 -0300 Subject: [PATCH 0221/1052] Add new Nightly app icons (#35104) Release Notes: - N/A --- crates/zed/resources/app-icon-nightly.png | Bin 239870 -> 232863 bytes crates/zed/resources/app-icon-nightly@2x.png | Bin 716288 -> 848597 bytes 2 files changed, 0 insertions(+), 0 deletions(-) diff --git a/crates/zed/resources/app-icon-nightly.png b/crates/zed/resources/app-icon-nightly.png index 5f1304a6af8d57bbf7414d175611829989d122da..562588955e81265c9a44ab399d5da5813f6805fd 100644 GIT binary patch literal 232863 zcmeAS@N?(olHy`uVBq!ia0y~yU}6Aa4mJh`hA$OYelajGa29w(7Bet#3xhBt!>l(0Kv zAAY=f^|J7Otlam#GTl>zUNt|iG__vW)fyA~_lL%@e>2{%a{V>8WmBC-kjI;7&Z9A1 z2GiH=u8?T$HuUQM&->E9$I(gSa{cTt_r2=NWtQ0Kb$h+a()F#@ti7{*zWB?ppTBI= zy|?oH^a*zAVK3juR@JMsw{QRO{d9Ntm)!@Zf0+8?{){@YOZL-FS6?cbyXE)uZ%nnW zC(nD@b9`G@lKJxMx6ctDjF&!*T@o+$lxO{$Uwij6zkmAoYfy;x%=LYj|DIRbX1#M? zm6Ge;iANtzEBU?JM1A*{=URIwuGfFf9OHF8_O|P7o7PM7xc>KMALQ0r`D$rMck<2n z`Wbd<`ZK+Gwt(d?#yqQ&sJIeUFUCq|Mu^uzv{8szYYn_zwbT$UidWam8+C9 zXQ}^~ClP(leMRN_my#d%{;I6~)iG=S%sBBvdDZ2bwe!xo35sR%PPz1b`kb`C^8-HI zY{@up`l;;e--F?u|MC}Zo>6z@LEKmCpF2vzpzIwy_pYoOA?@d2Bxn9qX)VaJTcIkZ6AO9k* zEPpx4f9Z?2w|@L|N@Lw-1W$s@c2lPqnUxnE_=O??Yn$_ zTT#_7>-VQjmVI=WnCg=(l_?{?|MP~sdGgyf)k++;k$n3uS#itpmkaFmnrwJB+4XI* zeV1IVb32ZA=bZSx6K)n)8*=T1r0FBiOeef!G~?-N9v z4ZYoJC-dD-xngblqe`Rf+pdOYs{O-em^_w(VK=C-T>F z6J~(~p2UKLKa(B3*WcfM{pGwbrLIPgLXCo^ZaJ&UYq4(reCZGIakmo+Dp+6ozT8}H zp!VZj!uQq3oO=_B`o6sPEuP5tXXni=DKWpKZ@!=Oc;d4q{(M2Z1T5^T-W!V4L~f}z zSl+@Gma$>-WYIrz&g_fty*q#D`B#&?UzHW}&w6G&Y*EZ1F2B9&Cd_GUej@Q^16xIZYLU>SM6>0s^)2W5+V(zp&bEKv7Pm{Ar`SD6f7kP{ zK5-6r{jX;eTHZK(Fp93pdtVk_pWfG8&o{r=VE+0g{1fNj7Wf}>Qc?Tztb1?cZroXB z{XTD#urvEQfqL#|Li=B5{CWFJX^zBQ{fl$@nd)DEiDSObFn7+eIezPu|Nr4=FVDX} zbsn$G>JwXq?-Z{3FmK=Ll=*dGE!r`spFOG9s;#>B^42}kzmw;z{_?7Pamn(``F{(- zbno|m{+fC9)b7cf4R~cIGk*}2>UQnA&R_;ne&Rv^j4Ke z){$T?{*7|!nTF9zjF+B07P$CWTDe}?E3U-`TVr>p$WPY1d;dmar^Sqkd;S@h-3)k@ z{-FHFHj&e3!i2t`{84Jl8!BLY=^)R1j>Su#u)HWeWZ2PhY0>=eKfXu>E|>rCYxUo} z^l3{@Z(~Z|D7T@ooG`2SR_2yUMag*%U)K6{xbFRt&&bS_Y`8DKyQWgUB;ZTr zktY*G4V;$l2;8&N?}gLt$2Y}NiyST$zpc%CXu)DvzNg=#Yq4?Qw>^5MNu^y6Zu9Xq z>|3tGwX&<_%oonim*vks>?}U;p3k*$XXC;nHm-NV&m5b2Y+C${^vC|oTeEegPAzCY z*Cru!Ns>$8t?f;P&yo+Mtm=Q=e7IxBj%h{vJkM88lY2i?GP%xg{ff{BcaA^F{P3&V zD(%tvEA!e-+E_Yv2si$J|Bcy5)#S&%us=~vcNbel_UTP&d-tL8gI$xNqN`J~RcYAe z{i2R5UoC#(Ab-Ma&P!>zW#TqhI$wRAm9ork<(8M0;km0{G_Scf|2lWIdF_?mFNK9) z1^my847>m0_p`gJSJ!{#oq5bX$w#vxyg)|Y-sWE3)43wDdnYgInIE5V^ z?B>~Y+s-$AnycNR_v$WZPDI$R_TX@clvR55>UXxwGK-MYM(!J8yCz5;eKq5t#KDa( zjtk22-<+`M`^`@-v)=A3IqN6(I=W%@Y-wNVCC&l8Ati?em(G&+u#8q)T*I2a*!TKE zHplg=SxauuekjjZ$n#z0(u(QZFMTcV*!A+jmrXW1=G$ef|2{4Lqi&f=)a>n-NnvD=(aX zae41*!NBLs=FR<3HK{eDZ296)k+aT9S%&sIrq<0568`OdZ;PG1%M8v^kIz@ON88-r zW!IMIlyz)Djd?~-7U$y6pC^Abaz8NN*)O?e#(mf1SA5f#i+5(P| zbTOU9=hIh4Nze1_eT;MBByI0E^=Vz3yU1~(=A?T;e$V^_LO;%5x+QR9Q?vNjUBBft zRp&p?;43}xl3htXHR^r$*W8=;W9pO_+P>Gjmj9fD)jLq~Lm-#o79Tpagp7(Pme%f+N+3Ug!hIZ$akjH@%%7uTc zo7NYLD2vVg-m>~*vF*0WAH$X}+|n$?zRUUAnW_9Q8lG>c%=yIdjM1xON@Zg2z8{C1 z?A`08Tvt!*VeD7Zms{xY_P3g)WNG?AmBb>4?+x#>T~_aKHI>;h{Yk& zq3*KYwU%a0E6il)mn>?KGAZL_4G@;w)3TRyy?9$f$<2)oCtp`dK0o-ic+nZ&j_)sa zZ2GAdVpqT;v60{JO9v=f$&Mc(M=j3SVIN&0Mlm&LWx{7IO zJjeaSW%dT#uqlk&$g}vfLQnOFNz4f=Cpx{)Z+qXmk>}W}1DkK%d~UpU!Rs{~G4WOZ z4^+Il$so(Qc89Zs@gd=!_J;*~3+2D$zPwrV*3Fr>$6ecEd%AA-zodyh zE`gaU*A$HU77MsMjJN$i-F?01?!8|3{z}%Za#NhV{?fDc;p&=P^H08ebg|=x8*}K{ zJ^|0~AJvW@s0s+-WYfFUcuPYjvt3YEwKJp1`5OQGnSW=u$3?2$D4nVBc(uC0iqO4` zC)ctk=KAz);yC%~tIdT!<#S!_Uh1t@<>_&=GU;LMD3H3jRag1Ck?V@ua=wa~&Pb0U zl_QBcJ_$EIm;d_CtrR!uQ^p#JN@>P3Jx$W{8o#JN5|ru{=IxQcl{&GfsA!i-mK;Z0 ztK(j|yWKo|eC#qp|2KBHUi+sd#cdJmbe*}dO}l>?UYKfg@KSHyMa4h&=J@Q6j0!4l`muXaOhX9gmlb;tR(Ca7mbmSgy{0rj z+k}0k(=P=UZ^t7C8y{%o@?Cy4Z+^nwH{ZLsLU+vBcK4|z-{UPob^3vgt89GqBbQar zJ6ZQTvFcojk;&eWW$6o7bX&RgZ7blM8O*F6e9_!r;lf4DRV?4tw`6b^rKi7MvUMf5 zgWfBXbdujUhO~g0fU2T6&1)4W`JwH)2dBTR^OyNh)>Y-;U3(}`+ zPTS(Pe_Glv^XD6XvoF7$zfb$}k79GLnaAeOUO4ezvvvL7_kYs=zx@Amb^QnS|F5p! z`uA#jklxRQ5+&-Pt<_(T5o$Bn{Hc3Vt@jxC&_^sR1w(t)E^d)++) zE-D3f`zaMqImM)nwn5 z%-EA~;Q8?duKov=t`2)GyxO-;e0Zc+ia$|x{>qPwE(bq5 zziLwRk&ZQuix*VJOC7m4fxUgw;f#I1b2yAN1;a0PxnEF-J62m3c%?9?xiQ46tV-#* zy5yyGnE|c>#*LE&*Dh1P!jQGgDKT?_xDcDVX4}C)!xE0bHBY~Ptv%H$;rz^nH%KdS z+riS8RlNGHC(7n09@)rnXrf*CPxVWu4~Q11PwHE_&VGsGoz9b)YlN1B#ZGRy>aHml zy?>Wp;o8c1(H0IdmsNba78?AMNp@2+d3q%w_vrKqn=>?e>y}zh4ti#}PGsZ3Peqe+ zFVxxkYiCcL^R9TJ#hvvm>J`iG?z1}b^_#&zH?gnlc}s*AFD$ppFDc9Y|8jHYc9rT+ z3>&^rO9^86IN#o9{%7x(_xEp_Q~$<0v~*KU{=JGVckO0PXtY;PE@JrC!*BYl^zSwO zsb3$~-`n=|{_S^hH6P>u9jyOcFn>|ll$Oeukwy_)g_?uTg)m zJAJ1#^C`u0zUImAR$u&6`=O?iKRHmJ&rsi>VUiym#fQn*HpL!1w!_QG)DWntT4w=v^nx zfAXB*V(0c*)qnP$4zxTI-}P(N)4*MA+{GQgZ2s47Hf`5>mNC75^`V-Jh8c+lS0-MT zv3`DMdPA~;Xt16_M%l}Y@sTPo-L(5;R>X;|zP`k3e}0tP!qyWnj6GMCq%(fM_?G>+ z^PN?EnG9>DI{g&!Hhxw;JKJvWu4RW8ipoD!jWIb?u{g)H;--3V@ZrfcqyOwiH%MnIyY{0*G}Hf`A_)7ZGi>ir9~ds|J>O(vGAzV+yJZ6u-SK)TFg0b zns7bzRrO@%1s$?7rw`3@HjGkMas77JZaF{4z0!*KzE8$$E;dhz$hfH%RJV0!|GcWK z_sh+fG%Wc)HL~=5_vW8>FPQkN89ki;(QqllzaBo*KflYqZeM!;pO@91{>3~ylb#iL zGI43_je3;u{NY(=2hM_BJEv|rT4dSJ@a4d#4u!pXlGUE=f9k6HzQ1U^ljr~O_q`nq zyIyjyb-w;*-LxaDZo#$pPdj9B*K2(Glwq!*YB=F;%lCi@39a9)ws2J3_qxAHSwJ9D zZ~FJA#`6Cqe|{_9uXp|T^0uT7Nuy^=leaV*xX)M0W9Uj*W8%Kn^zP@gYfC!RPFT41 zdU54!e?DjSqAeUA{8n!1R>u{tbV^2+I*CMuDakIle@UiaPQ~p^V3CMd@4cW?i*-V{ z9lXV>CH#Azb^j7rIbq#hBiDr={`{+|(EIgs)?{9{UqQ?Lo{L{)jx`H-m69RCo;*#l z=(#$_y4hEmbSAnSi8~k2dcjQmN$87RS{`36pa0mg*Tc_SGVEn(`pi4eLKzP#-BFtU z?k9&yRY8--jmNV}(}Q*PzwKZ>{V2&TiKooJewur}*PYnYdB1(;T#cX39`RhaXXQG} z)qWh!|CqL)2ne^ADP(q>G-1E{|GL^^8(;jM`1t|f$%F@2e_s9Kb2~5B-ty=93)3H5 z)iimO)i8I<&Zzso*XP9)svdpy{!;jvSIT>~XU0q1nij;@eSOkY|Kj?;9do#x?|zZm zeQoaXCQ+_!huf?}*%LIoZwi*M@A{^s>=X&;|amRT+#bJKlqA<0H?N(4=uT>@O#Ox{n*8ZkOYgxp&VTPKA7m!1-RZM;UW#c&P8LgWiN%eX z<-B6P{G}gzWU8&xy?5&yT|VmdIl}71d7aCD|DQQuV^(|g*V5)TzSevGXWHKj=*+wr z=$u$!uxQ7Z>$Q_V9qn~%)a>%USkGX&=F~C0DBbE0b2dxXTd5@Vu@&#VDDmp&yrzd- zUI#?11YJ@i`q&@Mwma+~q%6CF@4Dxi?VE3`+MKTX$9i7>)aNsw>L##cbLua(ktp;& zzw7^^h{H3Qx2|vBx=_KvXie9m?R%_vmiQUS^@dinEHY?KmHlwy!+oXC3LgTJ&SV?> zu#M2_I_GxuC%<#bIg=jA#OUn~HCs$Bc9fs{w|w&Ls8g%VwzRT%n^v`2w_N<9ylG

^<$;FGy0~c$pKd3l0p|9t29M|)Zg0&{qz0W3= z7`n&mX8d|LDbP|TV2_z4`)}=iY8I26^_)#=IZ7S=UOuW+T%O?+mHkS?<@C?ufWt~@ zvYiv>PoB8O!r}rS-|=%njIH^BA4S|w$S8XMlsvUWbFI}v&6l=~T`kvRt*Po}%zk7LwNb}?c z?2ntb+v_jamplEnvg=tlTVQU$kKjai@vM^{;v~*7tmp8*kha%iV(l-!YbCp{in=Vi z=#us7r`M{=Ch2nP%*(HD?agNXBB}JmT*T(W7X`CtrV>92cbIp|)mF+~tzZZYh+lUx z{C@n>jLh`=`5XQF{@C7^SLq3PTyjR-RO#8?tn(|BnV(uaMmfC~POmYl`2E-T~$1_4dg6C9A{=N*pwrk2QW&OiH|%vOv+Ha@m8et{Oa5@-j9`&ikfC zUJ_p{{hz@oexlv}T>rN>zunZ})d-VWTY6XRrKH-4-JY5~`?A|h8x#4Sb}V>#vDSoj z|K!KXm4&|^ExmHNf#Hb#m+uSTT)OOE({K6snS<6(|Lf+VEXT7i2HJQBr#ddrN^!~6 zeNuGbV(E^$rhszCx%R4#T2dDnIgQj0c&tkNGWYS;!<9UT?cKB2t zSnuKUPN^O1I-h*lKFf(=;==FSPZyP%v;LL78L#@qZC%q#s_OR6yUHo}AX#lLVg zl9nxrJ9peyKIDp77nkNycp=4I^@JD;m3&UwjC|MpvUUS|F{$*YEku33JsuHPwUbE{lr z=9Q&^)14OlDK&U;rFXI8*(5%fb;bPOtOecvhA8(;V^h4?RnwXAU1hO_p425pWnNa7 zb!N+ZHqEr+RA|4pY2N+mhp%?diLLFZw6xo&y8A9~OX7ikj&1C>Ym0+D(Z90iK8trKxO3}a{G+Nl7nWzLP8I9ZdichxeAOonHG!qYfomJp zKJ3fYYjS?$c0l{YwCNXZSoD;Pqm-TIAAd6O!&afU@9ym6&V2H)yjer=I_KxVKCfMh z?SB4U)n>7P#c;8zWNp{HQ=fin=A8Y#;9Og=XY>1q0Vlluyi>N!)h*k?#V794boj!o z#V_6~FJdWSs8*SA`N@m6^{T6qwb-4!BTs+X_BBh@+&tQ1i;C5^%3q%(MHem9Wb%CZ zAk==Hr+nni zsvB<@xrJ8ANk5fc%wyYfX<^*CAeE^_lTPTbTF}e+;6+`yQZ(m`scjPk^BND=Zr{yt zeF5u6?GrO>o_OUp3(d9G{T6(`#2>%s!lMQByYm$X4bvGfyqDn`R`L za65zD^m+09y%Ub7-}m`k?#mn_bD{A{j1^yMzuWIKw=WpRG%su27G}2mdc1T~aM$z1 zDbYe*TP;g@?Y7U7o&09z)qj^#R^Q-VbdaNY)zhUupKp8)Y)aU*Ty8~}?&hb3zh<>w zm~pWo$!^hS)gAJ?{%*B&itSr8b9LY0J%1G0*8~M6{L0zu_Q`LL&*rHT$0r({UDc%) z*l@y5IW~T#j2oZvjdM5p*DCrZ&Ck6qm+U6+qUZYz{h`=4_$XBu3E7BLs911OsO7$##Of-@I0{jVC`+Q{#Kf=%JkW*&Xl}v zxg}S<)VBNd zsr&Qar~2XlE2g)P)>Y@a9pJQJEm~fC`M`zmXG?G8oQZUA4>CQqrTL2Fd&_%1vvUpC z3o~u-J(i_^FQlEZ>-DE03V~2BbyH-1Q6i ztoXo=r-1jz-h(`BEM-Msq&5|9Fu4C~qH8Y zr8M@<+s%g?mNb}@>-J{Je{l&C`>e5ht(iJgi;F*h^n$6kX6pQQ>lG_v z1cD2D{>+!Nmsa@KSYhSIKZ9}03Hj^66`L1$?FnM~p4b;BGxb%Pa_;=4e%)cZ3Y)^* z%_Z~t7+*3xR=0ff`RCj(fAl|96-`q2j%W{=Uboz8@`d9b0XK_wdiK>yWEOpi_}u-I z)6_mBTahJtdeZOn7wkh@bRvRQR|_mkSY(j44 zeZ4>DLPP!kWG9AywtbHum-kJ7y}f?xs$J`sGe7HIr*~YVPrdAnirz!T3DzqMCpS&( z@3<~{lV?$>lHY^uM3<`b?c6=fgy-}WrLb?7?bluS*KTq*Pm_7O@{`p?k3?UuUhMg& zO|7=s=~Ux~D*ZU-vnOVHHL3P)=j8vmHFnqh68X?{wtb1`8T-R{d=DI4bBi(Ikg=8P zE+_kwb9m1M&Muz#bGPAoQ6=k>dF)@GZ_Q`8!!^0@X!REZ?W*FnT{ZVRCKP&_zT0U& z)zxWr*_PuASDyRe>o()mk}bFD;-35tIcjFQO0Z~4qmrJ{6zOAcOnwwZY&BVuKA+dL zXKt3b$eyx0(eDekX&;N!i@MmIG>w;k|B}-k4re;puBYEGb!J{JbFuSDk@tkJPj{nyC75T7J+ zpHtN~mfwy?u5QB%4SAL`;aPrL_5`P{(`l4XD{HBS;i@KZ$gempTjENnU|u(=l@&x+41RNkGO^(@(;I4eQL0NH}yc;U3OC? zPUgf(1wX_Lj1tQnOC*eg5-%18Jl$vNQn_H>H1AI~lfDO@3iv-yW@?pY_f^AEmS1^K z)sIrJH)@}dH3m$Yq_v{M(?z#St0UkyOrzZKGt4n*3f#v;87;W@@mTGr+-s^ zZ+B7tc72E1GJ78ut@DYe>{ll*_mfldS>^mK?adLM>DCrCvC4kiu2{ZLPBb&0)wpKU z<~vWf9j}<7xo9sd^UWpIt5!{(Qgr)3ri1d*dtUm@_4$g5J0^aAaW5(J^zr9KfrWkU z8{X@E)@^&jb5`v8*^4E%b%|TnI|a6eSMjW5+L!T$XIoiq)83UG467x+bzBO~nkgk~ zot^jeM1!%l%+iO!ZNKC@_AcYNko|ap+QP~!dK?q^nietpe4bi4ThlURC-bhn?gLu< zxu5@B+v|VwaQ|Mt`}OZ{Us^GleR*pCXGW%gvwWJ{b-ewAUWmVbb#D6etJ(W^=gaTc zzWhU2elqh1b(<-7z5>1sfITGwfSZ*tRZLIKsF6qWtQU*W{bOE4;DuDBZf( zwaRwUMT>Qf(+#Jb`@Le7<*YRsS&Lu0pX-;c+jFJKtD05vao(R3M?Z8_8hqF&pv);H zm_23ocaO+kyCrRbPM({jriflH4%djC8I~1b?6shZ@$Tu2{@o1D4CkIp7f+V+)@+&n zQ&eGvXir(D23x7)lT1T-Ya!j%OkuZ59qZs3bNco7@g(0aO$pbQ&YS3X*kSG=$%H!b zU5z(-q_e7PHDs(F>|$TIX^!;IiIsm|{1w)jZs#NR`FfYa*PkN{G!nG^rm^!+dOUCswYjt3Yj+wnU++__h-Mje@=^m~W#lD_r&p=URXOG=3p zCTUIe^~(;{IXivs#TP|~jvaoH^PVep?$PgAWgb^8qc4_}hn$~sD6nU)jeWh&{p$C# zH(mdBZ=#FSiy#qii?S&bpH&LzoLIQdxqeREkEfA;6)bP|*F`V;sBX1PUusMx90n_T5?~ zX8Y#qgvis^7NwOOXTHt%X+_X#cFk4xDmr{B+l{1yp2TDcRw#HYTwGPo+gwvU_O@e7WzJ~Tv>ddUP=4)EdX(Q%si(gdt=sQ){lbIYrneY> za^8PzVrhQ;aYlr<+E*#t<*#qOmAlE;=N!52^8a-yaq}O%S91P2%bM{*SbpB8-JMA{ zHh0KHdj9I^ow8cEfYZe5?)!5`FHR|{YWGht{-?)4ntIFWKJlT1{x-`#=#FQA<pDH$>Q9=6t>{`}Wj<^2_AQe0(|2*bJ+jiWJa59A6Cx*HUY``TQAAQ;L!8^E8*3#W zGnRJ7u?pF$3QatuaW$|-d0%_r^ZXSiJKx5g@U8BA1hnlJ0rhR49iE}wD%Klx>n-1}+h_Jht&86Kq~wQA z`1ZBc@yegC>T-VNd0MyC&0TX=Xi&oL{U_ZH6mNHosk-8|Y|Xcw?{(7W?<+6<6ZPvK zSBg{WkH^JI`~e1)TQ~BDyenh-`Szht2A}xZET_a{lV^wUZ`zhy5YLq;{`t}s4_zJn4F%$)u8_NQ+9ujWshpWin>8CM*ob80!G_QN*@-(RlD z*6(~=UXtJx|6%6r2iD%aqHOzpUbZ!UXMFqZCuar2l%CS|JRA9%Td#O7GDuD7?I@nQ zu&P}14(B7|&6o5&UbroAU$de^Be{9w#uxs_bM`SdcI(#qmLFQ}T=jnQg>;tob>j2+ zc@v$DB8_smxSLC+i$3w<+^KZLvpk8dGJE3YiCTu=_x@mJRaRc>@5}1QY8dtIzRV6C zBN6w?+_|5ZdHOxbT_aqYWSLvD%*4&~^Zl25eTzMFdtW4ZDxN(q8>x4B{@K?L^cPHG z`J9>2Huc8NiSPELguE{)OE`b@JLC0!tJhY~V~g{m1boYsj(JRS|1xiya_zEq#;^+c zMX?Tiw`;@_?0lwlw#9Cmywp#4Rm3kwPUrZ(0N&r8Z6+7i*!cC;ahiJDX=jydNUdBk zE24A0^}R`rMqaMMg&((gduzU$r@FoCN5k>Uky7U`9_X2HqHxze{p(-v#$LAjDLeC+ z{O=h84ff9#PWWH*_e1#Q_{tLz%-IgLfhnSTj_O-0Z|96+O!+`JCy{r>2Umd)sHs#^>x-Yk#SsfP? zE^amz7B4thlgb&Pzf&sWM%>!Q>mq$d9D#zRr()LnMTpBOu26F7OflALObst#K-}S{IcB|v3v-8)T z445U^+hZMHu!@!Kf}nYLmP(`XGxe7LSErr7mlU-)H(yvMujl9VO}n(`|9lhg|KE1v z!X>6pb}suIxS31EYT~+0rHA*fT&ba?{qN_z<@=p(F=S4BP;}3Em(~K2^T9Uz-g}Cq zb{$_jeXp;(@=U|GnC%*Z!NKB13&o z^2UlE8(w$UPZ9e#-A3W`-g}q%(>8~8x%4f$nU!)vP4VE=e-2B$q{RbwUj4egS8&0a zwq3=7(o%e9H*2x15Kt;Ev_9EpB_`I{J>g9Fj36od-ElI`@pIPPpVt#3Gt0(gNB-iI zf2MT=9qOo!eNZK9wx%Itg5o~c7Nu6fBQ`Tc`=v7XtbW?KLDR>Hf7EZ40kcgA(C`I5({`rA0DVMAN9$NHP6PM9!-?6@cW zf5*eH89P4Z)kNt&)Z~>}HTUj%Wut>Ffjakd?)1!995r#yq>i3BR=O*_FKnKqJM&(~ z<*#QApFc~wS$xs?`fl~E9aA>Q-3bvZ(dC@K_e9yw0)|;K3qre-e?&F(zm>|Aoz=o; z+EOBH6);0_-E?V-CA0p0I1zi~Y?J@0iKi~vWO6NVeYxNaF z&2~-eUdB93SlV`B^GnaV>ThpM7Ml0>c--O_%w8fK?&xv+iv?Gm{fWLZ-qIpDk-GQ4 zK2I!mT%Nyor~i}n$|>hc+-|8KW%|5wrNEA_$MhR?Hd!joiOuhN+ShCRy*l{aVvFk+ zj_neeKUY9gZ7J{SuB6H99?m)^yhVoZKy+Z{!#4+{4qpF0|8pOghFjhXldSZhEotwJ zPR(fUe&bM{p%mKuA$r4;8^I-xZCAJi*XW;lb$#ESdp1ALuDty~{{9S^2K!}&-+T9e zIagQzx&IR5ubT$1Lg!t5|0W>d#dMVeTsy6<{pqey*MIhM+KH={ngwUr50Sa=@qeVzp16S%fvOm#fYHc`N0MB9F4o3X|}t6Ef_Jp7C=}E$t1PCO%s+s@VS? zpIGm=?oSQ-9na>sW;Cg6=wM!QUV1ifm36UM+s=gSg?Jsm)FU(SYpuw_O(SQ1Zmw~c1FV7wjvurhzh-hA^yMJ}x?FGx8sRr6< z&r{?0roDR80e>w?rFDwBk4|;`uz4Z5McL(qw&i#^>%XZAi9qr?df(9<^t_p`T5VVKAGOiiLFA$?w`#nPJ=e&;`Uum1Y?Bm^sbLF@B^%HBS8E;xr8DTBi^+9c0nbCz*ot(** zhwU$4`1IXrQmCi-to3j2uGT+tdftgw>ryga2;Jb5cphe@aJjmxMAwlsvr)HzTXQqx zH4U>SjcuC`AB}v`>-u6Y>q6G3`$n&}9%eU4$b267>)(|3i%&&tFj~A;mf;|uth!3% z+|3=X{O2Zq@Z#Lqe0*v6*Iic%7ff_%x%91V(Ti;B+5FXdHy>@(@$76BVn5Etc07C8 z$A3oWt*exdY`mi*yLSfv^@ZzgANox{r|Wk9ChwYqkAKRxgj_ukaPgeAu$eOZ1}Ak# z(=3%~rIx3zdiC5hQNFXVlO|2{rBNfMqSgvyAj*Dm=E8~dOLI0?dbvRPklE8CFfl* zzkQ?WKZA1Q0Y;{e7k|6B z3HokW6ubLet7nGtRPnbqh9+(2PsF94=lL&g&E2-;;DtA@Uw@7N5pC34|J+cK;eTK9 z#;VWSXaBvre(UYoMI1V>XRhV{?Djy6FRdZHY(Z>u#*&^JK~Ie?R@dq8TiY#meS=$>EkIJGIwLyLEcSqjOo4Z|~U|`YBAC zx56lb-LzlpfwSet(^EgF)GvS1#n#-_%jnA< zDe8s0XXZ^SxF%Az?wR`)_7m*)3+6oIxX96PxbcJuW9#g+6^qXuH#!$%RqeH|C1#b7 zL^AV=@?}T-ck3%yr~SBl;d?{+WXrkvI!~27d^6*zMx*}xm`yYz#1^M~=c- z!wah>tuyayIxDM?5ggSLmEyhJwzCo~HFu;^E^?mM<0i!#!6B?`gGK zBt6}_+;2hk`*0Dhxu=zd?mW8C&zQ+F`A2DbvBv+)@2~#($F*{^gh#~Ovw6a)PPZDC z1o?(;Fn%)cygA>69q}wzzFabW@qB{Hixh{Ge0&`PxE{ z42t&T9Nj#7#TmEr2kIBk5?Q+Dy7tYtGlF=`%I$2fE`9E3Yu{G2T+8lKruwG?B5ki_ zZru7jMMdn+G#Pcf$TP|Ew!Q*KT^HVXukh?S_ZFjfli0&*R<6rm`uES1?Wt1#uYm?{ zW!t3wv+&o2dd4Qqu0A3#_iEM?r8jw}c4z(DX09w@-TtQJLWYA`aD@47&C7PP3_1?p z&AFJJ>MM3NeWBpTn&MM;Lzi;?uk4$2uC+Y&vI&Ed_37EyHQz3u*6$L$r~G#PdVQVmr#3mP4tDz@d?xYXOMa%L%va6-0(Y1l`l6#`AYm`u znX}6+Qy^>Q>-%d(4bzf3A_~?pb%psdbT86b~=}OU> ze(SpY_H0^V)#nmk!Rb8Zed#yXOs}H3vB@TW%r$doyr0jkix~%jZPhmIasQzc9WL~TG zq0{x;yhj4vCDGAOnY&!m4|)AI_1d44u#>S{P6#66kZ@raJWeG%2c(<0@R_1W{v_)DFxR`E|*lB(5Me(QEAPpqJ^wN+1T*0P30+|rSn z;imQn?=0TVQj{0_TCjcRiVLpHulS*5BFbW^s5RVda%ao&un}9&#`;X-LK}XSl{9J zFVf{xaLB(-CGmsLg089@Jr$P773`I;Z4ayA>a0TVvfJtYQ_`2?l zRvxtR_#sj=-PeM?(?H_YnL)!DJ%?iU1zJRbN&WzfsdGo^XCtO#tY@#yC)@0 z`t@U{*2);k)%H8~7$>UEiH|VfRrmH@v6s%CKYQl18pPji%sVNUx^>d?1988OM%IRZ z6BhcAZ`$PZxZg%>_4fUfls2w!+BvH?Z#rMY?GGKZX9pK<#HN6vAgd$4 z=5(uytho38^fZp+gr zzwDp6QkJ_pUea{sts7Zi(~7jZN_gLUUbaqea8WJ!e6_^wdQ_KE*Yg1Gk~-tEZ3aw= zZ?1P6cZM>q-F)~wYgALINy^Fi^Ue33c`si7Rn75at>W|P%V&BwtY8w9jQnCT$L5yq z%4HJ0wP!s7>@O>2x+^7}dHzaZVQY?-EMrGm#^d`5--X58p2)3D%{eGl>00scR{f9t zQG+ztMmU4V9E-Duo>{Xk0`ITU>TJy5!B_$Oa*Uf#6 zcJR*Gz>_QFkIg@_J+WX|L_4X%+`Q;1u<=o40d!eBHaYOmDz1t6$J@wxGt!b`_b>Pg~ zZ$HSMTFqFy%;A*V^G!GRpSXVb>q`9_QS9prI++?yZdeR_3Qipm#0eAF9|$p^3NlAW5sW6L+Sdh#!Gk1$((AIr@byO zz4F-_k?<$1y;o=RWu7%X{&(rqZEP#vJ^Hh|sPg06E!<`e-Mcetw;k=R?_Z(ZenzW& z^~A~386UaayLC*GFOTQSUA;370+9iat>=qwvYU6ZYGu^ZlMVXe4P7_+Oa!#}-kpfp zEMm=KRB}JMPi9rZ`NDv;<}YV`{56$_y?^y8(?2`iKiR(Cp(vNUX|=3NCmXBL`QB9u z-DMtMe!Xz&o#fVBIDfICV1G~0x@yl$shuaHjMm7eDk^?vwbIzX^3JMH3Lz(!zy0xt zW2U=;;N0!^x5^kF;4=Ru_wt!ZtNfOOpLTo-I>Po?an1Sb&HJx>@!Hk)zUKMuAhnEN z9~ACp+b192^MY}o>!lf4-|eRTVEz%&pSggmNuSXtIwEDxv4;y+Ipj@dey}vDY{fJk z*QLo4JS{U1YD&#H#}sH86=eQgvao~g{i=mJ4jY7@y%zo0z9t{-E<*r*<95 zKX_w%=JB(a9_8)w-nr9iYro2#^(iZgHcl+7?t6b*X79|na^>Hr)4xq+{d9M(+0U0z z%{(^+d)V`IUtisLXJ4&O`|gp=bPpCI)ryuEE6#}clO;RqjibXdO7}V z(CaD>*Ev)Wb8bq&)OSm7&VRh1#xneVdPlLrr894}ycYDaEjnk=TqQZLf77E@gFWZ6 zITKa7O>(23{z_l{#9^uPiX)cn%nPhD%tR{Xyd}!F1Z+Dm^=x*a`u zd}gq=UwRVLV~tQjkw=F4I&P03JYt@sCq5-j{jW0WpvPnbT)5S<#R1j zp1Z2F6k0_-&+D|k*d_DRYSNRw_FTEU?5`>^{?^XF9rb(RBR`YH|2A!SweZf-e71=A z^D<4nQfg_(>sMh;>k48-(n5Fh^$^=f@uh zo^2FawYpD%M!EqGt%T2tk?Evcy;U8BKC)+uMZ|&OcL`hvTk{P zMC#wZ*PmLeSYB=GxY(;Gopt51Vu#$bst@WOMH?%OC4V_f@OPZOq12d!ba>kT-TTBIwpS`2 zUg|IvCqG`g$Y{!5Mf?6)zokFk`d@RFZ?X8QoXY5Fns+a66F1s$QdU!_b7rmmp84l* zDZHuqaC$=E$1Ks8y(Vsl7k+nC&vGbJxx%(}{nLlh_PY6dKW0{bc@f(Z`g)<@D?_%ekrQqaP(Qx z?`s?Pe0*S9`F5){=dbX40nFd*=d$*Hs5XALGtcdicYU$oqQ(!i>YwRVh*$@|_>)%K zC*!jtB5eM5mJ8}jmTY?#(P4Xf(p0Ni$KI5^%lkd=$D^WuZeF#1y)FNa_b6QcAurSL z*ZI$?lxw+}7u&C1DZkh>L9YE-PN~XoX|ClT3bw6qKcwOGrs&C`x7jRvzpSt9I=661 z*rAim$JP73yJzbueUBsj z<$?EAUB`IZ&04c;qS%*R{FcF8Rl0KL-YIwQ0wT-`N1d8bMlhDJAc?B zo%_MSWo7{XlZDUP7j&(ea_yXm@s0eqI-iAhH?e#BJ4+neQFQ28&{7v&eZPeZ6E03U zvEbSBpsj(&da|ta43*VY_C$uV^6Yw6=Ktg@dwt};>-+yy{`?TA|Nnjc7yp#eYH0}SC^A?MBTYEllxY$zk;a||{H`7jpJ7)^` z_O6j$V!4s^#v}fet-G|-#qSIG?iblSr7QCs``N!TH~Z$@Tye(x6W@d4XEhfdFo!Zb z|J6`*2U~I)lsqd+O4sb6!?`GnWsVusUK^-Ts7p(Tr7_J?(d&;Ol$# z_N&yhZcD9(YuT!grf#~qCMBYz>G#F&lVjfSoqo{r^7OWoj1_-=SpIuc_C$^6uZ9bo zx%r6;-bm45Hil>_1O_WzI9hcEkh-&&3D!2bglJAP09A6ESJ%W4~q+bnzaJ#9SM z44n3Qn+xsz`t*~;(uQhP#;V?Zj*(y1ZPzTXZM7-SYs`Ek>2gp>N%z}Yf9|Sf1r?`G zsxQ8$>blzFL-jhxL#J4QP=i<>WGZkgGH@aVdA^)GO2G+Pfv(y0QGIqFnFQI^U4vvwpvLUiIbt@7FEAKFzh9Tvp+H zcpm#6sa#*ilC_fFFH8dB%KBbi{IvA>#{9B|D$$9JjxTNZ?>$@{nd{(u^!#P7ZYk4G zYrH%>I?VhoT{3?1EMH;9lfXTnG*8{+isE|nM4~vW4`4rERqA=3t0lnKa_Pz)H~%t(-%=`FQ29gF#8hC0v&~DlO$HNO zKSfkM}xo$(9nR(OQy{(ifZM^?o93}@u;YsU{?)}N^(aidZ{ z_I=X2KE|K6?#JCvYDP3?tn{1ssV3?J+pL}>-Aj>QuSKsveLLTN!s+h4H9sB(SAKcO z{z%lIWbzHsi5GS+3%sGv;N;V~GF;=LIa~Lo;~k95YE#Nrom!F^@WN)x+^M#+n;XAA zxE;Gg&Z>6V!mV}u)y1E(cl~^Mb5G$X%boY)>PqWBh~Kl_`{Vh3#mhg;`%W_ccrSVU z`~AupX0O+qTDYt+@eI+`cV%sT`QY($S^l-Nn)Lpbrni@#aa$I#Y=xiV>S>1zI;L$k z3^=`ME6>)(fGfe@+&JxKZC*QdfxHB(d-l79_q&SbOFubT)!QU=&;vEKJNM+Yn1;|FlIxIB~K3f+-4bj z_P5>!%vJ_1JM#|S?%4FTN?D_ou8hb1ab)wYm zs;wg5iG98ox#X^-%F3;0dj%$Hs;*vXXs>9Zp~tz#t+;c=cHfLr418#F$K)AUQ>L?bEnT%-**jX2fd0Sg)7N zuGTeq{htCG%Xd?T;>8_die9v}x&5uWkb~?E+_+OW#aIww^JPd^IP# z%|!QN&*H_0pZr-9Ab2r4wN=T<-2B>wV*zY2>Je|UrmS(CxR!frZ7M&bRoX#;_M~NN zGuJNP!*;{rjEtJzicE&XR}_veHNU+4dGM@a_vRCS@_RT_GcWC#>XRv&$h!5c-LmSe ztzCyinbJ+7DrotlNhRl5Z|kt{G@7!^#NFct>*aZ=if;lNiz2UvOjzhF zw|=eQ`poD1R{0t?i^`Y3+c){!gXGM0=PS+~nfPFeCnLYj%tP1ynAsnmagnDytyXbb zf!g|Y@h6^MooaLW{{J6>b=%`~pIBHjuiyJ^noN#X^)^Lo$tm*hf@gh@yLO=2JnyuB z-KR#Ie;;N}V7uAdQ^h!?saEUAyp4AITCy~D2HNl@+;us7QDefZs0AVtpVze{PgdmX z6Y2Ui0|6eRmZhY}OK6-uquk!Wl{#`Xsk@|lN zv~7UbS^D>qzu%%Wm2G;>q3et~~7VT+<7OKQt5-^B2yz_UUR?$z<{W4-VGuod2m}_G4>{19?I< zGEMneZkwwzVq@b@JzjqDgMBqyg#GikNi%!Z60D65zKES&c*%Di%ORYU`z^PGswMT%=fF z{pRKE?fg%lJn_i8YxSh+?cOt2tWs}DZo2#K$=>gF6V&_X^Zr}MQXF*R=0{UE#U+C3 z?oR*ogPGJG_M`_ri#~X-_nf)G^Me!iSXuV)zyB{9xy0dd^!vZz4$NP4oLbv16wcK5 zdttD=|K{8Id#%_1{{Q34m)Y-6nf$X(R$}}o?G`9oYrA%PyJfsaPtRgGKHFZ&nl}z+ ztEHbTysN|iB5I-c>i4~}SNE$p-&S^PZ3MKX&Vu;^rx3YkJ|&Ml7Mp&hJrUYsCTz5Fx6N(ky%D7_>DJ5 zyVH>~r^VT3SN)vuQCx|aeQATc?CmcGjOgfNyaIq+=XGkB|a81sb1f()>1Xj%z8;z zmHtzqN%0%|tlkG?c(^8H->5w0y7n6Tib*%LFYigZslNNRKvVY6lm6lVji-p{#N(OF9HeI7CdF_(7 z;+(bG>y0)Qx9jfL>y$|viu z&$s8_^?JD>x`1i@y6@j=>!!J!v{C=f7q_mk;?vD%{|y%{@0mTXF!qUv(z3=$4`!MD zx*|Q_`{mi~PuT5$rB%H$f3su7=NJLO#cCZd7ajSwBlov{-Zl3B>)(DW(Y{=f>BDhg zf7+GP+v`nruf!*M-CVFvXGxOjzQkAb4m^pd)VR{T zaQj)a4R`Ju7P#e4IlNf;=aJ*~(-!QRT2UD*zc*XPiv9HD^yfvhimslYzb`#tX3Fu! zTKSnbW*5y!KXhl|Gdq5Tf5FQREyZYMu=e?r2J&B(lyzY3W@^@P8*_9Q?PJ|S1Imov=%u*uk zljy?G`&~~(&rJAWuEBg|*2BNXOH3|!XdcUHvDN3CH2r$?->s5Z`Y33P0mCW5fG4VLbCf=6^qtF4pIJC>{R#v2(^JI$)-2;@Eb&l2 zV0O1Uw&?7evgIZFdbawTx=w7|V)3WkZvMl4-%g2k=uFq%6Jiu)==s6u?5TU%bKe(>CmDy1L+=Vp*KIXGnd$9i@yB0^-1UM4?-)8(|*rhx%X<8CV$+1-SYSMo>d9vRM!UM_`RW$m zR)0P!c)Gl#c&5|M3%RHHV{Z%Oy;xlO`Ow3Mx{YfehhI-!{5~sfUGlr12VOm%{ITgq0wjh0{<1O-nyHed-d4&q`=dN7mx4p&5u0tXHJu=xF(Yadt$#ATd4Jw z5a%4c1%&MTK2JBd1B9(M-LuvijY68b@u!|%Vs^6Yn+!# z&8K~Or4y?d^WRNptyuexTwTYIleue{vyG039d(HgTRr*9w4wl3-|HJA=FV95KOjzh z=SDx)wQNcjVK)VjRokQ;zvTOmp{Dfacdp92Q-bvQ4lay1GhKlzZq9xOtyd=}i$CaF zVb<_&V&i>*k9XePv1~AU@$_ist@R~MKW0v?EkDTDFS+*NuP}CxN=;jrbtm#0H%wf{ zv(}z<{`&&)2>+KpcejeG@VmV)%Cyn?bNecncSv|kI>w?cs-yt`=P5w&%xz zY^kdWrH5@Uw#+_aeQRc;-|Vo5|F++&ncG`equdy1@BZ$?-}!r{FZkzvg8TliS{|2$ zci*?2eUT`g5_57vZKuw1gIe{U4VRo5&*T~u_kQhW-oIJH-u35< zn72*hR9}gnhlKN!Yr(DlmsNhRbN7q6V0-pqj{ROMuQO3MXDnj8b!M6HHy;Ha?Xn$~ zQ*u;vFNZsPmRZ0!Wuj`#-U(ixubrLBqw1}av(i~`@%I_qe-)bYMHxillkWJLoL4NQD0nM z?2~t`j9GlER-j4GqULHQ=gox|zAtv1?DTiHph&dthp4r2A74#Adv+@{&VA*Y z?|Ify|6R^|DGDv=sdlv5biR5{={LEx;y&Cn_Z?`+iA*xipT_q*K(OPPNNRGnfrHA6 z-S_`aTr+L?r(1ukKmGd4oE6Pt6{5Aa@bx#xA}Kpv`(GFRCmsH9r>AK8#dR|lS2-U_ z>J*W_T-4?e`61XPop;JL-(vHkrm6+bwK;$1Od!OB_tjkSOYJ|V9{rg9 z|6ti8<|l@V42uJ=uCKNIcK!S9DX;J3>aYEF=Z#xJ%F<)e{6~*IlbC2Oome8dq}5Qf z@BX!!1Yy?36%kHeFHf0{Y}*OEPT@8wGF9o|u*S^I*$ zzfNiY|KIngiR;HHT)L3EB}R3*f@FQ~o$f~sT-CGqedP9dE%+w;`swr6)fy)+zYtxv zY(bmDL?wgVHs!<&*VjkZ@K~=tc#$_uCzowy7rUX#>ZSv+tWt{STa8j5{QN1>znUed z%jVS2rZxeVC9?gybnHS-DbxvV)(zaz|29F=G&Q-SGxf-d>#^rK*x!HGeGoq_KT38> zopV>g);Re#Atej#>P2<(jBDpTJhSrfLW9MfB2$mDIXV6^{##>kL{@W?f8y~Ydo3MQ z^-V)=MhGu7ELtpVdo=&@s|&nrrVJ5I=S=%8lmgEPzJ6;uWx~@*5C3Ryxm~6@aiN8U zO4qgmTW>!_hy8YIr~Z7kb&E)rl5@t})7v$j7|wDkxXlr_;$*5!uH@wU#>G&aqm#s1 zu4?=L<{K6dKmMB$a}R&neAU)MxXWRU`S*!>i#UQiyM(`p7bwnLBW>ShQoSsKkN>{c z{e!=%Huy82e(+_k`|?tUp||ABI+r3RB; z+n&MOO`kUYm=J4y+RrIQ& zuIyA@Ru-{n*TSa8_dPOas&6#kP;V=m;+mV?!XY5bU;gIq#BUo8pHsCssS=cBra9ou*!Jmyvi!~AELWKCZjYR=FIF5l$i@_5?(zc2kabNbsaQTSrLWy|y3_pA9? z_S^mMyYN11XPeBW8R z?heUTD^Kk%^JgDlOD9A+UE$kp)x3YpVTXbhi%)vozUlaCsRz@Jn{)X;Uhz0lX>0gr z=6dmK^V)k%B5L=_ZP_gO%q{d>(?pY(COm;NL%on|+IT)(4uu zt<3$KW3aSX4c-9mkcY&qy7)0}6RznyYTF5*9g`F#Xh=iFV2Yiib}sC2cxkV$rWw_OsW^l|^*9@;~ogY0P_3ioRYRt9X-~l!8$4`fmjc zcV3FEQ`deN`drxUj&wq*vWBD~*D}2qOHMJpJ#1~EAXU2fdfWDfI?em%zGq9hTS}T= zH?Ncxow?kJ>G|gL<(il5r{3P)cjMlz_qKcezMozzJk`)|bBXPy&Cd!f7CqH;{ieLp zR#$m5->3D{nW7R}CWXIa&$)TA`bERkZDqc`Mi$dm_doi#PhYI|^Pl-AOw`yNjwgM- zslRN;_v`QP{M&M8$%*+wvw9`#+qLgrUb3xrcYe=@L(Wm+FJb~2RV5vrV~#sGozD3g zcztum&+;iJ6PVG;bE|i%-RzC8qc)p!Cic(xd@$Gc+Q+jwb(<|C7KKIeZ(99Y+tSv$)oRi9 zXQj_9Pwg}E@l;;9oqEg8Er!CN%;JKTEqFS}mRb>4esufAof4+YHUN}SKVWhkzz zuBD^6_ttf-~wcK?8p>8UqyhbOMpetPcB#%+gRWNq0Uy))vlphj?u@1iFK`L%D>&Pto| zYJ!-X_Zla*Pung$xsiB2c6P+nxR+{@6{0(L-n%zrvz>!^d=f3VxXT8Kzu#Y)+rMX1dt3oWryJf1AaVC_XE3y7j6>E5EO@{H2qmbZ~*U zmDs@>kLUkAL#I)5Suc)2l z?`8|7qQk%T25jy=W6ajXeEAZn>tj39aGQQGi#%j1qzkW9iLDQOwr5iA*L`n{Z{H1;lwzHEBP5}7uER?| z!6xfXcjqmAzi+lo!&aHRMR!b2#(J{-f3>VVcwrUmFN@caMM6R^OlE&As+&1s((DwQ z+s6(53Dj#z@@ju#Z(jOKepmgM&aKmZQkVX0^z&F^AkZ7dUzvX}>}8Qjx8+%n#LTk` zW}IJl!63W;dJ*fl2k{|SZ7biNi=W0nzb6VG zd-mD>f~sG=!9O|r`)!yCD*hP9ubkekpBb|8eyroIP;ryU^I_(ETP?J;4?ik3+g<0R zzpf_qytz|gUAxh5MUAj$m9A^cUG6l_Vp!4Ze!)S%dftLp^Z)Oh?};2Rk31n&f$_;er49TKXf)c zew*jJ*`dj`EoEaj&qU6NUZ=ONezZ{Nq)F@qKG(P3j=#>%xwqrs*MJLAzjWkO_Ezk( zvuZqk>;JdCoL5-3EqxkWanHJk&sgyOlXb_}pIT?U0;aNU8J`pS=E`$k+j!pg zkw9DJQT5rI7q?q@>HV(Vmp{$=7vt-KWX8quSJn6Etx=ztc)D`#CS{?2vFEbHKk{YG zyIg+U_wyyLm&Wt&c*#7y78>Qp1kHg^@HQ56qD%N$c0sly{jLpyj^LXng9E>*o99&N=~)y`FG7}UAg9^ zyKgVsX0FVbFnO`Ycm5_D|9>aHZgu;=tACx&b-#A0bmlqMuOe35l1uz58z9iTK=jx9 zg`y9vB-Om%boEcuI;AmNIK#JtyKSG{gqUg5)3pyA+_kGt|LjB6XVH%g>Rl6GPSMbK z&id#=+|4Lixr}FmsVWVsOJb(WPGxMKeI_xF^Wf!`r)&9?7JgUv*Wb9_H1}oi+An)I zSN2Xh&@CS2_^|GL$MT7nLs?z6Yiud&%ziUhXU^`fS;edBxm9)reK_$|x$VF)L8gfl zCpnc#{CZq_Tj$re#dEoScvv%>`jvm{t$o1UT;2GChZu@?HjAIPi7}R#I%l$xgxT|` zNNKrKtO6uFd`P zPrfF8o_+l^o?C`Jy;g#!4@YahE%5$kKHZ{2p!CI6$1SPamh*VlNZy-s$NRni#asV` zjx4U6YnElYc~_NG>N3?73zdo|pBG3@J^L|T^OP@p;Z_SH-g^C?TnT>XuBpGQezwBp z!?Yb-j}^D~`DOKda#~ZgEj+&GE`54nswJ`gn4y8AuoPSKzqbipb?YBac<*?x zf=z!ZJIkpPMN^->x%RfY!E&q4g}F@`F?{D!cRBP4FI`b`P1vtAC~4Qfo3EznOe+uS z3R@T}w@9lZxZ#P5X2i6vpN--d=auc;$^S^U-drX^v3|R^+~pZ!Y9)&&_Pfn~<+HMB z;izEa6+^ZZJ0-u&JmiRqC`>(8dUw=K&loUbxt z?qP$Uvlh;MXnH}=+Cgf;+jB*)&b+>TJo46r#U}eM*H853OlG-t;qAHLFZHKh2S>=P zU0!)+HPeFlol=wT{530-gNJ5#O#oKM*AJ>;1Xi zCTxp5Tjy#=PCoc;`;D&^Kl2LM^_;)CZJ2s#&WSx!Hf~@2zW0-89BUWuRjx%U2>+0Xl*C|lWG;&TX;t+!p<_V~`6 z<86zRM3xtR>@sqfnwg^-cUCI@lfAoV-krpZ8m3d(b1Fo2+7z0LBRjYk9f?S3ezB6$yF8|mr;WPWW@vWNUdyH5vn)munUN7BpQKqA4UDugpg^xZ9t3!pS$n<}lcjxAp zttxFy3ruvQtW+$FL{fD`oR{abNzAhqxAImu6n(a;!b>gm;;hrBo&5aLKArT}OWnIF zWpiIq&74L5CV%;S*vZbO_fwn^``LT<*pE+nx@*?H>{-T3Hg{=FxO~ZU+AYnamNIqG zNt&uQ=I)wvK4i9?nO+w;rSiOJBBKc3RLh8#Wl<}R*8jc0+#tMsMM!6t%|TydoOB?>;?YE(+_4*Z5{LjlK0^P5tk< z7YnQvoK8OfxA`RF58j_0ef?{g1J>XFRdj1Z{I#PY=T_>lul;o+dP`#IvWrT->Fvv# zk5%XL@6@SUd`dB)&i}qdk%@D%TE_2Azb0ANh^ES`>+jl5od4_2`2~V*-M;aPo1#m; zKhgiQ^!&-U*7DOYr)$3qUz>CO{&7a$xGY?JUxu_Uw`3#)^=4f z=<1;&&L%NFj^00kpUQikSFH=puhkb9*AMdh;WQ)aV^^c1!lUzRZuWjy@Zl7bRpY+g zH#?P;?sLuFw1f*$(R}c6eJO8az_MDd zXU0>ycP96}CE;DHL3M5j?YZ4#R{Ox7P9~E|qkP@lj+pdnD8QV^Z*e^mpq|S$m)G z_ndh5lh}0wmPLQ|F0H+O=2@)w$EG>+rhR(XKiSdC>|McRJI7G=$;w;(SMHX#xs=y0 z_;0h@devXfOKhswPkgC)QOfo9mV*;Cs~54p{Uf(UZq9|DLA#UpPP4eP(fxO;;Oh;C zyPVIhoz`7u9^wB?w}_2v**TAA%1z2@6)wjw^HwTGo{QYWW6qPU!RIFS`PDDZd0uDE zFJs<$P0cc%nMp+XPGyu&K3^|M&TIHTC z%whlBUs=r8bi?>T`VO@N6O{Xu*d{j1MO@8rTs8N3(z@F8x)@ol(is7Z=X*cSlKS#u zzVVcG7eDkXEuX%`)p!4#h?Np#mZ&%cbf9pQPo!a=xIMU1Q zqSD4^rakYJds;Rf*zK|Sc=~~#FDE??WWAntVdl-5LQnlRUA#J9`ul?5bTboy#8&~i zhL4zCvMo$+-^l&;^WF=QorZ?aZFx0i^IyrlZoDnoC35VL%i)}~DOwX)<5y1Zt&P}h zyY8;EbTH>n1|c1<-hyuh^%)mJBs30ICMo#UR#>TKFOW^0%TpKCy}hp_x4>=7jAx#w z#NMnE-NDtdZTB-t*(VuKu50{^?6})4HUIYU{Tw07Z|*lRIkfnE#`VM%lg`#NPI}Q* z%`Cq1byELz}a3rE4xb`#xZv>&6-POY^6t@%_33m2GxS@2eMi?%LLNh39%% zw5+{_+IOYmwzKWH0)Vce}Dee!a zY>!gS!-TKb?%&UouYIzG(QXo`ivIU@i_g9mo82NW7V4cizuPEoqNSGe^NsiF=GEP} z^yBx!=yMVemHc`0uc)NDFO5&R7QSMp>ybHP_p;0LPpaGfE9|@(a9N}7J-huh_xJYx z7qcdRdhz|~$Iq>Qezd(+3r_JS+lX$u(wL7bK$o~thkjQw?@I~mv%^G##hJcnc6HBY;Ffut=afZ&7^Vf)4y3Z9viYh z9X6i7FivPz?+i`Fsts{dD%EU0l{LS)xMp{l^Sn84=XDpQ)jkwGIiqvB^VAF1*H3tr zD4F6P%hJKc`On)u+u%r#hqc?3Mz?syh>bG44*%FD%y#v-hr7cZl@;>*Pr3r?LS;Yg z@~Ln;lUZ1(c&qc$DjOc|j=KrbIeBwhOzRfS`E*KVtK}Tiw7{Ol3TYow4LatnbCl<7 zp7*&8WzD5s){6cSS`gAPYF>mRe`sFiMZJC}HwPw<{Z#R88>*iZcV)Q%8 z`%EO1;nBZjiM#&#=C}D%*YEn`%5KN>y<&d$Rdx~8lrKwNUadIoc6M%D8N-@S#uq%B zeDuHk(a(LwRq6T1-J@^z)vgyI52jU|I&)oVD#P7?Z)N)`t%Bd&zcsOlwfUW_M{R#7 zXJX5*RR55PXUmzQ-hZo|Jzu+dM%ON$m;cY{>p8@P-EDLH?HJVcAfSx%VREsNq^^kf z!o=M_=Shd@xt_Vh`T4F{k${^^xc#CwQ_GND1$PzaZo9Gl?z-%GHNJL9$|u}&bj0S@ z-ZUL?V_J0`e9=QMi9{%1=_>-DDVf?RrS8TS{rKiq3F>6dK4&+aM@tC-~-C%M?)zk9ax?5hdp z`WNoseYo@9r*qAIe-9Y+D=$_NyU4@tFqO~f@ANVTmWAh6sTP^f5)z|O>=|$&j5D6#Sy9}_WJhC zS{D81YtM_Dei5@TGB8fCRCpFytF!s$Yzvq2-~5*ne_HHamTDrqGPA$g{_f$VLiwwr zUOCJ?hjyH}mMXwb7$T5jzrflb%jWp?e<-l;g@N$Cc=iV1fAeP-Qljjiq9xybt5hpM6-}j#QhJDecE1Pe|>g;}d)_>Dx-{!NXUjA2P7@QfB{Wx7E ztu>sLHT)$flwX|fY_B6*Zp9tFe&4q{4-NVJb$C|3T=2{MoJ{5y``P!WEwgP+o;*>z zc-55!<%?(iQDEL#cE{S`KKpT1>7Yq7U;orq2%J?{+5Suv+Bvt&gP_Z`c0XuXwO;%PYofNvkuRB)@HVm)^08P`;F6I2Nd^Ax;;^JO{PIaw2W-*=T|E}XPC$e@<@UQ z*An>*Kga6H%4-@0UIx5XkYLidt)%+z0-yfr+FkmD+ zQ>6t0WsV)=c>G_kwpo$>RQNpA@{VC2cQ#)Asn<+vtotD4*L=EmmtM+5An zRC|=8?A;4)9{&4ut8h*3O`asDQ#mZf%!V)759d`!i3&xQ-DJMFq&WAtPL#rerPZv9 zpWoSNFh9JkciO#+*RC9QcP}d5EXv<9!9F~WarGTGsJYuZ((JIb*@qhLii4B*uF?cChy6YFHW=CxYiuB5YAxlTd;Kd&TpSL9iP>-VDdcvFr}_-*Da2l z_^#fik$LWw)T()rKMkx^mGrIWZ_@bvNqM=zkBLPLCg0~5IqZ*H=DN|N^1p4!VIA}N z%E8&?T70wn6x?~rwsBu`>{reCC2pIOUAR#EP^GiVxk+fh>pDoO9aSck=fTod8U6;!ZV@*h)>b_UV7e2$vd8o^U%ln# z*|WXee!g47|IY0cADhdUN4h!8tZ4y#+qPFs6O$71fzM>j=u8_%&*Q zVg5_zwTaIk_d0Jd);jqqg!9zxHB+>2edSxpG%fsTnw`|z6;87kx^4a{dq-``9S1g_ zpFfNIj&5J!^~eT&U#!_({=>v_ zY0je~TjL@`x=V!&glGw$I4fGJ-nEux_a02??El{=I)#JUz1bNd{m#W?c4QZ{iR9! zytW6byVow{OO8K1nZKT=cS7@F=b6{F*lSy-@a(_Fv1wwH{i78zYFj_r?Qsb`77$b> z5L3|El+Y)T@%>nXNhtqPxA#X4&hW}MKm8@KGgqkU7u2ZPSr9bG2ZJvU%qSFQNs&-uc`xrn>_+M>zO;f z&&xcWe8FkQnfJ1{rdMBW_Up7wO_{fyhoek)Yv(p$^G56+SM9o5*J*5n<8yBSLNXffeYtr-Yv{AJAT39 z`Sov~n#=2T`sdqh?(l5cu(x3IE2nw-J+e7YdMlXaLN**ZnR3lEpnh9iranXJqw4Dx zXBq^qE(mTq7oEZPs4}f~{nse|J>_d3x~eSwnbsW<;=k8?@sdE#rEkpyLpIF2o9@kP z-`Zcsx4CfN5`zazH!r^Jbx+`6$OOK)Gw+#y3VcjcpBwP|jz`1Gxb^GLJ$&L)xTUo( zAXLt&eQs)^O-ShNJr0}~n%YBpc20Llo8jL7YV8Y+4n>aQXeJj=j|in*4=zrbKe@T- z-UFXaDeIg)l`l&;?z!J$_j&f~ook->{+zzQTJiqxi{>f!_cd(ED``<&{g^d7NTf(* zN&WhCbtkp5$^51^PG?Ux^SoH1zOMIakhbcL=%&Ecw&BWa7cLZ5Dc?P@QTBhn$<`fA zm1S$E>+5t~J-=Fk?Wu=AV%#V8yc?U9F1-v;l$SYow~R$}cA{a^s>KoVnY3y=$3r{g>_jXc(MoW%F}2Sq{Os z8^op7-hAWNb>-f)*LQzU@_y~+Hi5&z+ zt^0mImi~FNeLtu_aq0ZIAA6QcyQcqnvtW^LBOlAs&d5{jho(7yo0fe2+|+^tKK=K+ zS;IBC@~)m(DE+|U)ng&~lvTF=r|(Q~+?Ci7H?^E$lf=A0!yk)TIoHq7pM5#QZ$kI| z1Ajw8T~*I4^4Wa;`^gvATBf-@&D~i3Gkl%O+LVXspKPb>i+xmGI`5@QPQst5yBDbD z{APKaUw-|<_i)jJc5BZzFLti{_vg6N(f!gPmrJVLN^+Xko{(F=Xz4O%HD)(wD;&_tFZRo2b=&DB&oWNF`TEtb&2OpT^ERcR?yI^N zi()?U)YO*k%w8p1p(6hLgYvV@UjM6e=d$thU;p_h=y>7I8H&8Gf}WnLyi~eK)GkV@ zV++TH&C*#JGo%)zJTZwX_3zxGc&ga;!s+W1?<(H^XtX5zQTp$%5ARR!_t<`*zlT|% zOXP3+J6VnwOEL;7OWbF@ox0d+i?Dms6^>i78Fz4I3wvz0uUXeV(}bD$_--TgHZoiYXVa~#D zM%%4Y3|CCP#nE`7?D2&~Pcnq^griR0iea(hIi(hU*yS!`_cwu^%bnF@CtInlx>vTh zKIP0iKDqjpXS0kvGZlnBc}QA{C9&|MJfYC*lJpx(5s(5HgecDglZu=B8goppk7!EM$F?f10o<~%>du+!k7 zy73z+SEiRA0~@|8^sVFYKDFgqUEvoi3xn80Z<80Cv*Sr}nw9o6cTe=|CxP$6WR|?% zGgaZY@B*HmBi0A5XXLQdads9R&wM}6u6oM8B6ardbzvcIH{Z3L7#8|cY3}Z-jb44% za$iqhcx<1`&igul*Dy<^o%^vu=aL-DlBUyDCpW8=UGuud8*Z6pr553S;lcr{8z*o6 z+{;`FGy<{ObB0H zv{mC*)%CaX^}cpYkCh)YOu71S{ZiM;HQ9`JH}8^jvN$MTD_}iCLbdR4-eErWJeE zxZ0ez?Rqu0N2I1WRMUT_yNL6LCSMnmpm?48Pwq{zUB6%5+ICmd!n)?%XO4E)PDZ%B z`RsZ0>BJXPXMR1m^uni&CAyz)Mt6Mpx?$<}yq?q($M{?n_OSL&(&)9Gy*lak#GHji z87`aeT|LM4Xu7ngf?=V>iHc8cGLdGQ&)4oeF2ndkGS~dkXK`t+4Jpr6>f7VWE&HxE zXlN{AiEZ9@Hjq1@Jw@igv~58ea%my%I%|$@bbqGdc(wZS6`%c+W0uR_JQY^GUU+TA z&ilK!v-ZvVe7>@#aDwX`OFg$=m*U^%-4fx9@187mGQG1*;hWow%^G|w{5O1+&+X-0 zC%NQIlb?LlH?R4UKVH~g*!?(VZG&-R&t{P|T8F%i?>0=ZuuAV-9csy-ap`)L%kkRN zuh~y65?t|aR!fR*8h=XM-AR)V`=45F_wRC1U1ei+u*MA4MOsXy$$`~Io0j{tRDEuJ z`5-y(mdrt>lPkTZyvuBs`C_6mE$8)I)=ZUyUyCgx&hPt|#4+t=XFHkcsXukgttu-QKO31DADAOIp18lVKD_Bg z*>3r3B`H|}t9?Q&dOMo;@W{73{Pnk5<%d+?BEzT0oN`CdQ&wBOBB)e2wTe#bqQe>qRH$~&>bp4ri=JLTrH zxpjZToEYP3V;lNgm;DbV2B*T})?GidbN2%GoRp4NmyHUq z+Se|Zllpzl}a5Pi>#w&d5!x zA|C3NX}ipms{HtY({0w}>}-cwjnslLMe{scb8|WAlKZQX@OexemA!oE@ynNsLAs^vwiy_K^Kc2VPW>l_!$u= z%%_L_&YM_y{=ZP;yNe!ht>pK(9I#W*)pfd++oBB7dH?d`WDjI6h|%xmyQFtA(88;u z>D~Eds}DR~@Gvh&kS&Bsv^CWI%e9Ak@_xTqcJ5oe)bZ7?6HE+(`C=?d38gt-zwQ3B z=dQx#mCyG~%}7wSaaXyKenc?nK;;vy<*!zn_no?`|1v%5o>jb@>XR=$@{^xd{On;r ztn{~}S-Z<{y9WvjxTB-c~-K2!Jvw( z^CEO!_NldM)_)&Ad**C#eQWcKX-_JyNEbbMxWY@3eKxbD-Mtf6zxK}AXTdD!y;#9k z!{k(VL!R!TZPN~lWpgZkc&$!dZ0$6o2{(TIiT}p4!sFCtFW%{Wp++jo!6)a>UD`DF zkGRb*9_8R@zUyr(dP={$*6nvKv*58#_OAYtE@-tVNxc2z=H5_=r1j@F0bRZGG74`lu>=qoI21vD44zJGpWzew>=y zXPG_MHH7WwY{x+7S<3D&yerym*8N}dj~7}=0+CFQpEsrm+y9fjpr4*Ffcv1H5bqfe*a*iEm1-yv1gVGhYVo zQY$S;nxbpcex~{9a~Z$g)$ix+`Fc&drPljU==;AX_ zQ0&W=!iwp}t3)3?Fi@Izu>4eASfJPw^Qoe1RPDO6XsmM{CeKm$&W8agqVI?VZ3n7(>r>66ZXsU$=zR8;$re^$DTc& z9gLD6F7hp6IvbZY?Lg6?Gc)N49@T5|e7bz`)J2n2YuYN9G{6Ocp?4R_5Jo@KW&&%ei@9zou zZD*Zi)Fp9{wPBK~vb;=-nzm2MiDw%w{CUp!>XziuTT5rPXjL#BJF20hE6}5&wbwm# z&94=cC+c3Xn-$Yyb#~^tdc{^A!KF`1Rh5>ZWMo)b*4aySGmRIeS2@lDZah3?VW^ZOg^jk&m-@y%kI7T zito3?i}ziQi*~OPeS14$zIg1+ch9|ED6pg%BxU0n_IakKF1>9oz$Hg|h3dAA^M2O=gU*WM9C&S^vB5XYXxME=LxdrB8^CoX_zfrj_Tn zUgZMLrfV5Xv%iT=G%RX%EIBOfaU>}utb#*Ll$Xw>V9+Kz{w9UtY;XC znKS+IX}5n}vf;c?$xX%eulb^X8@6+7=ob?;TIDMLlg0l2 z&cERicNeBkU2Xa#w)|Gyw%e)gZuZ-qUWb@|%6hQ(WpMjWw^=@(EnLd0nG|AGezyAm z^{xE8)&Jz;=l7GI%%0PA^%3u#g+l9Nrmib!Ij$UdhhKKmr5|PswuE&j>i+n<%dj$Y zg|m(K`PWC3QXQ*WY+8ldIMW$r!Mk?b@pI4uR~}(U;QAZ$E$bLiA1If>61_ZtLvbGp=)$F?~~$Wxsy7!29mI zbC)7Fc=+A2%~Ex_ws-M1S(o$b0Zu9Wos%@zzgQ_@m9J3yP3^06&-BH`A#w(eJM2%V zw-?XX5VT=VcfIVG#qzUqZ|RjUr)Fn3G%Qr&ES;sFe|g8UpLf^XpJFjv)&7H9%+i9r zmCaWzI0KLD@_BJw{r!K@ixF>@Rl0>}#(vKFsy1i!^7HdgynVd*OU-5Dd9uv0SGL{l zm#=U5EdIoEj-`m&XH(%?+vi_{7`_HQ?<_jj_Pp_p)Pg;c%Zg{(Iv<&{QSAAAJDpM! zlUDItpQfra@B75(5GeQmdFIPI$L)APpkpZ@zTV|bK2XSj-wj$ z+g6{ut~u}dm)9aua=8*pa;nbjrWYvu)XUl1{lc%+^vsI~271gMsS|Wd8I*+iSq0}k z<7xl4@wbl}^OYAVJ6~vuJmZ^rTaD*^S25S@O9eZ*!lyp3$#~)Xczylqt#{VFXuVN? zvSUNa{9@A>mGfWI%zpLMRs6G7=C}Lc!TJBGUkO|Lu8BuC>qRV^Cd;z0S7(#Kgo!gm zCh5AcG5cO&_h6W_Vy@(8JNc#t=j!w?)4#n`Y0P}e%CFGfRb3Zeq1jjVY5DXEf|GQe zrp}jNn4%~sbSzPm|9*x0Ieoh+wbiHCe8SEOu4!H@!NacD@kpDsHH zX-{>ozO7{{(<%3+I{$-+&MMiSWz`G|f?wH%`nd*nb=Ry^ycTz$iLL++DDkGPCpN=?j; zUMS7GuMwc*XzU_iXM8lr5Ioc$@jawk-x?4c2q#JmnU@H0coYS`BfxN0V|& zyhBgSny=7xfz>qrjKbH|>*p_@uRm@5>HR;B*-v#(?+@5@$waotE&uD0$9~~D>`yp; zei8jGKk3q|EtY8x8f6{dxK~fy7VKSd%k8%Il-Di~oAus#U6ygzxoE7^yI7j_M2RL> zq^wity8AcTChpwuzo9Nc`^}*+J~zMfOl$XE7uwXu!KAGj^kikFw|4iJAeZy{zwcdb zc91-FwaD>ff0@M`)2R>7iG8|w^vsEAWdbjLpWX0`i*e(MsQ11z_uX|^$9TI|4~RqZjO&K&xTdzUmRDPSJ%0INK#hZGJB5mfqk{}Wtp93 zCAYX7;V;%BMnJH#I=RJFU%w<-UdO2@ZQsTv4?WIg zSS012K6!HXt~!0;J^y6h2cJ7qQ>yYj{l4eKhnBsq5}d}19b(i6CHQTnQ`A&ITd10{8ta{#~;=b3Zv(|($C2nOo z&-{EF*T%Q`5vfAm52e0d{<1Z3t;dNBSmd77vw z&D6}AxP&jZU|u@QL#^qvZ!{ULk6h!$U=Wr6>*EW)8-cm2m_;M)es=nwDDu=;>wEwA zi;v|`U+@1O9~oP7JV-^xA?5L+=?*8OicZ>Yy_wR|Q!F)C=Jlb(yG^G3zmKSyxg0Vp zU;B6C(WBXEZ5#m}OOLC){`9wcrO?%1QBn^?S{s7<`ciYvs;w9#Uwvm2>i-h3Y}-Lz zv+0MjLm2KfDX!~k_~kqMtWEB-sX3vEI=_lHbOij*sN1Dn>FF7mAv}kF$GvsuC7ycB zJ)@E)_O(YaK<27j_hKvCgzF3y+m5EFARQm%$wIcd67}y3Xx;~4{ZMMe#>)dx1|d%KAmYRWu&5X zKCR{8yR|?2UMY&WMJ1brJmZ+PS;WPt@p8CpHiy9C(vnHt^OO=^D$ZsyeRG#jwt=ty z!pn6Er0nX9Il{w{of@}oy~pt48o`Bh?)PTA*M ztSTzFE?#ppi0gHIZ&#nhweW6Sv_<^k&Yi{2Ro=E{FFO`9(Qv!58IM{O=gRkcTRxl# zne_d@tnVCCK6R{<+$8MoF{4tLMM>w9=p?SW8{`k~P+HC^<1bXuY?-p^$ee)oV@>zx z-%T>)__$%p7qzqRH>O-%b?@B0fF~x?d2Te;dT<&puN8j!qM)zx+464}*egCgnVHhG z$kQa#!R^x8tr6dgZwEI&IBYO?>4~m+fvavaJf8oXS>Wo`S|Q%tlv^I>5B_Vf{r#u> ziKuMroNb@vGL0(zM$kCLigSm1SoG`A}HO{P&)bZouUmLQf(Re%eq-K zr<^HyW4vB=ecs(mbBYq~Y3c4NzyCKZszmnl#D&KByUt(y5YV0bK~!(wiE}v{dQWOB zJ^t{9>F%0s0*6%JNWNKMYh^jHnJV=W?(7nm0d|gLl98yI+cz9#_v*Sbm5c94o;o&L$xB<_Si^SW!mG(Q*DO=|Z)xRp&?cMh z(B9M0CY%p5Qfv)1W6y40efYUfPWOoeFU)UDHM=G=>48~Clgq&yZ+oV3?dDTIeNl2s zj>B2TmupvcO6SkcE}T{uA@qp%*tc&2Hhcg5cw*ps`D#Y(&-KZDc7-bKilGyJGEQW1 z?`IO^+_sMCWhR$>MQv@=ufsi)4_~^%^I-L&vw@MKC)~ZuYQ9uwFN#_Fw7&Y4@{2#y zz9#sueiUFTw- zlPaS1xVomXXHmhQ6A|D3-gB8HVYXwl$l1>CrH5C){QRqD#W5|BRa5fof8YLQ-Dca) zu5D>$HN{b5?Pj&)nD$olZ(VkwwfFQ((xPJIdv>!~?6vkj*ZN^cf8UDmy-UvjO08@? zuHD06W8;^8=Kkf5O{_;$#8{=Tyy&T2Gc9qk2St4ev-MjPu*Ag;+IzTsZ*;(-=*|SdG_dl)^Wu(0lTMeS~-v5 z#%Zt|=TUPaZ6ow0bqSrM><3&q_s~rF`tIceLAR@OrjC zU-Eg0(4oDStmi(sYF>RbVUgZ%?%mH0%{%a5NlN~)T~l+-z9*FA<$1W2Tr<#8bJ)do zt#ZvtK9{y9vA=FE60w~j=AJ)k&&?dgM~hiD?Nk1FW--@S z$%6vZZk$$l`6gRWY5gm%u7u9)6#b(aye)rh(x2-7yrce~*>ZQqu@igDj~ow@TRnBt z-1HgR3Q9>0Wlf7tPul5UCI4rql}OjFihH|e-F4ghJK@LCPv_bUmWWJtyYBUG(wYSs z#YvA`SA9FNH}!4q-g)w?^1~nPVJKO6_{sFNFIl&F-|$|17q>yt=NC`v>BUxzfpyuh z+g41NI*K# zc>n9QU_ZXFf=k@A`l{xNl&yA?ZmWM!-L2jk?76zDKr`rt=IW=<7**EIo-!?1mu0T< z-PwwB<#l3t6wZE|#&yLsEL?lSOOw=yMNKc<=JcHW&vNpr+Yj~m^Cx{x`^?o_9pSj> zuU%h5Q^wN3eiPPT!h2QwClzTe6#q6Hi zPwTm?-B)W@`7TN|diFSRe`V=v#<)n91yNhxpU~K~WU0D|MjuYayZiC0wQx{JBQ{AXv zHrG{2`O*^SCD$6yt)H*!p51*;;^UT+oR#x}GQz{BxA9ff?KmUYd}z_8+c)1I;RvkT zQE_yAo&CwCzjdcYc=%>b;&5Ge_4ZH`tRH z;`Cf3FWx@v(emk+Upnr&%~?EgEzgqLX3Of?<(E&E@19(IQjE1#CU5#JGr^zk`}A*> zo;ecz&5ipi^NAdnI48p;>q|5k3%1tz-uwBp{iJ~Gr%2I~G=W;S<_pS;pY|vy6lF^& z-u~|HZYgq0eA~p-*YT#ySeJHi3$MMH9i)CV>+J2jti1Ia?!UV)*4xckJk=@9qEe=R zM)Jg+jH=3h$_H74gHyJjIk(8q^vZLkLIM6y%X}YsoZ{GdAzSxi;rcVjG^DyF$=dM< zSFUoZTUK&slHxr(uizy$&9O#1Ubn1~VLrCZ#-y_|NpQoBd(6L5@2{+V;~#G`b@LW` zt2@lWnYrc?*?Z+m5_8HQgjH{Crz9 zw_5z@nm$gC`#%`(_RdvZ_MxM;_`s^^d&FLz;PE{CW#5$j>6{x>O}wp@bKZVfK6S0H zlAC?ye?gg<_pW_^mZ00-E`8E#<*O8huTN%a#l)uy7QN28H;p@}@QTLFG*z)(lfG@W zyruhW&BX(UzVEeixqa07Q&(TO7^B9i$MK&2U%3@G+sLj;iVRPiyeN5=shp-(p>N%W zAm>cM9&64f-nII%IeY>W9e0WC*OmMm9@;i-o=u%jzr6jUXCkZLifMJFrsDA=xw#}L_ho3uYay8uV1|IX|0|&*Utr-ZOkY51Z`t>z4%Z#cX92r z+1)jFMSGG3ww?GI_jT=tRf}XTiW1B2@vA2>@aq$y_ zFZ1TFJ9vlREpN%i%%iOH{w(Ba-^lr?g2hH@dmu~u`7K+HnLew!vDp1Di}IZd3wzeA zRMOg|&voVe>>C0O z=E|C{zO%+pwu_&)+{|!R#-!+s?Qa9KRrUNHXS4XFB%JbVt!-N2bwRG*|M(t@3$t#_B5#lHZNY)l|-y)s_<0{P`m$X=b^B>1#L1S)?WK8J-^XJeuwi_rTNzm+P>*q)_$L?etzS7g%_7+ z`?a;aIicyL_+aslZ{D5H4`p{~d<+X&@>=Lu@u%>OVWApc`kS-Y<<9^4>(cq$bHBcQ znfgZH$0;j@)Y?zwmkNIfT-Z9jg2gytq4ZG|n+aRa)%G2etC~@1@=7&AjX@zcIGOOn0uP~k7^bapWC^6Q&?JfWn|Y?-mmrm=iqzMkuu zhBFr#&pfzwU&$L&UivRZ8CNXdMiXU0kn)-Tj%B!v&UcKGyg2v&lvkI-N z+gE9>I_mT2_0iLZ{xFoN?YjQ{xpN55&5bYaWv^;>o$8|LCZMrybJADOwAa!`4=%0{ zwmDnaD9m#B^&-2pM@i1M91|Gk@;vvccFWW9zN^u5=j*k&8QH;?jZWX(yQS~{q&K&? zy_O!EF+aL*)1LC$?c0C8VlZ87TJY;#hHm}TGt1j1-~G4f$-OUy3VV7*vX7kX`|)Sb z`M*&+G6*uQ~seWbMBK;t5x9`i2 z-9ai6c1;iCC*H|!c`TQ;*l7tPZ{Mz(xQ@_|9j-rozHWJRLcC|qvT0KmWTo7HVXHVt zeZs!Sk3PA*+g}$Rb1z!(+UIU=4ZTSc*>_e1JXKigrRj8cpMqzfpUiXx{b$@Cj6x20 zT~E7hVcOF7=Gp$0_m6Bmvoj@c6ILN^t>rP40ToiN&0lJRBUERn6XpYN_e?LY62#QcSksS_^Dd9rL4 z|J>K}&2xl=-Wn^*nsDEDi*k;&i+J4Od@%Xu`|1dxDPLqKOxEFj^ER0AVOf~mwCOVi zwmq+TQuQ;V#XP@n%EPLYwt9;yI+r^>O!5e;VoOh-9y7aRn^T|9SN-mk6ZU^U&TpD9 zHQXj;iKg4`I;lu6-)NR7qw{N(4ELT4nZ8-5>i?58-WW-FJ=V1;zSs85UKQ_FbmoAh z)AFa=x~^StD0_D8jgF99$kPuti>&9kl}*mbK3k)C;FXSL?WZ3rd)5ccjS8_9VV-q3 zee-F})&w@q&G)Lk^2-}O=wFaM&s%CRxAw|(?uB`C9Cyq!y1%-({?5totZZ9dirr3F z7P%js==<;t*3WjTi}y@_&?mS(z43R}Bvj>+$mOx$BG z^IX3&qoelTav$}`RVUB08E#r~e)&|E;|B8Ic$6m})bzQ(u&ZlVT&fF4&Fi!5lP=G8 zyOmtu!0|;d^4pV$8&*>l&nmpz@N)mgbyMWOC0d>Ke|u{&&*Jm{{nr0mBx7$gExcgQ zB#r|~pI7QHoBA`gV(~Ktc^O-ez^-lkQ}fm~=qxk7SQ>jrMdIDcgF$c3xUIK#?LKL# z;n&XD=oTab&JQn z@#e3&0=3_+`zJ^|n_WFcuFdPgPmkmG6_OH7meg|D_^Y!$Hk$PLRqMphD$Z6%c@_E= zi)iYZt!MOl+rx9>y;onrrx&5Cwz6;Bu<830XRU)W)~d;xh8GIiP9|ngEV?xPQp7)@ zuV>y~5NMATsQxIkk@fk@St7m{tzJakC`h}oru=flbm){Ko=$?px3Ao#y?W^Ty`W zN1F|kwClgzdw=Te*J93_Ei)7kA78EYV58-6*@XJ3{nskh|Gewp&hRsgv!u#5N^9lQ zlA5-o4=kj#7OXf^Qy9JH&gJ>~)*MB`=DUp@wiskp>3e;f94M0A7h=GE=5i#X;9IWB zml>&DiaSJ#H$1nJ`SI(nlO z^bgmZ{;)ZQJ>&bbJ!-PC*MD7W*w(4_A&_xnW3zdOm574QIWc#Kx=qGSk59-X#W&Al zyWAERJ9}?Z=!!XK`BTcj-Z-&2=|uZ!j$-{c->P?(e>eLc`|G>T+{gNU=a+asU#&IM zt=#Y7i>W#P=Uj8z8FA?3_wZ%m&rG${a0DY z@cxvxS)3=!g4f^PTiiL(I$h!Xl<7IrmoJJJF&Is`86DhvV42*m4UU_-Op5~d|KR># z{4@Li!}|>34(2Hf|K92LTj3`D^z8Qc+@Dv(ycJIuFPdBQUeql8)WNqkhSlo&$t==a z+!e*1Em-~P0N<*PqcfHBUc8k4=_wpu*=s*dQihw~)oFy4NuAx#y_}M%c&z?EqNqK?6Oc)NmGpT-V>PRG4+kuJq;hmu4#R?F=deg7(amC)=}8oR8N zc$O$iUR2gv*eveZ^?0+`0{zzVg`0o28f$)j!lIWtao*i!b+PZ(*YRnxotc*XYIY*u z3j6qtjeT*2k&*kZobrveI4UdjIA%l5)w!Jt_hxh%tjIjhUVp!1L+AM|FHS6~-T1u2 zy5Mxa&ewJR6IQIc*LrS_kbZlr3;UKMR>DPZ%Sw23@1NWG_9I}Z>6KN3+8-pKHPe{SF*zW-LCC-_D)~$=ohCl z|3&$^E9%O7=d<5mU8!HV_vMuTcBD}yTh3NDck##XzqqQ&!)40D zdvD~c_JwMQn%Xr^d18CC&Ou<2Vn|y=Z-I63I;lBRFbG&+*@VjjL;svE(|7xyzqV*A#VNTDUxZ%bFS0>yPc7aavV{ZCSC)YR@S; zIV&ISf4!o%Mt9QVP_7p`)7{xtZdJQ~i}zf{2O}lz z#4VGyJbf7Zq?q$$)VhEjl{fTe962JVWUJ{EE8AFk-&r_;dxd>OA78sc&z^<{%CQC~ z`VSeO*s87(ro8H`TPSOG<-a*an}uwS8MxX?y6UjSd$%d|{&}1#lJ#Qir$y>aP8qj~ zuk*gwt#6P$F;mg+x!2OF&PXB*p|8sWHuRm^OoSHYw&Zpdudw%D6z_F9rQ7S2{ zRRV8$=Qg(JIsTXB&QJLgQ)I;V>yMlv|MeFWSKnWKHuGJW=Mm+!#cvJ=NR+4iF+LP< zPs`}vi#;4iLm$Q*IAQ(Au<5hT?tnV+#m|2k6e)ME2%9upR#0*M!6REv@ULV`542g8 zdv--z&W_?)hl33t-zmGtuFPR|OEYGVF%1YlHy-3s2BgQ=E=-uZ=u^TNf&Eq@1YwB~}b^qK?gB%f8yI&s$zv9e?ZHt)9hKPef;R zdrbMW@L;J^l8S6%EO)^FBQ;?zUb_F+r*=3uDDT{6H^0*1(VA5b&GWaczi0FF^d^74 zjLShcG!Hn2shBKrcs${>LG7`koeYv2X30N{>7MyV^FfC~?{ZO}ozdBx$LqI6Om30= z%frbQC9(37%gqD5lI!;d*u0wke81-U8x^Xu4FU82#9vn1(a(PS`!wyRiH~z?>_1f; zxK!b&d+ODWSj~X{>ueA0u2BB^i6P0Z_HxJc{df0Pn;#7RKEvKye(9T6@9Y1!ckH@l z`+4!g4a_HtquC~Usm+c!*`s&Bc5irlQ>EQxd4|ig9u%zQ46kJl-5#90#s5M^jz`Rr zvhAH8BJ%V3v&7ktf5^J{#pS5yfm?CPyOun@{9L3hPD^6Do=tVxB%91E=VM^6u*%Uyi;{PHmN1Cz*KhiAK9z9Fq&X(v1)KcKWWY&tF#E-}9BT z^5YZd%EGVCCzL~2WtF_vXqg!sjyg4%_es1!)l6ip>AHEj8p1X3xms>|CrEi(`!*#OS z{PR}@lY_SjJrD3z(d=XGW^-AWAOEMe^60VEoeXE*|FQkHBVSTEvSqdM=2P6w6Bj$L zvdL&Ro#gQUy#w>5Xye(HpX5w?7u4_JdAZj7eY2~~nVl8?9)-m1vDn^wJ#vY%*a}fg zBLQW`u7kOimm{V;e-$#pQS|i6?5&4#4sTn=1t*zxyUK{{m0(D0W2${3MPO5J=apXM`L#hLu_okw^$|PpXEC*n%>y1 z!=4mp6LrLYUz2l>mfqnhUhgl4ylOhwooMAz-^JXukXAstlW|Z*fkw=We>+ z>LJ9PzWHFbPe z#)i${xwvimgTi$$SMUnfed99uZW(_o_s2oIrc>P(HOmhEdbEe<|MvAC9p<&1e)=jv zmeFvjyA|79+vOAHvM%#0dDpXg0blCUm#f`uSVi7!c=k)_%52H^7f%#~P15kYGudE` zzND7)j$@}UN`2X>Z*W)SsMp2HsLAqmKN{z}t!w(C6x9B1%}l{Vb*($5uq(`YpKxNT z=zGro#Y+R?8~ipuxia5&(t$R|-*XSWn-a6kQ1*h)GR01}9mVE<^lshSkaS|vL~-+e zp`_AdVvqR#vJ3ST-#T3U(@AjMg1J1Rf3vh`Q*BT)+>wZ)0-B%{5;Gz z?VR`JiallE+$dhviqur zyn=&Q*&OXqmf+6fc@HnG2ub`T^k(iB(X!`Ci|;Jbd$R0p;)8#W;%koYYnFZ;|8MpE z>91esS~WzbuYRO(N;kkL#X#`X_p;qw5z)%1V5jYPWvV1ey5P_rL5C z$c>sg|L|EI!)Wcs=p%DnqzukU^5m>%xBmQ3pfFG=-%E1MGtRd6+by3i+JFD;HzTI6 zs@A?vZ(A)_ak9K<(*FGR`#r0&IZh91ufB8(JDqGfLsotN^6AaL=E=<4qZj}G-StV2 z%N?E9O|?|Js2#S=e6{!^8}7aCs&lq-S_T)b)DnMJEkRY=w*)@hE0%k|a26wm9ttA7`3S~W}R#pKOi>8TIQGrqNYoi>j- zul!spuTv;c_N>WrPvznzV&3aY?>;`rT%i1h_w#y=JC0RmQB~!c2V0hk=Bzw>P1Ch} z$E4Zm@1MU9yt3})7N@6PcK>(!UzXJl)!aC_{@?lkD+4x`n7y(6J6mbPTFc1Bm;QIR z->Qnbt+mUK9tZTa%>9<#aZ3UOj5n2R^tZ8-nQSyPeg{K-An zohL7{Gb_-zKH+r8rhxp^?A%)#yZ@T*`uvh{ExXG5(DnNdILxX`S*6 z;kJw$3+_KH%4KKszGf0zSXnyLELB~9-Tu>yZ|>T``0s62WS*FVP{qCr2j;!X33M1 zP6P^f`M#X?L}O3k^S&5U^OFu2b_V#i)o$LN<`w28`sVMcW&FGBRv%0|$~tG}vpFA( znxuN)B&SbW6?NHu@>wIxK(2}9HSf!I`?k-YyiO*R(<6UHWBmG6TbAjHOPyG;f2Zep zb=%7mEG3oM6>B#>i<$cV;l&N>gmdrSDwVs)|Ffq5*!9&dE?0^zWIhOA`a5^7t@zX8 zO|oli#XRC)Ey;iS;X~g^uG?8Y*FU>FjjvuO{VuX`@hXuGi;uqk^x@#bnu34x-WZ&( zY54uOc%j1->yT}BQxC>(FciK1#^&yIo4fzz))ZVnQ=oBkt67NcyYzd1GJpF2e|CR@ z{g3}O?sZ=d_CImcdn+k+GcxT;gu>SyKHvA>Tl2Bffq&A)TXE)@>sP)wbC0QU!fIib z^s_Nx(#tFyUU@%$mNxy{xv3k34roouY5P(=ef7?_vlU+!RaUnC8>Vhp z6eoRWzq&P-M8ed^axD9j>e4FKot>(aqIvaTl}GH7%?0I!GrxTejauy6^ls(tg)C1e zPmb0UEts_~*VN+ps|(+DEuX)1*q8ra*kqU3@u^^e{K2s@5@;sQI*x3jZ3a< zF@Eq{Xm3li%5D8+`~U3PicGG`yVc$GjVO7#^%=ox{C8NC+Kmz&M=j}{6L)`?Tf+O<_TBAMr?P$k;oj?ZVrHE51jPRcDqrdj?TLaJk#@EYMbGEJR(*EPqE4IG(%;S3^ z9LjtzEs7YtZpo})AYho@C|J7BHN23gZh~-I-1&PGe!I_~C~x=oznAcKp*Q7K1y?n{ zujuRfW_6+a()Y}An^yI$JpNDir@r@}oqKxIYlED1d(T^Lul-v+b82Md%*a|%F5iWV z9lBIJOj`T4XhuzQb+c&t_vC{5<^K-<*guK8-{@Q5WVE*6#g-2T+%{L~Tlcx?{9xUQ$aejzJEQC#1>>bvhx z@t7;$j#=c}WVj=~MQ^E^fy#o4Z+|S;zFjb9vv>UO_vP2mSNfOwU7Ym#d)llcY{z%a z%9@>bCCRw$bwS8lW$x2K-)sNgOMm<3)6BVX^}7`+FDf3Icva%juRB)ve|CMs^WEQO7>#$=a{KICo-{=fX7cSdLTM_MUnEeCKT&b0uck?{2O$pPf$^TBPD(mnvA~ z{C0DGw#3sN8||K1`A%|QdH-cr^}GXnD(bwVrzmyIU~gTx`hwupl?x($M19}%Xqc5q zB=wuN%b%({v!{43UuA4Ill$3wKjz2({?PtLS-y_<`NR3u-@eSOeJp){v)P-D#r3v{ zMJY$GYTbRee*L_t8@98w=I!>E{hE?l`*Yp0C9_<+ONAdBu~a@?{{Q#cuh#!N?=HCB z`L_jOsjmF#Oz?%>UNu`^^9biWowU+0OAia5hw@q4j+ z;>t*uHScSl?|u=P8=$heGwe0LyV=DZ7AnteZ*gxtC2YLy!XdZlK=b_TT9K{%=L)as z-+E+q?fF4HzNfVdCCC~b# zGvnc`m5!o$lD#*7K4Yz$Z+*%>*=zpce-|#vr@c2_`E8|G&PScYlikwYGwyj$6aB85 z@V8duG3(*FQy1mbKFwP2_votyENkVrtv(%G6sZ%rI(oLCq3~hro?T6HEERJd3k8+y zZ7*znQJ+3r<<+kp%X9Z1{Q2IDCuytLWZm@Z*B{S&uiKwnUwD36=6S8^7@lu2*CSUs z?)cpj0$L?4N)w-H4VtI1>ZqM>> zchm20SiN$AMBKTe>+@9){+;B!Eh@=LebVQAvELt*!q8;r~UjK&+szoK+y7CTbEAQA=DG+v}Mbz zr!iuW*fWG5N~!a*3jXXp*!uDBzsI{)x@G^))Lf#t&)UWMic$C}Zhm>Yp!o)on-!yi ze=pZn@p}A^=WM@3^ovJ-CK)~9FmjTYJEtwgdHU+i0H@Lwk!h11<~_(TSa$WwVs3V& zq_`}%-LG1%Z`^INWnJjK@->oHJvUe@h1zoCo%|OrTtBHpe!q9pm*3aq} ze(UF-$9yGUcf`E^*S;?Gn&v;_txIR#{4_ghK6(Gwef}V3vP_J^$(PRpbY-&?A{ov0Yo-1doU?dJx=g#QQrMfh z$LFqz`g5@<>iLEvwZ0qqq!xvJuYVS$s^IneN$#$=d(ul;x*GPb`5C=Euei6uKq&jD z_b%sIZ%yZI@BAahlK-pYLBEFlyIBFDvpQ9u8s4|iZIEtf__BKU|HA9?_e&4+tu6oZ zwq?Z`ro;JKCA#XpI@Y>r(khvoLVHfhNT?>CGhg_*`un>ZcXyZn-1jM1zV!E>n=4J# z=LJ@CDJM-``?mhtpYj89-aKDg;B&~(mb-M5PtTR7ogd$9o9%r@+(YoRvUYUm2a6M$ zJ}-Q3{9;+BnYMm?$ZF{W3+8vvXHlLL%e~aC=6z^&!GF=+yDW6?Z`>xP-uLyN%inWz znZN$CmW_8aJ$ur2&fk0Gao2Ba+zYtwRJlI=pNiATjgpF&cRagtc7erZ2SImtFW=Jo z%JqB7{f{r5Vw5tm^+t=}*Nuxflb!k%*q-c{WYbc!+NjmhbGg9qavaBN^8{Vr-Pt_1 zKi>N*7*HE7%XeS;(}CF19WQPK7&Lx0>C6Z>zT9#qf9rn%(^G}jSs~LGH@~e}l6^8o z;E2M6$cW&^5CP7LvQ7q$^Vb5IE}zeyuwcQJ-xsC}pQuP?nHI&Y_M~fx;o+Zp{c)O4 zCyOpS<=XI|z+~Aq-x%+%WE~6Lx%1xjXP?fnFZ3itDUX^dmI&ji5pzlF;iP+QG(cAmqerhUxx%X=A zOFIqic^$_rnYLI}9Qbyw>qDvOj_<`EZM!#KOWxws78td{X3N?RmVm}jceH~R&t}{j zXu~yi)`t!;vBhPT{p^bUE?H`xE%WzTY^|%$4c{%kG;H6s;>_HMVX}EQo&Bmre{OIN zc>U>q^qlRJ3%~Q{-%fk6r1m)? zTig#!e)W0nOV2E(j5>Y31D;j~=F6_#vFp~9OZR5Jy}K(uU{`gHzwY^Vb3d}+;o1H@j7(zFLO9Lj?CaDdCeB>spM5*} z4&xoZ)QuT`jS4w+G_~Iyn0D?|UQ+Ut6_3mI8r_(#XtLV$`wVsU=O=?*Wb>Z~Et|AH zb;IEv4Yx|Cs~Zk|wpm}dQRCeI#@IP~HD|XTkv2fB;?Pp#Z(OfcHtBy*piTH1# z$$j;!x~!mzv*W&FniUx@n^v5>=JeN)?c@wE21DJ6ua%m%_?=f+w{Uga^^-Mz5nuKA z-Zb|`eJ}Nxn6>GF>le4i8Cnl-W$mP6fOl|MID zKb^O>eAxnf#Rio_3l{oFoIb;2seNNp-`B67dd^+>;e4os6`Tfk_PbBacO__PA zr)6f)-FCq}Z^cVqoV$Cw=#7rIZRMw)`eP1j&6F1}S~QdSasb=spqb~ZJ%lgFsC%(L zZzwzdWzV+F#_hVht>4c3EB}UVZ(az)hW-D)-Db7=w>#vX^xGHLYAxmzcIX^p*#3(t z?wzbdGvhUa0 z-yE-hX5Wx;A+O-j)MtyIn-uSmto?lV(}A|NQy!G`?d$k{`seQ^x#BO2q8|tsJ$k4! z<>k`};b*r+#xEAt>r9yOwBnFvNz<0Q8Nas%cIG7Z%iZ06dGhnJ!n$?7ipj4_KOE({ zb=%;Mtms3ZQjgOU_s(9bFeOpnwR)1;k3@lsa{aS!9XYDC#<=(ZkD3~H$lIku}aR=*EdVE5L#>iPP~o4>onPOJ&IUcOP;N8@w#&V`SjSiHEk zD7lfR;Fb24J6-3p7HmGy82XKCqUPjZa#Nmm@Hi^h-@h)g*@AyY&ENJ{N|quQ5BnWa zV=uX_l*~Qj&i(obqYdWr|904x2TlEc+(8cKn`~t-$@5Z!K$DelpM7mFJvOe=YlCzfMiM#jDKxeE*gxqZQjDZYj!MkGBa| zSDo}b`D*3Hj(~aZzfP5vm7V_iOWy+C=06^FEp108Y&n{gsTk0b=z8I4f_mqAYmcz+ zb3C#hxmBbKe`gYAOt72V(dl@m_uT9wBC4-vUSBy=ELGB(iFIb|acIlDjS+rC~F-mSQPb}Pdh`#&}FFWpZxd;B(6+Uu@g3afE-`mu-I zEhijO{uwiIxjm9A`smj@XU_k&V_&ab)UE#e)jT)E4b?4vSWue(VdC$6ed+KYsK24pocZo@^SnVN0Ug@(B#omPdyKAlEcb50&j?gV@ z${&Arlo5`akalFt6cLvX&sSeHoU?QL-Xj+A|9iGezb$K8VEi!4T;N?z>@v|0`o|Wz zIV9~`zwCXO^^BCR%FsswFNAg;W;<}WZ_0_^TrRkubI31Nie%q(w^8Et zWgX#pXO6V3Z)}$Fu;HJ5Rd{9IA=A*>mFX%Rc}d51KU*q2acV>HP3HOp!^aD}PiZ{; z5+JPSruWp~N6g_1j^>vwu1BOcTc|vmoU!-F=Bms)Ynqs*NvF(cHEG~^mf#wBe);R* zo{FVrwOT#Ht%k{0v>ngM2$&R< zd|kxlvvk7Ua~IDF7TtMRQCb@?<@RQQmrmE_@0!kZ*sr>G*Uy_$<{Dd!R~)$6q@1>E zs^j{~jnFnk~Esy^*`|Y?Wbzb3=KX&o)>ksZrZ&;nzt#_g; z*wswno1e&)Sx2TTE;_&`G;M8L)~sC$vi(nZEj9`y>IXDBge0#G_AJ_1-pzPo$6VI< zlT5SL%P_vJn{~(`tS9x@t0TLEjLv*}rOm&hR^iHH?&8j<8z-NZ`M)`O zdHs|(k2IHme)yP^=iiN%H48ge&S9C{Hu+o6;olXxc)9vn%Gb>gn3rh176>St zHaTEfCAo3@+cintjCdy4hmZl%CxNF$rg%Whp2;pY3vIbHl}wJDO+GJf_Vu z^}MuV?)2iBRoor&=`%AuI!~mm{(SWBthtrFzy64rFX@}tTczVVwInXtX4^ukziY1P z=KWAPQWv?|wok-%!>UyoXYOTB<3H@X%`91DYg)AeZoRc)>6dD_x~%>6Y0H>@%J;+XiOJ29 zvzVU2-o_hWD6gy3_WWPU&-9Ahc^6*0DKf;Ce>t7n{Lg4Jm)nHBEpie^*$(eI*}6F6Fo_4W^Q77@e#2Nl6 zi%g_;tJpGfuh{giJhk^%{-k*g|F0UCIXsAspZhMUboSmW4V#bM@Lu+;&~>M+QZ(DW z=#-Dm(;cR$PHMb!*2s=k^_alinJe#a4=w#yef)dkjN&{d-O|TyWm6ALPCy05W!>c=S(FVK3|H^V(T))k7F>U6}YcowgAL#vF^j^>C zq3g}f_jXC9Hf1y?m#s3I!?N&C)a5^Q>GJBedCjYpma!Sj->H&y)MWm@ra?U_T=WOy zvv_ZZ<2qM_cZ;yZ73MB0{FV{?d;7FAA`@n@WvONt{Lis%aZ+h}q0?7U`^-x4d%&iS zN$g?sr#sF$GRx)2>KNg)|AGd)7pd&vs5IxV*J-Ogy1Mx7pDF3~-qYfvHgDt-)ksZ! zzVoBOo+Aw}C)~Sf)HgL>%>qr{oXdezAH1oy%X8(IrFN^r-*4k zgWt{%EL?5v=&|fdyMgO!@r~ZfWxmIrzo_8faKRuh$#d?!9ZeA_@=xR!v@Sbc`uY0V zc|L);2QH+EsqB!_Tr#cpSKG&b5A?GBoVg&~J!eDNw2QBF+)lf-c^p2xB2Kq(<-dr| z7@a?H&!snC@s+H|xc~eAj){MFm)Qkw(31Yvbf5p>7NyA>XSoX9aen_H>EgQjJd=sK zZzWdtGX_u65WVkO5im2SZ-efu>Z*Aseu#7Z5P4B5bNaSk+|$-Ao6=^?&8SeAqUKTJ z`Ty9T9~>$YE_&UG|Bkf(iz$3&XzjGf((3!PtuA36>Q6O}Ojxh@aaOj1P%2}Yz=pN! z(PbhVxo5$u_1=!tEY9EhcZ6Z#J%dmtZR~HzD z?c{WrC}Vj_Kjkia{ryezjKg04IwbYzg0b;j)}5kk$JCo{oZRb`sI&Gyhs4%(rOs!v zI(@UPZas3!R%*)HJKyjBfn0me-$=R5xbytY&njEezMX$m z&a75HZT?r=Q(Z1$MYi(X|GIJ{949ePGdvZ)PXBzRI%i?S1m6&~!(vS>tI}g9&yo^I zT0BMNy$n;9XyTWv7bk9++sIbx@OzTVWX1TJ!vYP`q6|w6?;ow7c(U)rpM^)v_8g;_5Lac{r+H`!@HcDetG?P|)eq;7WbFt4BTxUBfJ+@j-K zx1CvPn^~pJadD@rrGd|%E-_Pm@f^Lq=F=E^3pq|^y|>H$@^EAFz1=*Alimw#7E5}$ z_m122hZFwJ+I!DlUR3JXs%zO7zvr6%UzN&t`R~cb3Z0&}z13O&AB$EqY>cpwe6ipk z&-rWVdOGh{#A#KS?%U4B^zSl!yL_AYEt6B0uNE4GIXs$}d6@I6Z$_8Z+C^nMr@HRZ^A+*FnJ#eA%WdcO`tGh7 zPwV)02e0AWFP^;f--T1=yqZm$?jC7${#vPi@AtY{A9e1XZcq?u3fBn#YP$NU%KlC7 z45ugelumyomw!v_V6DKVjGIn-+7CuQ`ut7d;(Pxr4(G0^N_|2?3$1QhHqSO(5=j6f$o){|=__OZTi>cT#=Ekw^<0iv;$Q1&u!yGtWHgIbzo* zduH`#hs@$ofjeg-Z#Ji=y-N7>&A$9kK+&6cU5~@+9uB2;V#j&zZ7&O?~c;>%(@uDNpc2Y-A)s)N^ zegaWK3cpx4FY0^YY&vU`tepkR){Ploy%TS-R5#C!H#>c7MdI7%bpbucZX`Zzeh^`9 zkX?FtL5FlB`|Y=CN9|T0-knk}UQzSZE8gP0=kr&yUj~KT5o{CVxpgGrn5X}`_I(As zKfju8Dmk!p#pPAs?eueBPnxaC6L;mW+J?N#pBOgG@>gN`9RA42@yEhW#jZ_vtdGt4 zSyORicJQj(Te~%XcPGoW1xtM1`3_}e7r`M%a1mFR&?`VSU%I6 zce(Rlh67LRGE$2J@7Xc(DuySdK3{%xC%;M7=2v@oio%}(qa=VL#3NdlD;x$<(!h|(HCmf%9D&Xq1FSD8+9Iva@Tm5Lx zx_QP7r_LOc)R_GFA@jUB3>}s4F5h_PY4d$zlb@W-kEkNGKY4$hIL@E4*i@;al%{z8 zwgsD&VfD)9z_N!+eQ(P?#hkP$XO`VI|M{l}f?m~Z}ORdFJ=0;Y647^Igf- zTw0sCx%?Ak)HeDW1Z`Y!fL~&@;Y!o(eUg?f_LmkWT;h||%6`0#}_?T43JqRsdu}W*CO)PmrTv0M~Y0@e^-lTwVU)+ zUkd-Qf8~AaD1YWQu>+G<-`f|U8$P*M>G_njnd>|S*KZD)zh2~z%sn>gIVbq1u4DaJ zmFeO0eujR(g4)u^v={I19-pu-Wa89mZ{58WudliBBXghmE%}{oLTs|FfASaPL>fE& zI$|onXWq=ZhU1uIy4YU3^7hx!?V@>w3IQ zLe|=GmcC3mzafTcV|S@YYPaC`;&)+l|2#9E8}moQ>D|hI)4rdH&iMZAn~q9faUR!# zEA|PM99B|}hkOMsOiPr0&wAyd@?>6tQsU0(%-2Qx<}kBfjpIGE^<1W2q1@lU8E14} z=ib>Edj9{{z3j7}&v#Nd@$IFid*$Xkf>Q#La;2|tnCQ>E&T&$o$FfJys{YDW|9P@s z_0u8+ZU58TLF0rXoEuyo{V$BvC_nk@`Jpqyp%0y&us*(bI?3|R_vaQ0MzQbYqcx&7 z`o+rBmUG;^%NLl+#`)yMxy4C3F&fXexw^cVyi3l$a+%LI@jF+qpSa=XwxQNaqx6xp z!)?a?R3Db)+LJ}9{KiUoPUu&o%fya!()Z& z?U@E_-`~mIdV2KMx^;S)K1EL^<@7K4os%2avx76%Suy+RtRLGKoUO0>XczfINpjMT zl&c=9vsb-zbhCAhj*n^Z6I-@b4j(@|Tch!+M$ zQ$P6beAh02uw~!r)56uB_byj|kexasX-4m>8%=zf`-83XccGUn z_pd6~ez#3rYx(AtLGqUgzc&ay_g(OA?q;SLC!HF5Qu+3=T+ap86-(4Mh1th8s4UW5wsqaFolONY$Db!u>`uG4O3x>SW!6{Ew@qpu zd#xld?~P!7_w+KSUThn`#t{`X2q<8OGOP^i48wMsBO!xt%PN*74k2Srcll zSHzw2$J$+qQ!T@Oj{UzWD(ghdj|SC#%bRaDTUM?An`*|#o2nc~(iE>1MdsXDY<_Ci zi;GtSqwQ=z8oaCD-Ydg-FN$6E*-G2L!qFQ#pJ;e~Jd(3x(*#C#q38*M|8II<44L(| z=;}|c8u{A4Pv^vJUUGa-W|8u|{W}hrgxs3>;Qoa5lS2N@WeOF%DDYIrKKw@JV%IjDLFlDvZuaT#oyGZ{wr&3 zRgrLeviBF0;%K2yrM`J-hm=13Z2ImQwL#c>k;vts2TsQdk9qp-mM_>Dw|!r2!ToEj zX8Yv)0@D3odYznj`tCQ?&--)3r%x{{^i0dPSib7tw2TG8d=(qAZ!SpJJ$fTwRw+LI zChLi*ud^B|;<7d$Ir=r_QJL_Grj#qYswp+p+sLeEd}V`m>4z4}d=Rw2Ca%2fOV$lrcEJt)S>DX6o@7T`$=)#6zHMEx z^v?96_2$q2>@EEN>+k0r{>|@d`=2?y%X*@zvS-hB`$vC26uIaNW$fD~^Jz1eQ`qtR zDW`X(ZIj4derzXGiS?Ve=^sulP?1pFQ?*L1itXj~of^kW&oK(vOs+AOF=#$KZEg4U zWJmoH-lkqz9r>H*|G(Lv9{=~#_BXHP|Mcaye}2Vs(oyn>;!RGc<2#nzdRCHpu=Rnr z;*O@c@+t3F=G)fi@yiRHwcD?-kZ;ADQ#^V;+q92=O}MoG{As;=^STn!bbhD4xf+_} z_AlE~(r#!b~IQIO!!WR~)wy2cFzPG2x`TstCX~l_Vvz2R3H{|b@ z6j-A&^^45O^V8pm6}U{Y{o@j8;41RWcd6~i%^J;b9$yijH}$;OjkKwW2M$Lu?0uRN zz+znf7Btht+2A20-n`f3gUZUeDa$oVlHc3?lz;oPvN5PSU(vGt1z()hLMf}~k%9~K zUFNTQE;M_htkLb5B*uxi_K4)jbMM#wdU(>xwN<-g_NV)w|F@#%`Bt%_(|wi-Z7nKR zovgPXO!J$eb^m4e9{!FyJt~{BEiA>CeH1z@z1=?R|3CeIvcGqp|5s$_>K)J=BreNn zEB52(&6%+=F^1loGn`+gTv&Wf+&k$?T27M5yi#7dgdG2z>e^eIR4@OX6r%0xf3oEJ zx7^B-<16epuslC_aoRo$iCqG2kJq_vkFh;s=%DsGf1#VN(b9A)mFAtzFAZ|f`G*7@ z>YT%g$qQ^C^bp)nV}wLU##cxv`)@uzeAXDFAp6!Z7pbGR+TSzD)9y=U1;_0Gx< zMKQ*j5>2*Rf=ucW(|isdjZS!>R1m$AMU`z2Yjf0uHSZqFb+~!odHnkB?hMtn#`kO` zP85GDJ+NEH-O*m|voIUS!X13A^<{hIx-QzeIvBaRU7L78>X_aZt_Y(=%1q{qpP#t( zVczYp$vy#}v*l0i`;IbxF4@`z#>x5nIz2uMN3yPOfNC2)~2g|Cr*W!%5J${K4-#v%0qYLwQBPJcenlqX~J(=P#f`OAVYOZ?$izj)7Z zvP>yU+^JO+aWA?e8m8Q0i(i}dJzQwgO@02gU7n&XH}fvMJ~o9RhHb~2XZvsKPV1VY z`cdMM@v5`W{n{kIdR%Y0uMxEV#=^Z1H9P-S(wSr2UbnNDle+!yS;uV>kpJ|U z?_R2(?db!SC6jdH7JL=rla&ncdHh*??#ovX7RuhM4ZRu8o$+T@%+Cw!@3u?-EOz+z z=FP_^kqU9ecE$A2QZzh-ey(B!Q1ri!2*^j`9qbza~SQy*_;=KurFDwP{H0l zH+Jf#8%34nTQ~+z&G`FR zwA(@h4e9B({&3c)Sx@Z0t76%7Xj8ZiciglktV!0LC;MNQ`e;r3RqJ83PhGS7sBB48 z=sm|E$txy_rrItC{z<;x#l)^9E77^T<;Gqc?!WvTUT@cwp1Y9t&~LTML*|=(`F9N` z{dcprwA5beJ8kit8_%Cc3uv3Zy`ZvHh9xFrxrIN&aiLu=ZmC#rOVq1LDXPp9C|bQ| z(kI>H>+eZeK9CM!`oLc6@y$@I_&aj`<9Se6YR;s$7MJZOSH3=%H0PXP zh2vSiCbhkr-ppuoZ}u;`w9d+*-0SqC8`ECy?7gcx@8Xg-cOw6Jx+w2R%c-#nH4gr{ zC`IGtp+#2~a6hTid~T)0kgQ+r_VaK>j(~Sq?k|;NOrK-KtB*GHh@^W8SFc|_cgjtb z8BT9IQ!dt@e|_8OqJBz`uobgfk=HMsPj_!Es-M{?xLJnp^X*QF8^MYGj`QoMpJ)2O zVW@aw&otwxjK6IqS?eEcP&ee2W&Jnr?<0j1rZaY>n?CT~`#FiLCoeqb^{H9u>-!or zllI{SZY0eJJJHE_%^Vg%DS8uX%^{Bn~X4l-Y zT84X4T9KCy9Jo!&~(%~H!Z(HwZ_9)nSi+#z=#2AUsM-t{;5PWVV$?*Tu2g~A`&ZrQv ziAR6WczvAeKeE$6T(|gueoqyt7zbV=NJaKcQ7i0d!v$FSUSymKi%=FR< z&}6GlkT`DlKrM}*X{*!gI8#sW#1qYbrUWLJtM4kkR`JYa)7!EOho))xzIx?i7tH3e zxAtm5;e998Y`&-3ldpYS9rIY^iejqezK5rOzQ6yAgU9mr>?Xk+vDCJ`f5RuJ_8F}E z6SLuL<=PN~+txn>+J5GgpXWJu@aE~?`Al)KGWS*nS}p!9dj5*}`?75Lx*y49p{J~5 zkFD);jN!SNcYVqQwFxKAb#L6g;R3^RjVpV_=5&V2cTBwB?+;IV z+BKbH?!BVOIX@h(9^x=NH1or;o)y3K!^<60zI)v--W9`2l@F1u&G^R3;w zLDM>_x7zkRaSDHBZS!Y_tnA%QU!SeImfX*Msj#5ryq^F5;|@U{PE$HGvL4^nly_r$ z+0kLMODcC+m)(!-_b=qm{eJbS_GGYn?_0Hprc8{b2W|Qio%&vj@ymkZ z|7KVC<{B#{hfHAJrd`A_L7=HG`_yqye~B`Yxnf1@H4@jHmaCF}om%~MU1-yK*Kc+i zf8S}{@jJSwiR;V0I{ppkFY@soc@cHQjIC$w8WYZEahfaSMQwIyOw2Yfd0^z=TkJNE z=l08vb5mwlr3UMsx%KJfEs4j|z8W*6m-BlZU0PEWaqaWAHMeCw7TmnG;?uskd}9^Q zvW&oQ2R6#ezYQ&U_U6x-bLadDW#=uioOH0!)A{RvmV-xBXDmCF-00@|vpg_hyPS;# z+pH@SJROR{kG`vjOu6X$|7KqKr+s%DuJ<}JoSLS6ZoTjABIXyl3UUkmF8TT^t%^AN z!hNxf#^MmSQ(c{>7D>9D&xrJQ$<2R%;agYZzVhdbzdd@i+icBT8)XeyzJf%Kz{yL+oCJ6 zEA9v`n%5(cShsSmS7}UlAJfGDi)>Fel^izP?O+v=&do8ot7P8O_v_Bv9^b-pGAM1L z1lyynFCTr8o!9QSf92LdXeCo1U6+C#def%F$gK-;XX0*t_5Q-BjID|H##)*LGVUIeO`2;da(5I#&*vJp3!b zBee4ChWfL0U)I{^|9|yr_ETf#gdh8o^S>Nh?zJfH-F0u-2EC1c3ZMI}EPr44;F8c} zQT6Ko)%UgLfBru4!HiG4ET?_id)&QzV;_5oxlV%5aUqA8=h;?f6PH%Sznb*@Y*u@+ zsLNLa*2>54DtERgpAEU0yTB-OE(~>F%9-_u!M0Z{Jzp+U{1ACGHW&zogSJ;D*4vKd(Q(Pr4hSdMQ=OATxf?V$V-( zD{r;WS+U~9?^V7nPwL$|-}sd7U#)!V?h1dUyRozOrtrH>n;Rr;e>U3XAM3mIIm~KI zPXgwt?78>z%7ssNV!k&t@_N?##ogsK{E^dQcc7~3{Jg&N7Ky<{`(ysc+Oid!PBXOT zZd^NetD^nlYXRH59rBzrm=T>c$B)@ z-)^tJ*>3kmO6JPk-N&7LCYjb2l^3}e$UW|hjNGI3I?{H(ic~3w%L&E{3JW@q>9)-i zkc)4;W1i=?^7(@511C$bOzu!h>{kVxU*#>_w&(DRXV(^G zXgNl{oygCW*fzOP{pn@PuSair^O!9N58$ksEAt}7a=XI!4GPwApYN`@zkSWevpSv+ z-rc_UarF)TObJ1gq?!$`(sJ1s>-xi4Ulx7)@$_lz+OzA{-E8ewlGk{+H!gl!(cN=# zdv@r(x7~d9nN%wG?Q&?|GrK03-o@KgQFYYdN zJt{gYyX;^8X_Mz>?JAl2vz^kq{B%S3W>1$9cal#zyijS^`h^b1N++gV_tm{xeSDhP zo2I5UJ3k-z6fyr}$E6;ZB~$+Vh&%LQfo9Z(-}c-L|Ca3S65M&(vp(?syMqRN0a{az ze@Xjma*~t(+OI0*w|)YDKZXh2e~~xgdTR5!{HgC{^P}fYbc#5x9XUb&SK-QeFI_6E zw1d|RL^=2$$OeS5dz zP8JnArgKW4XZ-ppY}Ck_Vk*4E;G_+IyVTnH$xQu%-;L(HnDX58GmD3CR#kaCyGr%n zN3(b2&C`yarsuyu?)9m8Gv#GuZuaVE07g5zu*}p_cSR~wedEx+@pN^~B zZ|3`&Kdg>DKeWJYcif{tcoN*7ZF0V}G0o|BT~Md?HNP*B z$E%axv78J4^q*EZVQ#;f4i&2E_^cw67v-9}Y^ZS|R z&n@~J%fYmeMd8zvH`4-Y*KK?37p497`X2sEUI7i$Ki^nqU;cK^*_l7iFL3;@_x+yy z`2VNE-`xFvZ|mgeM}yXK{h7zL>p{@ge`l`RK2Vj5+uFaU%zYbsZ;gh=JEpdN2KVz5 z=P$V-yeTzviOBBlx=VXF{dOL>&wl*eG1KR7-@JdnaLY;2Q+aIr{q@|AzVH5P<5qL@ zwCOa%9NTR?w%=v0TC>bFjCRgja{19+`+0kJZ%X<3^4lxP^~N7}=&bK-$vJf^cix5% z&*$CYz5V>yB=yNg!LPRqdw(`7G2NzdcIG>^8uy*{r;o1PbZ?y}&z578Pefj3-|7BO zhvCQM@2|4bqBxBLe{%-O{rXdG`q7D3%B6p5;8ic4#DgD7m1b?)(9=6f_qFwhtEXlu zFqm+rO?y|mO4<8wdee%yRNr^uk^?@?co2`Zao^W`URE}Qwd zuF0^dd7^8F^V<-WlY9S8{o6YKr}j5v`_IDPo<-;1d|vnB@wX2LWzXov$L9xh+uHBn z#4qlO+BLNZ$w*J7O!d}kUbD@6-^>XRb}_SW^DUb*#&drJ4`ZQ|$`ym3_OiK*ND?b7e_Yk#vEZ#t9NI7RvzPkBoDnSUCo z+DlycrteSx@btXFtv^Z{na}SuZRE&t=<*G;pZ98S7snLUP21uxB*#52%a^uZRdg(N z`>OLQ>=)N<+aTp-zWu%3hWT0t&-K^+Ykw2}pMQV){hH^O?*06Ay}MYi?{eSiy*oCs zzIyTdXs6}@kLfqEPg*>0Dkyube?t0o;O^ecr(#cR4U4L-#JQgAkPW$KTDYNpHH&n$ zO3x}C2cguKbB)W6s08|kz4;+ipjQ`nIqX~4oh5v0rz|VDk+E2bExuq~q$`n(A{*ne8+q4mcLCsQRFCUX3}o@1SUdTOe) z;{?ym4tqa+ea^Yo*Rw17_2%WNkITxwyb#{D^Ur~8&(HVNUUM(2c&_~IVR-nr?D!v& zzbDH7HT?ajzgFx{*JSbZZ*$+*)KAlVyrmbE6(rbJ66PZF4HwJM_smt)#}3j4^qFsCTAB*ZJL&o<>+gX`sKv?fTly0OG3`C zzxVpgPKkFut8erjTrco?^^1w$7}>5)scxDU*sL|T{N9c-r#l7b)sneVMVq~fCOn;g z_rRvJPp@uWJ8kaYGx2}QxtqSPfBWf??C)dd`*;sM+q6G_JD+{>>xVmY+dc=e-98vu z?eIjovUsmR-1=$E^1%Pj>h4`{S(@fruRYqNQ{Yl3bkX5${i=yzFMzM zv*bYgs^7l<=U!11m{`khQ8VdU$z!1m2hU}jLUfH6_*qBseDbuY=evAj!lu}y9sUlp zcwU9hKAu(bQd@{UU-WtX^K-S;`yDzwKjg34w3?ZzwqyX#*bf0JJS?en)_`=8Eb zzrVc=dT*l}X>V@KyIw{tD?h}pC1sP0cgilqUzei}Tm83S?ew}Uwd?&vmV=GE3MbuT zGJf_f=kf0fzANnIF3;b*aarMb`dgH^i^PIye-}+HnxoS(V?y@T?~l_jXY8~(fWa&Uy=6 zn%2Rfe|@#-srPxQ+3K@}uYXBgEjit#>61q0TMjAZ;&WHLJJe6V>~D7MuRAmGMCf7V z4Qzs!{`}DUw`KQ%tw%R#8{N7&GtgU#QBd1*#q-Adujf4e9J`>SX4@LQ-a_$G{mOU; zHWRI9pqq|NOb)Di73i&p!{FlKuNw`2Kvql)cpj z*XPB>Tzl^5RNTII+iQ)5Jr7(vIF|9u+LY{4?rC)O%Epd#84ua~rZ+v3O#J$cclOuI zr*hpouT!waNik~o?oVIK6;_#r%Jp9J{h(ZQd%oD)c^6mBko+@gwZWCA;u>O2ODCS> z{GPC$FKL=upi;*s?@Rwo{WP9jjyMrE+5BP3RlR2}5~9A^AFrO@&a%8)&q_0iN!j|u zjFdN!dixQFPkrm+qTW)T`I1-HJ=!~G9%G5&lca!xTURxN*fx0^o0?f2&CEKo@aUoH zJFM#84KKKHd%20lTa=2v>z^jS{&i&Dai58)jUQ(_Zi-al%3bnq+S_UAOa1m=Ja)aB zRo;EJY~RBtYgRM1xZ6KIe3p@Dq=DI6>v|=j^_DZyP-uo1``B_oeQfuwj7u!#y=-!RmEz<>tf#%+n82}?TgTvxlo!}e3i7gFuW>4>lS$HmKZOdsMrVO{;GV|@f-mf)Uw!I_lg7Uh9GoLvsY>nua zS~_Pfo0ggWL5-Ldcir4V_dJli^8D$gy>4s&&)RsX_wDTBM|OXAp1-;K{l0Yd^Zsv7 zJ{GQi{?h(%u~hEb12yNHs-Ij|7d%s~HhZc^3D1Sj6+I#on*K4~d^aIMY|@cSi{8kz zG)&u}9yjZ;OF-WnUX!g^EiJ!2T25VFw1zpq|4gP>h`aU6h`0P7M5cUTQ^>!;Jg;%} z-V1dGALh3#3!ClvWc9S#rza)`oD6%a!L2djMbJmqxo+;(FE8dM92a_J(aW{&r;I_y zS?{LD*P=9g|1Ik4*sr)=TA1NWW~ulWGlv*&iSD~!XDYb)?wtMP%HmLcg&!v#8O!T! zf0?l}jVtPL=Y%cBD){MG3HJA^{?~)@A>;C z{@g+4^9^hR?sPmZw%`iyv1zUGenKq=(P{A7PxpxF%p- z-M@U$;?l*;1-@0CU+qGZ59(}bNvVD+w{GT9Vb2$9cOC7#D;(?3sNnD@xH#)w%3nEN zjub18*=3b$e{W+s&)nEnKF#9yjm=>x5w_V+l)71u>vOxgYDa!B)si|Szd1R1c|kyvwRWH##tv`i7uG=tz_BZl-Ey>t@`E>m5_Jh;zhS!K<1DJGMs z65pqhL2ae`?p|4xmdG0-f+>^vRRr@^;ZswNE-Y%4_hp~#3=ZhyzY_b!%*&N2;yY&~%Hk@ewhlZxwG-?k@C;Sl`DUNW0USGfQ3*8_?iAv@#v7v8oxVw}Zi z-z4UrWWBYjP5$OvwF1NFXQ$7z7ix9ny_0v>Sm4U0pUxF;8It~P|J~cs4=nHT^8+tnFS?_x5MV!GJA`113*-Ub1#0SKKR`15vq8C#9`eD|Bm9 z!fmN2Kc!2{*1fZ@i|2OPGuP}^%+I^4l(m(Qeog9_z#8FE7jU8M(e9Q70+tu=O+FRp z>R)u8kLTbOo-nrEThw1n{hsh=gT)d5x^I)e{cW0MTl?#ZhIg(``Maq{9@)4VOYe_= z+oSk5*SL>U-Spfkfk;K;toKr~Yr`JIq|R41>|&^Yvc>-KuTQp*I{MZZXPM5}<^AP~ zR@W6q&8Nnh=XTz^ex%`Cb8LL}iz}bwQiZ|X^~rvjy^r;JmF{CS<$RrHy*g%xO8*l#MW=Bhh0NYEj$w_yroRe zH0~6`h00&YKD;@$^|@~FiDSzC=RIP3jxLVO|6UX%@+&De;>hAJt2XBqIWRB&{P%Xp z0>#2vnh(A598<0ZvQ13%m{{~?O&RNx74hv8yz+b=%=nu($#CnnB`m-`l?F@m95aR^R-0D*mVDZ}0k-`ZxXmed)jbec$&*Ig40%ShIfHnT0OxE?8&s z@a)am38DY;Rx$FYhS-cmG@+? z^nPe5Sz@#!w4!%@@7I3}bNeUx@IE>7smG`5)!O&G^l}| z3koerXW4pw#di0Te#h*ilqKc;c(P3PO=EH29I*MzCjPBzC#v3idveWH_-AYQE!G8{ku6Me(< z`A3sT&U6k@r4IHfvdO!H7btyB*!-vRq2%vc>Fdiw+Cw6ZpBG=2RhhNopku(3Imc#3 z`-*%F^j;>PU;dY87fWq<%)7&!rv$3o*WY;e%4M_kB4uS}(+#nDCm#Hj;%9w%ImLbX z$C<7N9xUD?D|(PewD$b3U#+1|nhNtd4A!ugW^QsQ{9E}()}~=^F{|(W)w@flXxIis zUi<8=6l|S&Inc64Jbe1evcF9SyH2TG)0$ELD&D+R95teOn7gxH^RG4AlRF>@dqatOlktvh-t7ohB8wzm#W9St=aXvFX zV9E9+Q;u%iyM(QAF~i+3F_TRJizg=Gq;p0%Zd-({9eFh z;9(b8pyIuwN>uWT+cIfU(f+F)1*>}{Qn{x(o>-i>VdAbMHvg{Iz0JS%|55$V;&0CO zU#bfK^}qe~Y8IRQY}as?14}$Ls}9_b6qtAC`Yqh0sUVC4@rv23X6Df0MH}&7zEHCh7#q+p@7kGED=Ey`uWuzGx7;>j5 zbDOO{IlJWN>$$UU$GGYC)QXh+w0!e^y}$yC^9L>pXkD4P>0iX{s=9YMZ=(FFvS#io zv{s3Zp3AU&O-^9I3PyuZJ=zP}15WPxIy3d&ZxP)dX0^vk%K%iHi z?Nedw`{Fn2IpPZXo%NZ%*E)5}HD5XrV9oWag2AS%VO6Ps{&wDfQfyi}a&PW#jb`7@ zE%N^kU+lZE!=*LncPYPnxa2C6_7a2Z2V;%p+P`_+s}w)5)aYy8vl?ZG?$=6M5BV;r zww&B^J!g`GNN(JG{l49ck2T!33IA{;;z`}fY}YTEUyQT+dmq2~u_fCuqo@9xSBR5! zy!qN0YkXrvd$x!)<|Q2$J=LaYzjl(xvq>Ko#+@^CS};%K$I}e{@P=g%CMZ7?-o10v zvjmNupWdzCqT_jgo2r5N!_s1=29rC9X8N(et~e^oyRChn&eyOtVE&2HxBJiEi4f@h z(Axa6gPuKxOCUG4ub+1n0hTnajU zi$m_SqWt2BZyVG9T1>4`;O734u)Owd{rk07S4Je7#=&X-l5xPk-|+ zsiuQGZS!Yee;4JZbBLE|Qtg(;R>2f+!G#-xIJe0E{Nw)Ccz)gHD+T&*-h8>TO1SUH zjb~a-o3Gg&T)wp}HUA)@W!#M^6H4AOY}Lc&{3^PFRMo$Smwo4Ko4`Q;UnB`fAE zIWvuGLU$0mUg@p3t&wuK%EK1R&s={sXTs9O_iixjHrOqDefFI3`8hRHr>?tDwrBfY zn*iaW2`jvo-tt`Sm-hC?$);?no1BKH4upT*%dzX#<|p4Lb~mKBj@cI=ankV)SfGf=$e+jy|5+Bdi5POH>0n!CaFzuO1w~Ic~G)NudO;}VX>Uq?N5Kgj%P@oGYt$VSj{<; zM@L=7&@Sxe=~cVm8nYP7da+8cRt_dMj-CRrzL(q~!m5s!_exQ>wS_Q#y~fjT^T-ydGD+qo>TUJU&{ZSQGHhW)# zX-cX2m-r=HELy(8^nju&x3Z8&%Qdexv-gTV?VWq&x>3EXeiQ3ood?e%ilXL+)d$V3 zch;Tr#f+cpQDvm6QCqXw)&;6*2kbw1ZO&&cn>`yWTn>>`-y(i5J^x~;QGbTt2^`%(VU4&b?78Jg%FjOi{hS=(}~_T$Z2ulDcUt*ZPWVeKBQf zP~?Qe)_lV_-e2D+xP$8{x5YDF4S-TA~*Hl4Xut>{cn0$YNPjr;~rYxyx-o$m8qFo=SiGZaCMy!w14|u zUn`~5efN$%cP?I*S@$ljcfpNyJ?*)XtCi(qCoF$u`qE;ms{Q|S-+V2Np8fo)pnO+} zfoIA>R{oW8(yuNCN?$b%Z?|?=D|xYGe|hZhKAY7)i+M}0%_*JbxT0`Uaj*=_)gSIQ zoia~i>gpcG%)YYsPwmI}(_baeupc?VI%RKN=~B5o);ppbJE}7)#R?{_-n4&5vO8;1 zx_qVi?&TlBwQL&-7R{Q%&T!A^#l`gf z^%;l1c0RRQ+4bQ=`M%$x)&D=1=l=huY+X^6Sl(}+^WOF+^Qj+)CK)_h_TfxKy0?3+ zk?UHoHvaDQ%QqZ-lCtKl@v*PF*XFh@|M59%=Z5J1zPJB>#s3p${k1n}cU+UONB3T) zo3cy?KV;_4{@PvD>)DmM`mpny+gr4E`k(Yzwy^Vm%gkqKvRX-5Qj@u-Zr0lN@Ki~* z^2Rgww``XGH*x;9`M*}$w|_i+y)I`ezuMJf&N(WlIij+j99qNB>g;L}T3Ej|NMX{` zDPcS2H?wrlQtr@y_;cS8vH7f0kzL83?*}f_4Y&QPu=1+dj;td`f;T+#j$(H|ed|`# znOF1u_T)ExJ6^bEd6r8&*LMaY?58>YW2Tz5UuY<^=v>%1KsO6)g1>YdlP>tdj+%pInk{9hk)Ov{bj zzyG)n-{P3OT=(eAvpl*LudCLkpEde0>&uhIHB2R2?-bVdy)b;AD!-?czhmleDb}|S zb!-KsYd$^tDm7QUr`_!9_rSC_7eB8*r@Zz5)&)jUHh_!Ky@<&e3@myjr|NTwZ1_zr(-f!CW~5ctE>~!RhIWfvL2hw7vyiu72G1*)^O}uR6^>OBR`&Lwq;rAHy&KNcKxX&%@YTf zrYi~QoZM=+E=T>w_gVI5-y}6<$*6sF{F4F_SZ8UI11SNNb!G*ouB@A6%^Op?(6Sg zDD*-rC9&a$n37h**5h+!&YhOt$oBK<>U00(>Q~J>rBgM3?b93+k)mV4Q~&o?O9YgL zb9U-q{}j!AQ)ur~);PJct2;Lx&H6UeX7cH?VaywLE}nN>)aQ{^_S(3E4>_FXo@JU; zD8}&N)uQSJ>%8Bv*DA5jiHTEQKk=^N$9of3TQ%{iOx;z#xzXjx6^)8n8hS_0_;Wbe zF#lk+dUy6fvcO914gZv;nmT-3t$E(d-0XRg%HN%=qIHReV$&Lbg=~HmkSFtLD(k7o z@7)8YseYNvY@Tw!=xg-5lPj#trM^skY!ec{{`BfnS(&@LV&{0~hi6X;zwPrY=4k$o zzNwb}f-gAC^zA>3oyo8N9K9_r{^GJHuYbub=5CzRJa=BE!0RI zH8pZhn`DrP?qj+wWot#MFkbN(0^_@T4DFC}%;g9!_=6Am8WG3h&d^vp~Dnkx|||6;^n zSuI?~y~THr>&50hZ(^o;tFj2zi0|H|X&-#t?>&=a-M{SJg6n51vur6(SUMx5r!)Jz z{);1XTHl;XdffB%?!=q(mb-nDVk$c4S+HZq*K>SkexJJU+|YV+=4JKm-u@4Jw2u9o zYc;d4Zj0d&-`NL$mv4NqYC*r*%=+|8X{#^Ik=;~Pv(06Rd;9NgccO1yR`+{yaRF~8 zzr%9r;#*7K_x}nn;5J&|A|ciwv9?X}L*)dPogWwbPnZ0>NkL)$&m;b~9?s4F{r3O; z?nlyPhF`b+nRR4l^>?|O?)JaB?(VO@z3=ba_f8Yfh~CucFfsdl+>2$o)fLsLR(B`L z%FEsi-}lM%_hSA38*MB9?2wpYd}nbU+h={T;~5i=^ssl&+PW!L@-2r!+&dwT%d@ji zU->fW@+ppW0n)PkU6<{W)519GKJ%E(`5H1m`-sTjPcw3o=jZmVIjY*>xyZ@k33Iek z!G>u&FJ-du$qTq#TY0gu@%4hz$LDX0%Cx@?om$X0L*3|$%*ts$WG8HO6T5b>uvo2X z-Auv$%aZQi>Km{9jho2hU3pib-A{MI2G8n~{-GN-CPO-u>;)%tej4cZE(R zt#06ZUaI07(oZ{z3Btrw~eXF=xTLa@thl6UIvc@ zW@c}B$a?BfLtVq&Lld;OZdi8Zn>)v%r&V{|qMI8ny;sa|Yp@nc`SkO$dfEGb&ei{V zo(is*Q?>iai>E7f-+K60)L&Y#S*qv9uD2_eKk~cEylUf{-3bP)O|G>K8nGEHn+%Kl zYdH@s-~7e&O!kzB(D&EhlnG7#AF^Nn`qL)27bmpJ?l1SN(pElqeSdAaruW7T3QEpG z5oQ{qQ?^!TsyvRYhjr&- zt4PoAw9lO>Css^v-x0oIJ8Mctax2ez{du?E|NH)*|6uw`R*is@5{ysx{k@hw%jv|W z#?w31I=c_JB=+qH)!3Gnl6v|6uG-UKs+WIWTK|9A-+S->HvWD0{$Ke8XZd#St=44; zzsg=RIA^W8C2`L0t&iA=)>D!n*BDvK`&#zjbho&aYB+6mGxP51?{SqS(Yr0?zp?*y z|4;r~`@g^c>sJ?jbKm+_V?k<)f9K_cY-du^_ivOIc`qwxc7ClQQzYBU)WE9=t6v{6 z=09|Lj)z!_=DtUJuj;O3HH|)T?vUX1hrWSv93{&nPaa@&5^2p3*&So>M0v->iw4?C zZ#VMgawSY$x?F6{lM}Cg=mb^mZ1dNccfS8-o{j$M=NDY2R@CivesfRHoHcOb^*H0( zo*%Y8kaD`Q>%N=CALs4iWm_sz?pxPy4_R%NvH12H^BE?Rmp}a36UP31hxoX!(uX<9=@V`zZc@sI{#nbN-Uq=iaFLGV$&> zxcAe^naZ21EF2dW<`whte}7Z7cSE^-MV`9;yy)tmmB*%>-^b?S;?;FGQn!Pt@6_>ea&%@_1oDOOER`!RB)>LuygL)-7(G6_-a}= z)z#V*pUc0^TX|POwt@3gPv~yzcEeX&13BIbFTMP%b4{RQ!3{mXSChO#?s1xOD9V0Y zyvxGlZFbw{n@U_qzv~Edx+y+>wRNxT*N4Hf^^(foYo+AXIm%`zY5XnuYW`i5Em-9R z`-B4FGuQc^pV$<4~ujGb}jiU(s}$68KmI#al8>dg7B=R5-!$AnK^e@FIo!eqs6 z!DCOK%U8V(t$up(Z;3v7(h0}{*nZt9fx4-@W`TyV2-)HatTK?_+ zpL6!hAHV!Hy+?eWr+FBYoM-1*f$LUQ9``d^8`=3wIW!LN(b9V2% zHRbshJ&wx@ZL2D_PdUGiD{1?)sP>NY7rrfADpeAZ_59pAxlck&tsT>17q~s$o4@a8 zTkW6V`CHo0WO9DWTs0wWr+Ge7?z=tLOD|!bz>-*4I;r6K z>AHqPk*aqN25h;ut>>C?>awS{vsW9dI*koV*Jtzh7QOF1O%7|Kf0qCHplIJV z`Rldo;g`)ACjKsuze!zx~s? zuiZ&!{oYRk!T-$swj4S6)D=up-T(H1sdm_UhkMH@ix8~lK-d{mHep(PfoeRfCcr%0*pszPk6^H~x6j^f~Lz{Vy1aFBf|{&B}$F@vzWq#w{%Y zftOQua6V26=UAfl*u`qTtznOKcCaY#?}QE7yLZG)aIySklf*RNe)7K03<;qV7AsrZ z@7B4lpg1FO@xriswRL&X^M5LYI-d{l_i}ru+x)n%(SQ2%9DVKoHWeRc&7HdU(Vh0U z?^?GmG~ab=OI!=W_it5J6jAq+he9bdiCj$miN8$+fp9qeC*D?^uL^^3L0PT>h1RW3q+4!j!m8 zr4Qw|`?F3gU|KMpdvlJ3+rO+hCmVj@E$?-o{P5#{)oQ`=>UPSSlUFy*)ct+=-!4l= zh9)!3MAg3vN6$0+h1M@`vz`$ZvnQ@MAz{hqGqpc!9Ud9aIP3DK@PSA?&rQ^5Pe>?xr@;z@(-j|B&$9ukNwcY7xjP+~}jxHAKIHa+} ztHt!R5X&Tu(6bY6ZtmUpr}O=Mmf6M=U+3)9TDq+F`vGHz&NDVY6e8Kag*8^|n=gNR zb7{zYc5YtJ6|A@}us`mD09wHs=)n3g}j@NGJOSK&U5f8Wk5Qf4%|ks7=Hxcar{ zqFy@slg)R=9pAY5`FVeXweQL_<#$>w7rxY%yUy_!$8&$n$n~D>2k)=*{1qjd{zSED zBTMk>x7@e&qaPgY&fO~OXffBm`xa}G$QDlZAJ?MuZ!E8W(LV8Kd<>sJ2Uk)$i}^~n z$$_&r?K0c!#aDOcX%eg6sr;Ic`#0s+{eAuINAq%?bx9AVJodAT$x-@fmd$6>F6cV# z{)EL<_2=h*|2DBOlss6eB(jck!zPYR zmApJo9XeN%g01-#^Z1^Z-;Vii&pYkO9Oa7MCmPXPTc>hAC_DbX`G3`&6M8+p-A(Zu z=FXN`uYEh0ZPDUQ)32swh#ucjo@E(Rymr>Qh^nd z!b_%TPg4IH>rTI!#mnYZC@|ICyZ1^&c;}Dmi5u@6eB$SJXVv4U(~VaoGMG&B`IlEX zp}b3ZZzym2w27BnufGYd*Ji89)bCRKf6RPeY|s1R#YW*NUuWg&?-mFaFzwSD*B zteBs*f*h>e_oEIdCG#v@zh~{uqH6`p8a-?KbOPp`-0Z|T=f~cKe1F7l9{z4$k>l^> zX7aWT<%Y_*mEjBe=$?OqVk%_v~E_g)y)rRlaQfBPTux7Q`lfTyP)K#lf5BQsm z7jMmOJs+ArxwFZ!a?=9dIS;n4YgzB*vvtLBvkKWg5))Q-{P>Y>XYo^c_l{p?ryN9> zyK*+XUA%^`UrOdPTSV}Rkom3iKc6uDx6s-?=GxzR@3>R#@_*;w4zrM?u z^Va*<{ic|f2U$-m?dw*R9p1fr(UB)vU3>ctw{y5iGtJr+a?v|D{g{cDveQAPZ@d02 z^u2z>-T$77;Mv1Mh9|b3cJZ9IvS!wQANB|Scepp0*6d9*oM(-RgmYaL~~XBPWy$@gU@-KNod&laU< zMQ#x3@AZ)TdcpD1QspKg4j!%UkK#tUFP56`=rOHNi|f7`%Ux#myNdJj(Fr{nvOUEN zGX+*~MCVO9#Zkg#6k+*VqHUIbg41)yinLWZcklmy@KCq<``$^3Z_098@=uvYcl5rU z*`1!@*HO||HtmhBZ`v~#tJhK6G+(UORu!8bIM?8P?X16gi&iabk@)DIBAuhC!?*do zjj~+_P*B!O{*y(>u|L-etE~Y{zmyB7rY-88HTj29}u7Ke0Ws-@THvOH+m#QOWpH3rYj`(M}PRxy3t88Uxz z`kM#6JlTr8vL20j+PmL9U2n3y5LpD;nZC1ag@!mF~CondpFpT%7i z-rTiEtAO+B<hHRvN(TQ6#1euePiUy zFQvB~n4bJ}KQ=4-+2zhD&u^Zcx9L5rv0k`c%ddqGrS|>*TW%SmT6!&JI@5v^5}TS9 z$r$o({$L=t>cMHpjq+B<4209vEHyISYW)&#FvpoVY?+gjvF%oL6i?d1tQk{|XjvV2 zz4T$%e$5omORdugWEV7jx9maKY16~U&u6P0yj3^hDN}~0 zmhOxIo`3$YRX)#56%tDdtcQS{ov=} zzpa12t^dER_VMcYjpg@i{rTm&170;I$6A*}MBB=j`veKBIX|WPqO3+#d%N`xxYu<)WBvB^tZeZOsL}Z=Vi1r8n%-=I*YP z_nq(9AFmNG#k+?0arnLlEm`Hs-y8PsxKOnqx8vI-J%Jfn{}+WU&ou~kn44nml(r|9 zS=g(?ZE2)ZlSXCv+GAsuc&N-TOKdjxotoB#W-gA*D(~D**ygg`8dHTdG4aRFi zUzfe)&_9uNu3F*O!m?MVqBKtn4D6nDf&wH;Tls>$S=6k-L z&tlKwIoE&wRCv0o_3Etnd8wywNxbO_;CcJJyU4|$lR0yN^Be9dFP^N;v^dNbqw{V- zto}RZo?T`^y>E)!Jlr|@S)%Qe#GQV>G3?uylCyo^N;S6<`@D16*LLpz&+$Go-abrr z0$ZQ~E1R5M#e=n-(l6e`ul@Vu`qP@@l2`hcv;3I1*16}$W4o=}jv6otZ_2g$`D&7m zNAJ9|hg*I{Jh>8@o*n9ME0bO<^6}H8pyU_E$?UU?V;8mWnOfBmvqMpCgV-9o;H>5H zif*UQRwu_{hlu3+cnrRzM4m6xGhmH+Gkm1R#?^69PP^_F(B zZqdluTfSG~gX_wp{eiO%{Wtv3_*uUAZu=AdC%fkVZSXtrWr2}Q7`M%iyxRERnmg=R zx9XR8H-#ITrhBCyevoqMO@F5Ojmzry+Y{~W_C$ZX=cuVYCn5f8_4WeuZ4VqJCUx}h z`I-3p#&P@H_#fHv8#Z@mANVIL!aVclF<<#>>0N(!OMUq!pj~Y7ht>Fht9OR}Tl4=9 z#ox|dU%%Djzq;7zxprmS+=RYA&-?9kUH;Sc8#8&>vKw|LXUoo;_kOSO)Fu-ni?S{A z4*&ZnE3Id{!S0~cm+W18K5RW2R}pNf&aC-h@7h?-gS`UNQ+CGO*jv5*?a9l}x8_cd z+)^m}R3XqROL>WZj$$io`(;~blv^|&dc;)neZq|pJ>+>ALDr$djv74S)UDVvtkT1aW-~#Wa zJ&7A$)vD!*Y$;;6CLJoA|HN|spXX0((+#W_c3fO9R~Ynv-S)neZ}$Gmum99Bl((IA z6uj)ECAuJ%yJes5oNoW=huB;e)-SwvsNht}?ka_c7w)ZHTq~uR-N?G>`b0jhgaDWS zh0H?ktm#`%9A@7fF);rTyPt2DUx^W?xBX@~dZ1emBiE<7;M?RHS6n8yz ztKr~%8nE*4`r=(ti7}V@skaqjv6_cXyMm_my@ZoOGSbFnr;B z+jzE&5~YKt3BBf5dwSox7DQC?t?YV}er-;`UbCspY0-u~_4npF7qqhF33g83SJt=c z$mWvvUAa!4CuX?xTskgLmRH`ertrJ1gZH`89ZR1tK9F!Nu+iT)?0Oc9Ok_4!pG1=3 zUZ&GITkoVA`kBkHGN0!|5$ z`G5W2pu&IITMm5u=A9ICGuMaLbnCX%s~6{9;C^w-=*GW!KmT77-=Ffn=I!clafSaH zp9q|KzBli+>YTYUb!${>GA?aQTFcfpS?AWfWipGmbh-p_FFw9t&g9GW!Pjo?E}7uw zw1Gb&X~WDl=OP;yJ=~g?@BTYNR^$I`6_5PJ5~Jj&&tAy+I96Z$OqsH;KN^nh@_QPowMX#O z?PzWRhNmPZ^DN7O=V{=*EphyHK=su!M_Fm?8^Z$Z-+tasZz@yQxi zM$37wC3mUX-U<5Zd3Jv;l!DzPfK|x)Obb8Zdp>zCc^e)t3%MGH#<-7*s1imLU*@W zs7c2{zWwUQzdp&ybjw*Rzg}*Q#f)B#xX!j{`tjo=ZjNvrp)+Z7?Z zF(ge;#pl$IihC`SrdQZ!-`ivNLE7ZWsUq#`Klj;L+HQaRI9m0ZhHzp4aT? zcB3-qY&t_^ zjqTlA)-uoBu%2;gaYRJ0{Ow)q4ho$-=px=`<-#Mmch~Y~-G}$zkJj6Jxc#}=wZ8`y zl%kyll4NIY+_H0`as17>?(;Xs|9!eY&;DQV{;+FD+Z`^)9$}6VHhi#J6LY))0>Q>6VS-VBg*h_6j@q#|qS&ccHc|R@xS6b}FaBZ*c zJF}84ZYQ$-UyHrHZv70&-^aWz-ZD>oR_by+E_exAD ztGRuf+jO(re$Ren{hyY#%=^ns{@cZp9G1FsZuwZ5p4_SOs<2vN)7^QIn~vRRe{}Pa z*{i9`m-8Jq?mnrRQt?_$se4B}Lsj= z4&M_2ZZ_-vwtVwpzSN^VV`_*<4a-i!T`!xTbzjfccpm8GdotSk_~(etXR4|>ZF!k_ z3?tuj$(^by+<8f+O89HuX%FomoePa?>scJdKNsJKIo!c$>FN0-!uGr8YX+Cq+AO+L zC+0?)-i~NqHuat3dX_akZv)koUzfgYh+6D%Yj+(})5~S92ZaQ-a!N=TeJCk<{_7Fv zzWK#kVqu>3%KvxYsc$&HuRZkdRs6p6^Ko}J zzu)`4(z^B!JL^i#rBd<_b6kXFCWhFuN6GwK)7Nho_wICS?zaA3mFW2G(|_dYclNzb zzhx}>I&ubc0PB_xxqJF2ubW2kZk(mEiOp$o)7?*@t$eHcI zsv_s?*+MN|wdGms=g*rbx_IJCh9HBWlVZo%Uak1bKetK5k>x6*a&&V22aU4Q*9+3$wIgZ;UjF>?-lt#xSk5eYvV@N(V+A;Z9(`oT{!UM;H#u8lFR zmazy}#(ItMbnB{zJ#!v6&YE-Y!A++ufux?U)NdA%sr!o$UwbYu!}9;{GM096@pKcL zhbuO}Xh{~H%9VcmR?{UNhf9Xba(Y=@{g_{0cob0alkI%W!8sh^=Oh`8t=*-s^0c|@ z&b=PnK7Yp6ydYLv#;uPx%g%Rxzow)#_k)~X+&%WKb#nwFwyxu9ep6(0*6G07^QHz# zZmQ{Vk?-X?+74ecUi12PTA#<9x2u{?{0{j2q`4zv^Y%C?5u5uWEZ5Jh>33||u+8Ue z-79w%>p3<&_P<_$dt#&I6q1(II?Byt9iRb zO()OOaXH(RKB>h1b?pVY<(EvDbrfnXy()NOI@S25T~*HKdZ96S_vNV9YqU7B&Njzb za7(PyW3#rJ_Ke}$#5es+y)xU}Pe>|O+=}D(*#C8I`J3|p?e5=x>^0tP_mgjzH;3D_ z^vlg2iBn#_UFH1!|Bi->7TcbCvtHoHsN%lYymX)4^IfffY!`FP%G&-k#Q$;mPx%=; z{zfuyqZu^Oi}Uu|op$yopSS7cUWpNZp*8cE z0-J7$o@Zn9>g?i#GYxNU-#ncBOorXvZ_m9K2UnzveckPwUHD;Taa^v|_6La(rS`JF zCzmst3nykZO}eOe>NlU?T=~O-v-cM5J-ouy;rU(1bbFQD!#91e>TJGR9BFjL{nWF0 zi|u@5wi=t$qAi-bUkCaoO3b$hK2o%HOtRu5t|9U$E`}rMlnO>+kOS z{Pz3XX7%NQc@KAf|6T6IRKIfD9TR1fO;0Bl>SaGa{GhpR+O-!iq5?L?i*%%NW-f?{ z{5Ey+{LSCqW|i*0;WodlDr|o5;<9~h<{R{rOS|rsJ?W|jt zu$^W8>Ayvxzst(X7L^J%?%MJv^pHz?d;RQgmaie}Si%>?+<$pe{?_z=tKTyP?%q{* zzwF#<$%B75^r?vHzCoN?FHMVa2`Vlgwe~Rm#s< zy+}w>Pa%9mzuNO>JI+ckVKxZ*ahU!5l-92k+wD1RKdyfJd&V)=ZIy<@ZfoPVjWWlvLjw`A8DM$HEv z2WIF^E!@KQ=+ug7UkW!>Z2S1Rz>iBnRrA=A@SiIr&`^}VB?aj zyR@^kf8;-TQ8V|@1>ZHD$2=$X>@-TdHu=}5lN&R#a@i`bbgr^YvpCV2{D9|N;q`U4 z#|;*8+P;(9qvI|6<=|WYo8RaEjk9bo-XrcDx5wnsWz+PVa_7C@CT?~6TO_TK{Z+QN z&cXkOyzExv?S=Qa&dr(9Q5Iw;F?E57Gvl`CONTn0n}5V?@?yRCNNxGOi8f|wiUuc5 zerRRi<=)CDpOpDT%jes*==^E3{x5&Sz5kPTSzRS#QFPbWnKPG~u^!{-yV7QT?2660 zxlfBUxBZ`f;M@NPCp%5VtqOww{9L#=`Bvl$J(uVu_LKDrYw|Z8`&zM6b@FfR*5q}! zb+0~A=l<3IKvZVMN>z<_FWSB0-UdwjG;7ywCj0BMDJMd&ZBkJ8yB6~IR@A4&)N50CWFK{-lo$PGP%)i_5Geh14k%CoS zrT6;2{Y~HB&p!KbhezhwqbWkO8oL#}udixdJzvJo?@awngDW1f8Y?XNkN&ge-lMUs z{O9+o?3vb2R1SqI*+rTgw{LY3k?EVs zQ(|q`{y!AiR}d#Tm;d_g?jqY;J(d^vlv&tnYY$%Bx%E*)%!^6;E(bKrN}cEx`~9XW z!J}-=?e%7>Ymhvv9;pZBUNP1C4g6zofl&EL?q{8n6R zW=@^|9&;;B+kg*@i!M!>z}jOt&m`iRm0Q@enW6$)&dz-_Wv$>!pYt15zX&+6Br?UT z{>i%TeG%(^6#M*6md*@4?mfxx?4Nx)jS3b)bCjEXW;6Biyx7CL|DjCvwM*`qwk?lY zm#21Y+_cior=aa!#ACZtxgWRNZoWRLbFKG;%D7h_1*iO6sq_7N?(T2X*2MD0EwZ`n z>L7Wi;l!phSpw5dHI2`{vsMgUoDhDq{M_lnxttx$zP-7o&CP%@V&3I_BXY0gcz7rRf~P(Gft@y zwltHm-M5la>wR2-VbsgE``K3wjRF=hggUdnSkd_A%(7Ue-&b1#w;WL9@Rf45ZTu1Q zy<=(BnHbI^t7qNu5pWY0x*WMxwX~djYtnMJ%4^$JXEg08tGqvzSM*+g&fJ=2wr@+T zd^1>&DQpzYG4+}idgi#n3GPb=o41xOeZsY>r!dcg&;3AiMa0f1-4!{TUe*7KH}_y~ zn5aD|CnMP*dqGEYP&Iy^kVLTb+gYdH8Q%)_U^zlcIjIolR9!z%6$*bxE?E_g@IC`0!w!ZT-JRHm8dnPtBG2e`cj-#?9Pv35Ca}|NhESK5vetmbNFlrutf2p5ia~ z{cU3G)ZY&4Jdag*aOa!uHJUH`)bZHm)%IqS7ay#6vsyf?^mgG@;cISHE0vwz6r|29 zQ43k|hGq6KmcyBxhpr*0OnUKm;F*Z;2WNL=lQ6Z^i+&0joyf7-8u%ByBa9kO*2@X<(J;LLOB>b%u| z_r%;|wQqa!gz>J3rP1pnL37nDm96GQ{EJvCckoY+-n`kJ8?Kl3%8Ncfo>0B$^8D@h z{AT{rxccUZ)raRB99OUXV6m#F>vls?lmq9?>p~uPeJk(I5n|Y6bZ+_kka&5+y`CzT z0)My!-U~ciU>C&0pvAveo^j@86U&V{>Q142nMw*L0i{*U;!$PK-16U|@G{xip|=$e$>=80UtXF5N= zH*M>)DOTJW)go6;elfkiqDE-C`h&wR?z4_ZZh7t4VRCEkht{6kJ%4|lQCfEAlV@7| zrKlNf-F-)&In1zSNfLNuWN4^6a#kinV;Qc)2)#DZ?i_@nSJ}$ zHO~Be=Aq5jupYh!<;Y~IMD{PKrwnWLihQIVODRMO@yK=vuWvnHv_YUVG4{>@7x!(? z{7hZNJWpoCHLX)MTC=kKu&-9LLBy+oWv4Fl@SQDAQVDEZb!fWCtk6T#Ds=bx$Ie;V zeO2R*lcT8d-Ho>E#qR#pGM{hSKij&{K=^us#oHWFKXW$Lk88J1KGeBW^~X*7ip28! zcH17i&)+it|I_^uM*kbtC9`ox48p;d)L-Q>831reoQs9$o%%OMXjElA2@q_wvxjH)@{Ft6wv2-~M*(s|T)! ziubX--`jNdN~lPJkouATJInv`{=V{hy&^-0==9g~d^Nm($T{xTj(S(~He=IL&Xbq! zOqqULV6xXc!3nAh*jK)*FZ1?Ywl`~1zuvc<=YNYWm8)CtHqSk&v3tJ3pOsS!LhX2$ zsJx5kkvW}g9X|D;#ZD8Cd5w9iT2}uqp1g!1-;eWv{08^d$ztwGpQR)oh_tP_a!b#0 zLQ|mnQHAXaht52(`TyR6ankoQ=hb^R&Xdv!lJdE7al;GmvYVpK1+{92v)q34O3(DO zGLqP~uEp?N!sBPBW_-`TEi$8Q^7(GY%Dp=OTx(ic@3^armtH%;;JmCjtDbLv@}wZw zOeN23YYrQeLt&@c|J`$BoBj8U<%6dQr*|`7d>}bHcbn&_+QcPuc%HDO%}EOIv{)9x z8@fQzeYhGITuFCvZyOhP$ZFQpQuZMGf z7BSnl=6unS$o={-j^{t;;)1nSY^m=aU%2MVYaj7m?T?o_kK+uTD~`W=j?c7IEC}8b zCKGh7NMgnEcn3j&ly#Yt4nEt=aWguM`$ufx|1!A)D!wd5jA`c%B*nUydra6Br671d zKU`pX=*cVcwNIu#`cr>!-rSg}mpge1*EA|NuMW!FeQ)Z6O>chf-Q?ERvQ<1Kj>S!N zfrXA^llC9i)$+}Ttoe2CRI9%iwa5Q%*?59S&2mmg^!KYV6=`uB7#Cjs>XD_{`C91~ zukO*E<)3<48E?&rSbh6AXQ#ue>UZ<&zwfONe)KneTJjIccc~@nQx5!kz}WY;CF=Qu z9haV0y{)cU?x5XtUv`JG-5g$z<%_L%E7*4($hs(|k+R&YUfZQu<@oL7+}Qc7@4B`- zIqj=pTHm_j;Iv=5$8wsVI?aANamH+c-(k7acdVNsAFyu08^`NB1xI=+?;Egtrrp&C z)$}V^E*zerqRuUPc$Qd};7kqnJz5`ZzO$O2+j4ux+27Fz6$K`;9MjsI_hRPbEu7n3 zUWBPkTBF&pMSWgj@r*9(r5EPh%hh|pVRfM9q0Rw+-N^RCuT~3LcA8;Dib9}XtKKfR8@rUIJvbqA!MM-+@QeGlVPb3apIp$(_)yZp`1Hgf zrPY(n4sOwP4AJ`V>62WaKHEYbuW&`%Z*xx@K0EO!rGV+(oFXvkQ{PxX4FXqmfdpKc( z&g3Om&rNeyJIu+*EVJnPBkO;CC%Mk{?$5tyf28FF&~t}6HG+0T!9al9~4WrE4y z_9=yNdU=i8jdJ`HdEe^%EG%y-ZE3h>-#7DFbd3D2=npD4;!ZIvXg4mj3^RBtJ1_h= z``rEaSJd*)z1cl?nt)%??iVVd7OE@wg}O?`EKB%4m3_PWd&Z;Vn!R_*x&QOce`&X| z=J{uRfevkkQd<@_(Zjez4SQp#()^CRRGp!>o`xc#-}GqFXCbC3t12^xaVSL@gz;}jmNk5 zy?K<>``dL&J4@KDEi0{({YswfE7`sC_FBtX(#v-;q#rrGjJZVMU6g`MPpGv{s~@*Q zcE_}g{sZBBkO|47)!*`Hp$Y1^|QaHGQ$7x!!1 zoY$W3J)ZS6coUyOG}miIF&%U9nGaWdQ#3Y;npn8SYuTaex(Dt&53$wER%K&~TpYQX z`=Jj1grzghbpJ0{a3tdY-s<;?2_fP3uNNKT^O!sPI4?^}>60gd4a-IN1VgUs3#taPbr`v()b7~)Cw<$CyP7|E80NEX*idV+sDkaIq=hK| zz9$EmOL~7P99poFm4)F|7xMv&h_B}6-)wvPzZb>F$47^Xg!JC;%{;48bDCf8^{+iv zsq5|cf8FSRJ6GKE(65L?lKzngW6ZavFUjlS{Cx0m#-|vz*#2~*?n!@3kM8`wI@!ki zit|RcX<@fpPW}Aa&fhipyg7-<&Ti7J^*jGmPUU;Bq*~Zwyrz$(jil9&+(%>6Vmo@3(ZVVXV=OMm?gDT;ZF0tO~+=NeTw_?U~>J1@88d8 z`K*2?xPUp&ro6}~CO@wEz2Tgb?~lq|v&hcWEs=F^cOrzh;_|#}WmkTS@6f-}9Ny{a_&7R$U#fid@5kS~ z>))=w`EzOdcj+?|)eXzCmd?3Vb}He9@zt}Yq2e#y=jPmMe*0d@{(a3~>2L48%SU&p z9hFPnvx$9Q$Kg|r(>_QjFR0kJt4r*|&Ep%@3rwmO6f9E^eYlNPWP)~;*oE?xJsX>g z_jta4uT^m9zlh7xN(l#x$8u#~f5@@;UYzv&)bztquVej8KU(`9yu9Q=erVIa=D&Nh z)_xM{Sir{j&}`L>36c@N=7=#bf7aBv=)NSs$VIkOnlt7;nVj1eaP`}Pu7n9wW~`Pw z5YgY>u=V{Ge-D#62e>EHu3GB4c<)|Ih6B7#3>)^bU-@$PE<67177xy_s=FQBQvMSy7@~|v2S*j<=yUW`{RPEhJ9TAKK0|? zwI61@V@24_r!uC=eT>7K1OV^h*>6QNU~xA{t%E3N#XFgkp@EooGy?(!vtJP$SzN~*uXERH>F5j&VICu1`h~C;$Ke{S&=l!kp zTsG&|w^yELE%vSz_+BUVrAL})ujTJ~S2FUbFgx*H<^MPgJO4`!tt7LDTW{zkkd<{NLt%zWYlg zcjm#s8*eQRXeBFLYRM_sUAf)r(S?c~`)clovDV#Rm z_t35VH@-a*Dg4&3tj+7V!Xzel$2;NgobP=%=X&%1E7NcL!#^$Oys18W`$pL6Xa`d^ z_Y^g@Y5yYmr3@12~FQ< z(6L)%>F(X-`BxR@ZT1oRmcE)}lgq2-iaX2rZa?2@ys0?Ed~(L_TlEq1e%i8bYLs!= zF7*9|h?JO9y@gBed8VIhoV>1e{?Ikq{J4Bg*!K^$ACwQWzj$+=slmQ;y=LcuB^kQ> z7oB|{n?AizGtF2yaK*JVulI%B-F^AI?ysb;k`767mAf{p|2*2i^Ty|0H)b-Oo@Uy{ z=)2NVvRvo*b}!xEhqgZN?^V_lj=Cw(>Qo$kWJS8BP=4 z%i!H%ap!j=5|_8eO^wISF;%4y1iyAEpQJUW;BWPa|6(__8R@F`O6 z#?h;mePS(PJKL*k`njD1*4xj1!Ls3m zT~n|iqcm^KUmfu&tfzOe3a)Y&d%jIWc3?A-0l@~w>h2b8X}ebC92`Eb*3vwYd^ zdp;*xnQS`ocb`ml?20F>E~}fJ%R6p0U(vL_RP26!X3p<@3xurK-+W$h zsC~kp(h%M0KJ_u8(+dqYE|1rkx>&}tZGBJEq~PmT$s0eqz0p+9E?b(jai^NeJS#q@ zPrn^o&86O7xvWs#u=zvLsZ}f!tJi(5n|)VkGD~*P)&zIOJ1?uvTcPNH0^ApD(F0}rCU+3I^>2C+w)kW9w zKRxJaY@;zn^)Az$u>b!rq;i~hI&t6l&VxIfubr3rw&Y;?Lml7y$9${`=OzjzIsB{1 zzkd8*=O#Hb|GUOh&c1DU^X5?9si?L!W)mdd&+flwcfi$YQqBEqOO#pW?kKnMzVCQ` z1xq)3`?h`iF5TK5Sv2MKE++?`&_ix}lrs&2LoeUXS$J~;e@X9>!%K5^zUwY(bts7Z z_fjC?*RKy^uQ$$Pu8iHtU*Mx3&oEKsx$E+Z$#Lc$>ws(?OT>TxnY_22GKhp?G4+tGJV%$3DuQdUuC& z+L_I_6*ow4-TC)l#kKyx3zxb6o}2vOTuXJ~iG6=AO5T=_;1X1s!#DSLyWN*vwXY`U z-+aA(e-^*Ijn=s(+7s*Jn;LDUOx1l(B^WbwyxI5jquC1$rmZ=S8naR&7V%6j{^G8$ z!N96&>HO@?3(@SSf-;&O&6fq=tGJgP-e%x#{O!B=NmakLOA@$btle%vcufhrW*(9KDS>Zw*76zd*0m<_1Ddg z?pS=)$NjcGdW4}SO4w)|AYA(>-+!K+16FL-EHdpS}}iyWJ`>C>M|{Hnb&H&c(T?lx-^+% z!pT|6^Zr|2o9UV`t2g(+o_Yr^ZSBcSwx|EzZn)I`cI#5fpWC*&f7&53Bj}pWql}o# zEPZDZR2ZziHeHqSFn%uaI^U`C0`m`7t0OyO@@pfm*Rn7e3M))l_>DE^;N}gnTssy& zPSN;Qv`6Rs_igJZD|h=bzu@1LUZq;`t=UdFf%$CU>arSSQF1Yqp z%t?FS1+f*+iykgiJ!1T*?-+ZFJ!fFS#EK{Tm^IUGv>Kdf)Sa%%d^=9z*3y$HWxlEh z*GaryYpdDz=)(_Fp7S@B2B(C@3A>zsFLFq4+5ff<9^Umo8m@{|Z|m}rYYwUjE7K@D z$rJuwib?rsp`V@0(yMo0;4?qBS`sf<5LO zNA&5!y{E4_``8w5+cE$5a{I5_{yy>l6Y=xC`kQ3=YT^G?&l@Ihxbw0nd2+Dt)r9Ec zimNA{Zj<|T=F8qIZBuo^>s*ch6go#qC+6K3ukYI`yCG{HtG~j&vZ5o8PxD#k8GGqx ziC^8T#&xOtkq9ygK&amsBHP#@Ysd)fe{P@@&pLcrj)BTZUs( z_m*zeetN?rBc#dOdabS`<7F#@g(Xgc;;Namwke+z_GBKhrMN+n%$iL={m0yL(>g_n(2=9){hx@g2fs69hGDj-s0Qp<97aB%((>i`+7513BTbxRqtJP z*R$`cZ~Nw0?`3bgLNYZ367^;my}xkmY_h{M_tn=KcE+t+pEYY@(?O}V+EY1YmbtpA z>25J#*EsO>R@>qH#IBQxnqt8R0v=3Oe7U1DafXnw76aR3zhg7pd0KVet)1vQW%04S zvtD(Wos+n6R)E$1K-RYvPmZLuxTY!}ci;ZeR^s{Vo}WSde`eQz=Kl8m|G)p6ue8N$ z?3(Yjwkniq#f);h1^e6&U2iBhy?w;d>*ZI56Mp-BzHP4msei-&|Ci@)&;R|>FV6Bn zboZ`ZY(HPWd2^}BA$4o2uC_Fv%8{IV_r&@(eNBJdw7N!PNnp10)jJhSqztyaH?Z{B z95#O`n}hbuh`sgact75MZxg(6=G(Q7E;j6zw=%;Pvud7CUatG<(hOBbmc%UobxP8a z*Y8KB{40FBl6&953w7`0=SDS%#JjrBN%JY6>Xr6gHEUBX=QRFq!+jC)msU(KzLV>p z&N#)$S$N?Vme;4BUYoaf$D$sc5?i&{>~Q7{W&Bfpmp|LGVeyeq`EK(k8w*x^*&FrM zo#&h7o$}}Z``=jK|Iugr^TEyvhq-rmSKp4?Q;~O3*KJ;)`qqmQ-FtLiSKVg|e_A|s zzu}1qw#Jt_ZC`DD9&>n6RK2ZnHA{t4`wSM}qL`CeVf>djK4>}3VHdomuuqEj&SF`^ zS4P4Cr#DS^o4Q49n}yPj8D^_K9Q|@AuT4dRv3m)Vcg3P9>sRj9VEc6BR>+0)hbull zzm_EPi!=6~^P!_fUhB@QU*q*w$^6zJ{Jxs+XDQqF+chV*PG1}va45M?AYsMq`-gi^ z$vx^hpxRmGK{&92q!#_hlS=;lFK~WV`yT3=OmC=f5VW)#X?l z39ge+O)}Y_FEFutmB_n_SGz(ZEVS2qPIE|jz1C`8t;pk7I?t=W$8X-u&y^LB@a6UM z^NhDE`AWavtGyk&){EgmR^no_ntoTwlvS&avECN1VqRvr^=6i=VB0|k?cLWbP842@ z?{0Kh<>)4zFwMYsmQI@ZjT4z=DbK{82RsP5BmUR!$R?LR7_m)=f|~=icx>(+12u~ zA1FK1cvJY*j?cZX)_T96y6Zjj@2m0uLVvf;{~!5#qWsUClMMcEKR#amHRjphi#Hd= zZk!sZ#iN_CW!I-&%WiZYN>|N7zTtpx_NZd66ku3g3^GYB5}qH4%P% z`?N%`UF+xai_&w9qr|Eu>laCXy_WnaeT{2&=<+9z*YtZQlrH?CsGRW5n%_dfWV$-(Kx} zce1O~x$oB=IhR?E|2760FFjN~JGi^(WJ~mx&8u2Y&R}a44TxjyklawOS+A2{EVJR6 zY{P|D%yVmEQ~4O34SF3t_NeiTDeRRi%er)J`^+C#=YP6>mXpElpht!3N{>~dEP`v? ztl5@sNfY?7;c7ddQjbf0khFxzQq~`<>azB3oZ6FYy!^!@bMNYcKPT25t1c_u%RKq} zyS3Nf{yVtPR==CC=W%CGUHOsscKX59!ndFZ3kuB};nsx@vsef6O^F;4lpjO6~R zZ?%Q#*@4@helQi&N?Rk!$5Z8EvWRJZ)vx0#YSiy8>l9(>%w-AG`?qn{P1kJ)f1g@6 z=gOw1Cw{jGOsU`%+W-9d@}({lkG_;hu-JZEHfp_%^WFRR+dtR;`?K>w&g0@k^1G^f z_uOg8ImFuX@7etyuD|*JhyRb`lHO0-%4mv$Q zX8Pn~7N75Z-TZs{quCNO9x-ppyzy9U#Wdl}PKFIK5>AO>{ftu`S6F&Yy0xC~?N)8M z#0^%H7pzw0s1MUBKQ)ovD`K)__M)`hKN|%@H$*Z8a?Y=srl!qxuYddVsuR1jPYZv~ zNbcPr+q~q@`r0*C_u`+oYA_tIG-Lh+T3XG-aCKuwrWCjAg|ZaK58Xx6=H6>w<;cyp zgJC+?FSjoi&nM^|-6z5L)BJ6Is;}7TbvhqHJ9V}<&t0qk#@+tsw7tK31a7QOZLaw_ zH~;pvlir!jzsVgw=6ZhrOw-Kkk`HxES+(bj8Yq3{PQIrd?3$OB6Z`1-LcJY#HH6JA zLl#%~94L-lI@v~xbHc=rXZW^WldYcouq9=RP`iR7$FgD}KGvvZnkw9(VJqXhzu!4o zEfE{zE%R{C%$N7}Rv*_}e~q;-KHQyA@0g1+yIlUtrT6v~pPpx1uQgx4U6pYL&%$LE zdd!OENA`c|wok8rZU5(c?)sF1^YMEgY%J}mTx-oFQYn70F|1cLN@g~jCp687``hs$pt4&+%zp^(&dST+tjAM(OdeS@5U~( zyps2~Keh+)zn?y5hviz=T}OT2M-?nP(ADoQBX7yulT;QcY0V&hY;NZEm`8Cb|93BP zn&W%? z-M!@b!{cqc)KlgMS6_4bmZ6+f@}uj#)7x{E$DZ{oC|4M*R1-^fG+o!T>D5WClX|;m z$Gk26?(}`bc9DaV*(b2(9e<$0z4DWqYh1I8#eLQvfy$vfT4roWW;(wzy6Ld6M(